Update

Author: 2025

README.md

@@ -12,28 +12,60 @@
 
 <b>Array</b> <br> 
 В этом разделе чаще всего находятся находятся задачи, использующие массивы <br>
-[1. Two Sum](src/main/java/org/example/g0001_0100/s0001_two_sum),
-[14. Longest Common Prefix](src/main/java/org/example/g0001_0100/s0014_longest_common_prefix),
+[1. Two Sum](src/main/java/org/example/g0001_0100/s0001_two_sum)
+[14. Longest Common Prefix](src/main/java/org/example/g0001_0100/s0014_longest_common_prefix)
+[66. Plus One](src/main/java/org/example/g0001_0100/s0066_plus_one)
+[88. Merge Sorted Array](src/main/java/org/example/g0001_0100/s0088_merge_sorted_array)
+<br>
+
+<b>Binary search</b> <br>
+Здесь помещаем задачи с бинарным поиском<br>
+[35. Search Insert Position](src/main/java/org/example/g0001_0100/s0035_search_insert_position)
+[108. Convert Sorted Array To Binary Search Tree](src/main/java/org/example/g0101_0200/s0108_convert_sorted_array_to_binary_search_tree)
+
+<b>Dynamic Programming</b> <br>
+Динамическое программирование (DP) — это метод решения задач, 
+которые можно разбить на похожие подзадачи. Идея в том, 
+чтобы не считать одну и ту же подзадачу несколько раз, 
+а сохранить её результат и использовать повторно. <br>
+Пример: вычисление чисел Фибоначчи. Вместо того, чтобы каждый 
+раз вычислять число заново, мы запоминаем уже посчитанные значения 
+и берём их из памяти.<br>
+В Java обычно делают так: создают массив или таблицу для хранения результатов подзадач,
+заполняют этот массив постепенно, начиная с самых простых случаев, 
+используют сохранённые результаты для решения более сложных задач.<br>
+
 
 <b>Hash Table</b><br>
 В этом разделе находятся задачи, использующие для решения хеш таблицы,<br>
 например HashMap<br>
-[1. Two Sum](src/main/java/org/example/g0001_0100/s0001_two_sum),
+[1. Two Sum](src/main/java/org/example/g0001_0100/s0001_two_sum)
+
+<b>Math - математические структуры</b><br>
+[118. Pascals Triangle](src/main/java/org/example/g0101_0200/s0118_pascals_triangle)
+[119. Pascals Triangle II](src/main/java/org/example/g0101_0200/s0119_pascals_triangle_ii)
+
+
 
 <b>Pointers - Указатели</b><br>
-Здесь указываем задачи, которые используют указатели для решения задачи<br>
-[26. Remove Duplicates From Sorted Array](src/main/java/org/example/g0001_0100/s0026_remove_duplicates_from_sorted_array),
-[27. Remove Element](src/main/java/org/example/g0001_0100/s0027_remove_element),
+Здесь указываем задачи, которые используют указатели для решения задач<br>
+[26. Remove Duplicates From Sorted Array](src/main/java/org/example/g0001_0100/s0026_remove_duplicates_from_sorted_array)
+[27. Remove Element](src/main/java/org/example/g0001_0100/s0027_remove_element)
 
 
+<b>Recursion - Рекурсия</b><br>
+Сюда помещаем примеры задач, использующих рекурсию
+[108. Convert Sorted Array To Binary Search Tree](src/main/java/org/example/g0101_0200/s0108_convert_sorted_array_to_binary_search_tree)
 
 
 <b>String</b><br>
 В этом разделе находятся задачи, использующие строки<br>
-[14. Longest Common Prefix](src/main/java/org/example/g0001_0100/s0014_longest_common_prefix),
-
-
+[14. Longest Common Prefix](src/main/java/org/example/g0001_0100/s0014_longest_common_prefix)
 
+<b>Tree</b><br>
+Здесь помещаем задачи, которые используют деревья для решения,<br>
+например TreeNode.<br>
+[108. Convert Sorted Array To Binary Search Tree](src/main/java/org/example/g0101_0200/s0108_convert_sorted_array_to_binary_search_tree)
 
 
 

src/main/java/org/example/g0001_0100/s0066_plus_one/Solution.java

