update

2/A/Main.java

@@ -0,0 +1,86 @@
+import java.io.*;
+import java.util.*;
+
+public class Main {
+  public static void main(String[] args) throws IOException {
+    BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
+
+    String line1 = reader.readLine();
+    if (line1 == null)
+      return;
+    int n = Integer.parseInt(line1.trim());
+
+    long[] a = new long[n];
+    StringTokenizer stA = new StringTokenizer(reader.readLine());
+    for (int i = 0; i < n; i++) {
+      a[i] = Long.parseLong(stA.nextToken());
+    }
+
+    int[] types = new int[n];
+    int[] lens = new int[n];
+    int[] rewards = new int[n];
+    StringTokenizer stB = new StringTokenizer(reader.readLine());
+    for (int i = 0; i < n; i++) {
+      types[i] = Integer.parseInt(stB.nextToken());
+      if (types[i] == 1) {
+        lens[i] = 1;
+        rewards[i] = 1;
+      } else if (types[i] == 2) {
+        lens[i] = 2;
+        rewards[i] = 3;
+      } else {
+        lens[i] = 4;
+        rewards[i] = 5;
+      }
+    }
+
+    for (int i = 0; i < n - 1; i++) {
+      if (a[i] + lens[i] >= a[i + 1]) {
+        System.out.println(0);
+        return;
+      }
+    }
+
+    int m = Integer.parseInt(reader.readLine().trim());
+    long[] x = new long[m];
+    StringTokenizer stX = new StringTokenizer(reader.readLine());
+    for (int i = 0; i < m; i++) {
+      x[i] = Long.parseLong(stX.nextToken());
+    }
+
+    int[] y = new int[m];
+    StringTokenizer stY = new StringTokenizer(reader.readLine());
+    for (int i = 0; i < m; i++) {
+      y[i] = Integer.parseInt(stY.nextToken());
+    }
+
+    boolean[] overcome = new boolean[n];
+    int obsIdx = 0;
+
+    for (int j = 0; j < m; j++) {
+      long jumpStart = x[j];
+      long jumpEnd = x[j] + y[j];
+
+      while (obsIdx < n && a[obsIdx] < jumpStart) {
+        obsIdx++;
+      }
+
+      int tempIdx = obsIdx;
+      while (tempIdx < n && a[tempIdx] + lens[tempIdx] <= jumpEnd) {
+        overcome[tempIdx] = true;
+        tempIdx++;
+      }
+    }
+
+    long totalScore = 0;
+    for (int i = 0; i < n; i++) {
+      if (overcome[i]) {
+        totalScore += rewards[i];
+      } else {
+        totalScore -= 1;
+      }
+    }
+
+    System.out.println(Math.max(0, totalScore));
+  }
+}

2/A/README.md