@@ -0,0 +1,30 @@
+package org.example.g0001_0100.s0066_plus_one;
+
+/**
+ * LeetCode Easy
+ * Нужно вернуть массив увеличенный на 1
+ * [1, 2, 3] → [1, 2, 4] (123 + 1 = 124)
+ * или добавить 1 и вернуть новый массив
+ * [9, 9, 9] → [1, 0, 0, 0] (999 + 1 = 1000)
+ */
+public class Solution {
+    public int[] plusOne(int[] digits) {
+        int n = digits.length;
+
+        //идем от конца массива к началу
+        for (int i = n - 1; i >= 0; i--) {
+            // если цифры обычные, увеличиваем на 1
+            if (digits[i] < 9) {
+                digits[i]++;
+                return digits;
+            } else {
+                digits[i] = 0;
+            }
+        }
+
+        // Если последняя (первая) цифра была 9 - попадаем сюда
+        int[] newDigits = new int[n + 1];
+        newDigits[0] = 1;
+        return newDigits;
+    }
+}

src/main/java/org/example/g0001_0100/s0066_plus_one/condition.md

@@ -0,0 +1,41 @@
+You are given a **large integer** represented as an integer array `digits`, where each `digits[i]` is the `ith` digit of the integer. The digits are ordered from most significant to least significant in left-to-right order. The large integer does not contain any leading `0`'s.
+
+Increment the large integer by one and return _the resulting array of digits_.
+
+**Example 1:**
+
+**Input:** digits = [1,2,3]
+
+**Output:** [1,2,4]
+
+**Explanation:** The array represents the integer 123. Incrementing by one gives 123 + 1 = 124. Thus, the result should be [1,2,4]. 
+
+**Example 2:**
+
+**Input:** digits = [4,3,2,1]
+
+**Output:** [4,3,2,2]
+
+**Explanation:** The array represents the integer 4321. Incrementing by one gives 4321 + 1 = 4322. Thus, the result should be [4,3,2,2]. 
+
+**Example 3:**
+
+**Input:** digits = [0]
+
+**Output:** [1]
+
+**Explanation:** The array represents the integer 0. Incrementing by one gives 0 + 1 = 1. Thus, the result should be [1]. 
+
+**Example 4:**
+
+**Input:** digits = [9]
+
+**Output:** [1,0]
+
+**Explanation:** The array represents the integer 9. Incrementing by one gives 9 + 1 = 10. Thus, the result should be [1,0]. 
+
+**Constraints:**
+
+*   `1 <= digits.length <= 100`
+*   `0 <= digits[i] <= 9`
+*   `digits` does not contain any leading `0`'s.

src/main/java/org/example/g0001_0100/s0070_climbing_stairs/Solution.java

@@ -0,0 +1,31 @@
+package org.example.g0001_0100.s0070_climbing_stairs;
+
+/**
+ * Задача: вам нужно подняться по лестнице из n ступенек.
+ * Каждый раз вы можете сделать либо 1 шаг, либо 2 шага.
+ * Сколько существует различных способов подняться на вершину?
+ *
+ * Пример:
+ * n = 2 → 2 способа (1+1 или 2)
+ * n = 3 → 3 способа (1+1+1, 1+2, 2+1)
+ *
+ * todo пока не очень понятно
+ */
+public class Solution {
+    public int climbStairs(int n) {
+        if (n <= 2) {
+            return n;
+        }
+
+        int[] dp = new int[n + 1];
+        dp[1] = 1; // Один способ для 1 ступеньки
+        dp[2] = 2; // Два способа для 2 ступенек
+
+        for (int i = 3; i <= n; i++) {
+            // Количество способов для i ступенек равно сумме способов для (i-1) и (i-2)
+            dp[i] = dp[i - 1] + dp[i - 2];
+        }
+
+        return dp[n];
+    }
+}

src/main/java/org/example/g0001_0100/s0070_climbing_stairs/complexity.md