@@ -0,0 +1,107 @@
+# A. Дино в комьютерной игре
+
+Дино решил поучаствовать в бета-тестировании игры "Бег с препятствиями". Оказалось, что игра очень сырая и совсем не готов графический интерфейс. Дино решил поиграть в игру, совершая прыжки "вслепую" - без визуального отображения дорожки с препятствиями, следуя указаниям игры.
+
+Дино совершает прыжки следуя указаниям. Нужно подсчитать, сколько очков заработал Дино, учитывая его прыжки и конфигурацию трассы. Если трасса содержит ошибки, то результатом будет **0 очков**.
+
+Правила игры:
+
+- Как играет Дино
+    - прыгает моментально по команде;
+    - может прыгнуть моментально после приземления;
+    - получает очки за каждое успешно преодоленное препятствие (даже если за один прыжок преодолевает несколько препятствий);
+    - не может подпрыгнуть в воздухе - чтобы прыгнуть еще раз, ему нужно сначала приземлиться;
+    - Дино **не просят** подпрыгивать в полете;
+
+- Получение очков: 
+    - за преодоление **камня** (длина препятствия **1 м**) - **1 очко**;
+    - за преодоление **бревна** (длина препятствия **2 м**) - **3 очка**;
+    - за преодоление **ямы** (длина препятствия **4 м**) - **5 очков**;
+
+- Потеря очков: 
+    - если Дино неправильно преодолеет любое препятствие, у него отнимут одно очко за каждое такое препятствие;
+    - итоговое количество очков не может быть меньше 0;
+
+- Успешное преодоление препятствия: 
+    - Дино начинает прыжок не позже появления препятствия (допустимо одновременно с наступанием препятствиями);
+    - чтобы преодолеть препятствие - нужны прыгнуть на расстояние большее или равное длине препятствия;
+    - прыжок Дино покрывает всю длину препятствия (допустимо, если он перепрыгнет препятствие или начнет прыжок раньше);
+
+- Трасса считается некоректной, если: 
+    - препятствие пересекаются или касаются (одно препятствие еще не закончилось, а следующее еще не началось);
+
+## Формат ввода 
+
+- в первой строке число - количество препятствий на игровой дорожке `n < 10^5`;
+- во второй строке список неубывающих `n` натуральных чисел: `a_1, a_2, ..., a_n` (1 <= a_i <= 10^6) - координаты начала препятствий;
+- третья строка содержит `n` натуральных чисел: `b_1, b_2, ..., b_n` (`1 <= b_i <= 3`) типы каждого препятствия:
+
+    - 1 -> **камень**;
+    - 2 -> **бревно**;
+    - 3 -> **яма**;
+
+- в четвертой строке - количество прыжков Дино `m < 10^5`;
+- пятая строка содержит список неубывающих `m` натуральных чисел: `x_1, x_2, ..., x_m` (`1 <= x_i < 10^6`) - координаты начала прыжков Дино;
+- в шестой строке находятся `m` натуральных чисел - дальности прыжков Дино: `y_1, y_2, ..., y_m` (`y_i in [1, 2, 4]`);
+
+## Формат вывода 
+
+Вывести целое число - результат Дино после прохождения трассы. Если трасса невалидна - вывести **0**.
+
+## Пример 1 
+
+Ввод 
+
+```
+5
+10 15 20 25 27
+3 1 2 1 1
+4
+9 14 20 25
+1 2 4 4
+```
+
+Вывод 
+
+```
+5
+```
+
+## Пример 2 
+
+Ввод 
+
+```
+3
+10 11 12
+2 1 2
+2
+9 12
+2 2
+```
+
+Вывод 
+
+```
+0
+```
+
+## Пример 3
+
+Ввод 
+
+```
+2
+14 15
+3 1
+2
+9 12
+2 2
+```
+
+Вывод 
+
+```
+0
+```
+

2/A/test1.in

@@ -0,0 +1,6 @@
+5
+10 15 20 25 27
+3 1 2 1 1
+4
+9 14 20 25
+1 2 4 4

2/A/test2.in

@@ -0,0 +1,6 @@
+3
+10 11 12
+2 1 2
+2
+9 12
+2 2

2/A/test3.in

@@ -0,0 +1,6 @@
+2
+14 15
+3 1
+2
+9 12
+2 2

2/B/Main.java