@@ -0,0 +1,21 @@
+**Time Complexity (Big O Time):**
+
+1. The program uses dynamic programming with a loop that runs from 2 to `n-1` to fill in the `cache` array.
+
+2. The loop iterates through all steps from 2 to `n-1`, and for each step `i`, it calculates the number of distinct ways by summing the values from the previous two steps (`cache[i-1]` and `cache[i-2]`).
+
+3. Therefore, the loop runs in O(n) time because it iterates through all `n` steps once.
+
+4. The other operations in the program, such as array assignments and comparisons, are constant time operations and do not depend on the input value `n`.
+
+5. Overall, the time complexity of the program is O(n), where 'n' is the number of steps in the staircase.
+
+**Space Complexity (Big O Space):**
+
+1. The program uses an integer array `cache` of size `n` to store the intermediate results of the number of distinct ways to climb each step.
+
+2. Therefore, the space complexity is O(n) because the space usage is directly proportional to the input value `n`.
+
+3. The space complexity is dominated by the `cache` array, and it scales linearly with the size of the input staircase.
+
+In summary, the time complexity of the provided program is O(n), and the space complexity is also O(n), where 'n' is the number of steps in the staircase. The program efficiently calculates the number of distinct ways to climb the staircase using dynamic programming with memoization.

src/main/java/org/example/g0001_0100/s0070_climbing_stairs/condition.md

@@ -0,0 +1,51 @@
+You are climbing a staircase. It takes `n` steps to reach the top.
+Each time you can either climb `1` or `2` steps. 
+In how many distinct ways can you climb to the top?
+
+**Example 1:**
+**Input:** n = 2
+**Output:** 2
+
+**Explanation:** There are two ways to climb to the top. 1. 1 step + 1 step 2. 2 steps 
+
+**Example 2:**
+**Input:** n = 3
+**Output:** 3
+
+**Explanation:** There are three ways to climb to the top. 1. 1 step + 1 step + 1 step 2. 1 step + 2 steps 3. 2 steps + 1 step 
+
+**Constraints:**
+
+*   `1 <= n <= 45`
+
+To solve the "Climbing Stairs" problem in Java with the Solution class, follow these steps:
+
+1. Define a method `climbStairs` in the `Solution` class that takes an integer `n` as input and returns the number of distinct ways to climb to the top of the staircase with `n` steps.
+2. Initialize an array `dp` of size `n+1` to store the number of distinct ways to reach each step.
+3. Set `dp[0] = 1` and `dp[1] = 1` since there is only one way to reach the first and second steps.
+4. Iterate over the steps from `2` to `n`:
+   - At each step `i`, the number of distinct ways to reach step `i` is the sum of the number of ways to reach steps `i-1` and `i-2`.
+   - Store this sum in `dp[i]`.
+5. Return `dp[n]`, which represents the number of distinct ways to climb to the top of the staircase with `n` steps.
+
+Here's the implementation of the `climbStairs` method in Java:
+
+```java
+class Solution {
+    public int climbStairs(int n) {
+        if (n == 1) return 1;
+        
+        int[] dp = new int[n + 1];
+        dp[0] = 1;
+        dp[1] = 1;
+        
+        for (int i = 2; i <= n; i++) {
+            dp[i] = dp[i - 1] + dp[i - 2];
+        }
+        
+        return dp[n];
+    }
+}
+```
+
+This implementation efficiently calculates the number of distinct ways to climb the stairs using dynamic programming, with a time complexity of O(n) and a space complexity of O(n).

src/main/java/org/example/g0001_0100/s0070_climbing_stairs/info.txt

@@ -0,0 +1,52 @@
+Подходы к решению
+1. Рекурсия с мемоизацией
+Прямолинейный рекурсивный подход, но с запоминанием результатов для избежания повторных вычислений.
+
+2. Динамическое программирование (оптимальное)
+Используем массив для хранения промежуточных результатов.
+
+3. Оптимизированное ДП (константная память)
+Используем только несколько переменных вместо массива.
+
+==============
+
+Объяснение для новичка
+Базовые случаи:
+
+Для 1 ступеньки - только 1 способ
+Для 2 ступенек - 2 способа (1+1 или 2)
+
+Массив dp:
+dp[i] хранит количество способов подняться на i-ю ступеньку
+Каждый следующий элемент вычисляется как сумма двух предыдущих
+
+Формула:
+dp[i] = dp[i-1] + dp[i-2]
+Потому что на i-ю ступеньку можно попасть либо с (i-1) (сделав 1 шаг), либо с (i-2) (сделав 2 шага)
+
+Временная сложность
+O(n) - один проход по всем ступенькам от 3 до n.
+
+Пространственная сложность
+O(n) - для хранения массива dp.
+
+=========
+public class Solution {
+    public int climbStairs(int n) {
+        if (n <= 2) {
+            return n;
+        }
+
+        int prev1 = 1; // Для i-1
+        int prev2 = 2; // Для i-2
+        int current = 0;
+
+        for (int i = 3; i <= n; i++) {
+            current = prev1 + prev2;
+            prev1 = prev2;
+            prev2 = current;
+        }
+
+        return current;
+    }
+}