@@ -0,0 +1,70 @@
+import java.io.*;
+import java.util.*;
+
+public class Main {
+  public static void main(String[] args) throws IOException {
+    BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
+
+    String lineH = reader.readLine();
+    if (lineH == null)
+      return;
+    int h = Integer.parseInt(lineH.trim());
+
+    String lineW = reader.readLine();
+    if (lineW == null)
+      return;
+    int w = Integer.parseInt(lineW.trim());
+
+    int[] sandCounts = new int[w];
+    int[] stoneCounts = new int[w];
+
+    for (int i = 0; i < h; i++) {
+      String line = reader.readLine();
+      if (line == null)
+        break;
+      StringTokenizer st = new StringTokenizer(line);
+      for (int j = 0; j < w; j++) {
+        if (st.hasMoreTokens()) {
+          String cell = st.nextToken();
+          if (cell.equals("x")) {
+            stoneCounts[j]++;
+          } else if (cell.equals("0")) {
+            sandCounts[j]++;
+          }
+        }
+      }
+    }
+
+    for (int c = 0; c < w; c++) {
+      int initialStones = stoneCounts[c];
+      for (int k = 0; k < initialStones; k++) {
+        stoneCounts[c]--;
+
+        int currentHeight = sandCounts[c] + stoneCounts[c];
+
+        if (c < w - 1 && (sandCounts[c + 1] + stoneCounts[c + 1]) - currentHeight > 1 && sandCounts[c + 1] > 0) {
+          sandCounts[c + 1]--;
+          sandCounts[c]++;
+        } else if (c > 0 && (sandCounts[c - 1] + stoneCounts[c - 1]) - currentHeight > 1 && sandCounts[c - 1] > 0) {
+          sandCounts[c - 1]--;
+          sandCounts[c]++;
+        }
+      }
+    }
+
+    StringBuilder out = new StringBuilder();
+    for (int r = 0; r < h; r++) {
+      for (int c = 0; c < w; c++) {
+        if (r < h - sandCounts[c]) {
+          out.append("-");
+        } else {
+          out.append("0");
+        }
+        if (c < w - 1)
+          out.append(" ");
+      }
+      out.append("\n");
+    }
+    System.out.print(out);
+  }
+}

2/B/README.md

@@ -0,0 +1,87 @@
+# B. Осыпающийся песок
+
+Динозавр Дино решил почистить свой террариум от камней с помощью магнита. В террариуме находятся песок и камни, которые магнитятся магнитом. Нужно написать функцию, которая бы вынимала все камешки магнитом и оставила бы только песок.
+
+## Формат ввода 
+
+- В первой строке - высота террариума `h` (`1 <= h <= 10^6`);
+- Во второй строке - ширина террариума `w` (`1 <= w <= 10^6`);
+- Далее задается двумерный массив `h x v` <= `10^6` (террариум), состоящий из песчинок (символы `0`) и камешков (символы `x`);
+
+## Формат вывода 
+
+Вывести получившийся двумерный массив `h x w` (`1 <= h <= 10^6, 1 <= w <= 10^6`), который будет состоять из песчинок (символ `0`) и пустых ячеек (символ `-`)
+
+## Пример 1 
+
+Ввод 
+
+```
+4
+5
+0 0 0 0 x
+0 x x 0 0
+0 x 0 x 0
+x 0 0 x 0
+```
+
+Вывод 
+
+```
+- - - - -
+0 0 0 - -
+0 0 0 0 0
+0 0 0 0 0
+```
+
+## Пример 2 
+
+Ввод 
+
+```
+3
+5
+x x x x x
+0 x x 0 0
+x x x x x
+```
+
+Вывод 
+
+```
+- - - - -
+- - - - -
+0 - 0 0 -
+```
+
+## Пример 3 
+
+Ввод 
+
+```
+3
+5
+x x x x x
+x x x x x
+x x x x x
+```
+
+Вывод
+
+```
+- - - - -
+- - - - -
+- - - - -
+```
+
+## Примечание 
+
+Камешки вытаскиваются постепенно слева направо. Пока все камешки не убраны из текущего столбца - Дино не переводит магнит на следующий столбец.
+
+Камешки вытаскиваются сверху вниз (от самого верхнего до самого нижнего) по следующим правилам:
+
+- песчинки могут двигаться только вниз;
+- песчинки не перемещаются наверх даже при движении камешков наверх (считать, что камешки двигаются вверх сквозь песчинки);
+- все песчинки под действием гравитации падают вниз в своем столбце;
+- песчинки из соседних столбцов слева и справа падают в текущий столбик, если разница в высоте - больше единицы;
+- сначала падают песчинки справа, потом слева в текущую ячейку.

2/B/test1.in

@@ -0,0 +1,6 @@
+4
+5
+0 0 0 0 x
+0 x x 0 0
+0 x 0 x 0
+x 0 0 x 0

2/B/test2.in

@@ -0,0 +1,5 @@
+3
+5
+x x x x x
+0 x x 0 0
+x x x x x

2/B/test3.in

@@ -0,0 +1,5 @@
+3
+5
+x x x x x
+x x x x x
+x x x x x