src/main/java/org/example/g0001_0100/s0088_merge_sorted_array/Solution.java

@@ -0,0 +1,35 @@
+package org.example.g0001_0100.s0088_merge_sorted_array;
+
+/**
+ * LeetCode Easy
+ * Объединение двух отсоритированных массивов
+ * Даны два отсортированных массива:
+ * nums1 длиной m + n, где m — количество элементов, а n — зарезервированные нули.
+ * nums2 длиной n.
+ * Нужно объединить nums2 в nums1 так, чтобы итоговый массив остался отсортированным.
+ *
+ * Пример:
+ * nums1 = [1, 2, 3, 0, 0, 0], m = 3
+ * nums2 = [2, 5, 6], n = 3
+ * Результат: [1, 2, 2, 3, 5, 6]
+ */
+public class Solution {
+    public void merge(int[] nums1, int m, int[] nums2, int n) {
+        // Указатель на конец реальных элементов в nums1 (не нулей)
+        int i = m - 1;
+        // Указатель на конец nums2
+        int p2 = n - 1;
+        // Указатель на конец nums1 (включая нули
+        int j = m + n - 1;
+
+        // пока есть элементы в nums2
+        while (p2 >= 0) {
+            // Если в nums1 остались элементы И текущий в nums1 больше, чем в nums2
+            if (i >= 0 && nums1[i] > nums2[p2]) {
+                nums1[j--] = nums1[i--]; // Записываем элемент из nums1
+            } else {
+                nums1[j--] = nums2[p2--]; // Иначе записываем элемент из nums2
+            }
+        }
+    }
+}

src/main/java/org/example/g0001_0100/s0088_merge_sorted_array/condition.md

@@ -0,0 +1,34 @@
+You are given two integer arrays `nums1` and `nums2`, 
+sorted in **non-decreasing order**, and two 
+integers `m` and `n`, representing the number 
+of elements in `nums1` and `nums2` respectively.
+
+**Merge** `nums1` and `nums2` into a single array sorted 
+in **non-decreasing order**.
+The final sorted array should not be returned by the function, 
+but instead be _stored inside the array_ `nums1`. To accommodate this, `nums1` has a length of `m + n`, where the first `m` elements denote the elements that should be merged, and the last `n` elements are set to `0` and should be ignored. `nums2` has a length of `n`.
+
+**Example 1:**
+**Input:** nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
+**Output:** [1,2,2,3,5,6]
+**Explanation:** The arrays we are merging are [1,2,3] and [2,5,6]. The result of the merge is [1,2,2,3,5,6] with the underlined elements coming from nums1. 
+
+**Example 2:**
+**Input:** nums1 = [1], m = 1, nums2 = [], n = 0
+**Output:** [1]
+**Explanation:** The arrays we are merging are [1] and []. The result of the merge is [1]. 
+
+**Example 3:**
+**Input:** nums1 = [0], m = 0, nums2 = [1], n = 1
+**Output:** [1]
+**Explanation:** The arrays we are merging are [] and [1]. The result of the merge is [1]. Note that because m = 0, there are no elements in nums1. The 0 is only there to ensure the merge result can fit in nums1. 
+
+**Constraints:**
+
+*   `nums1.length == m + n`
+*   `nums2.length == n`
+*   `0 <= m, n <= 200`
+*   `1 <= m + n <= 200`
+*   <code>-10<sup>9</sup> <= nums1[i], nums2[j] <= 10<sup>9</sup></code>
+
+**Follow up:** Can you come up with an algorithm that runs in `O(m + n)` time?