Update

Author: 2025

README.md

@@ -3,25 +3,43 @@
 Задачи распределены по особенностям самих задач и их решений<br>
 Многие задачи могут находится одновременно в разных категориях<br>
 Ко многим задачам добавлены комментарии и пояснения для лучшего понимания<br>
-Для работы используется Java 8
+Для работы используется Java 8<br>
+Желаю вам удачно пройти алгоритмическую секцию!<br><br>
 
 
-Жми ★ если понравилось.<br>
+Жми ★ если понравилось.<br><br>
 
-Моя статистика: https://leetcode.com/u/YarTsin/ <br><br>
+Моя статистика: https://leetcode.com/u/YarTsin/ <br>
+Ссылка на проект - https://github.com/YarTsin/leetcode_java <br>
+Ссылка на GitHub Pages - <br><br>
 
 <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)
-[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>
+Примечания: мажоритарный элемент - элемент, который встречается более n/2 раз.<br>
+[1. Two Sum](src/main/java/org/example/g0001_0100/s0001_two_sum) &nbsp;&nbsp;
+[14. Longest Common Prefix](src/main/java/org/example/g0001_0100/s0014_longest_common_prefix) &nbsp;&nbsp;
+[66. Plus One](src/main/java/org/example/g0001_0100/s0066_plus_one) &nbsp;&nbsp;
+[88. Merge Sorted Array](src/main/java/org/example/g0001_0100/s0088_merge_sorted_array) &nbsp;&nbsp;
+[169. Majority Element](src/main/java/org/example/g0101_0200/s0169_majority_element) &nbsp;&nbsp;
+[217. Contains Duplicate](src/main/java/org/example/g0201_0300/s0217_contains_duplicate) &nbsp;&nbsp;
+[219. Contains Duplicate II](src/main/java/org/example/g0201_0300/s0219_contains_duplicate_ii) &nbsp;&nbsp;
+[268. Missing Number](src/main/java/org/example/g0201_0300/s0268_missing_number) &nbsp;&nbsp;
+[2900. Longest Unequal Adjacent Groups Subsequence I](src/main/java/org/example/g2801_2900/p2900_longest_unequal_adjacent_groups_subsequence_i) &nbsp;&nbsp;
+<br><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)
+[35. Search Insert Position](src/main/java/org/example/g0001_0100/s0035_search_insert_position) &nbsp;&nbsp;
+[69. Sqrtx](src/main/java/org/example/g0001_0100/s0069_sqrtx) &nbsp;&nbsp;
+[108. Convert Sorted Array To Binary Search Tree](src/main/java/org/example/g0101_0200/s0108_convert_sorted_array_to_binary_search_tree) &nbsp;&nbsp;
+<br><br>
+
+
+<b>Bits</b> <br>
+Операции с битами <br>
+[268. Missing Number](src/main/java/org/example/g0201_0300/s0268_missing_number) &nbsp;&nbsp;
+[338. Counting Bits](src/main/java/org/example/g0301_0400/s0338_counting_bits) &nbsp;&nbsp;
+<br><br>
 
 <b>Dynamic Programming</b> <br>
 Динамическое программирование (DP) — это метод решения задач, 
@@ -34,42 +52,67 @@
 В Java обычно делают так: создают массив или таблицу для хранения результатов подзадач,
 заполняют этот массив постепенно, начиная с самых простых случаев, 
 используют сохранённые результаты для решения более сложных задач.<br>
-
+(как я понимаю, это часто похоже на работу с указателями) <br>
+[70. Climbing Stairs](src/main/java/org/example/g0001_0100/s0070_climbing_stairs)  &nbsp;&nbsp;
+[746. Min Cost Climbing Stairs](src/main/java/org/example/g0701_0800/s0746_min_cost_climbing_stairs) &nbsp;&nbsp;
+[509. Fibonacci Number](src/main/java/org/example/g0501_0600/s0509_fibonacci_number) &nbsp;&nbsp;
+[1137. N th Tribonacci Number](src/main/java/org/example/g1101_1200/s1137_n_th_tribonacci_number) &nbsp;&nbsp;
+<br><br>
 
 <b>Hash Table</b><br>
 В этом разделе находятся задачи, использующие для решения хеш таблицы,<br>
 например HashMap<br>
-[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)
-
+[1. Two Sum](src/main/java/org/example/g0001_0100/s0001_two_sum) &nbsp;&nbsp;
+[290. Word Pattern](src/main/java/org/example/g0201_0300/s0290_word_pattern) &nbsp;&nbsp;
+<br><br>
+
+<b>Linked List</b><br>
+Задачи, связанные со связанными списками<br>
+Примечания: алгоритм "Черепахи и Зайца" - Floyd's Cycle-Finding Algorithm<br>
+[141. Linked List Cycle](src/main/java/org/example/g0101_0200/s0141_linked_list_cycle) &nbsp;&nbsp;
+[160. Intersection Of Two Linked Lists](src/main/java/org/example/g0101_0200/s0160_intersection_of_two_linked_lists) &nbsp;&nbsp;
+<br><br>
+
+<b>Math</b><br>
+Математические структуры и задачи<br>
+Примечения: Палиндром - это число (или строка), которое читается одинаково в обоих направлениях.<br>
+[9. Palindrome number](src/main/java/org/example/g0001_0100/s0009_palindrome_number) &nbsp;&nbsp;
+[69. Sqrtx](src/main/java/org/example/g0001_0100/s0069_sqrtx) &nbsp;&nbsp;
+[118. Pascals Triangle](src/main/java/org/example/g0101_0200/s0118_pascals_triangle) &nbsp;&nbsp;
+[119. Pascals Triangle II](src/main/java/org/example/g0101_0200/s0119_pascals_triangle_ii) &nbsp;&nbsp;
+[202. Happy Number](src/main/java/org/example/g0201_0300/s0202_happy_number) &nbsp;&nbsp;
+[1025. Divisor game](src/main/java/org/example/g1001_1100/s1025_divisor_game) &nbsp;&nbsp;
+<br><br>
 
 
 <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) &nbsp;&nbsp;
+[27. Remove Element](src/main/java/org/example/g0001_0100/s0027_remove_element) &nbsp;&nbsp;
+[141. Linked List Cycle](src/main/java/org/example/g0101_0200/s0141_linked_list_cycle) &nbsp;&nbsp;
+[392. Is Subsequence](src/main/java/org/example/g0301_0400/s0392_is_subsequence) &nbsp;&nbsp;
+<br><br>
 
 <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)
-
+[108. Convert Sorted Array To Binary Search Tree](src/main/java/org/example/g0101_0200/s0108_convert_sorted_array_to_binary_search_tree) &nbsp;&nbsp;
+[509. Fibonacci Number](src/main/java/org/example/g0501_0600/s0509_fibonacci_number) &nbsp;&nbsp;
+[1137. N th Tribonacci Number](src/main/java/org/example/g1101_1200/s1137_n_th_tribonacci_number) &nbsp;&nbsp;
+<br><br>
 
 <b>String</b><br>
 В этом разделе находятся задачи, использующие строки<br>
-[14. Longest Common Prefix](src/main/java/org/example/g0001_0100/s0014_longest_common_prefix)
+Примечания: Подпоследовательность (subsequence) - это последовательность символов,
+которая появляется в том же порядке, но не обязательно подряд.<br>
+[14. Longest Common Prefix](src/main/java/org/example/g0001_0100/s0014_longest_common_prefix) &nbsp;&nbsp;
+[290. Word Pattern](src/main/java/org/example/g0201_0300/s0290_word_pattern) &nbsp;&nbsp;
+[392. Is Subsequence](src/main/java/org/example/g0301_0400/s0392_is_subsequence) &nbsp;&nbsp;
+[1668. Maximum Repeating Substring](src/main/java/org/example/g1601_1700/s1668_maximum_repeating_substring) &nbsp;&nbsp;
+[2900. Longest Unequal Adjacent Groups Subsequence I](src/main/java/org/example/g2801_2900/p2900_longest_unequal_adjacent_groups_subsequence_i) &nbsp;&nbsp;
+<br><br>
 
 <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)
-
-
-
-
-<b>Dynamic Programming</b> <br>
-Раздел на leetcode https://leetcode.com/problem-list/dynamic-programming/<br>
-Раздел в проекте - [src/main/java/org/example/dynamic_programming](src/main/java/org/example/dynamic_programming)<br><br>
+[108. Convert Sorted Array To Binary Search Tree](src/main/java/org/example/g0101_0200/s0108_convert_sorted_array_to_binary_search_tree) &nbsp;&nbsp;
+<br><br>

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

@@ -0,0 +1,38 @@
+package org.example.g0001_0100.s0009_palindrome_number;
+
+/**
+ * Является ли целое число палиндромом.
+ * Палиндром - это число (или строка), которое читается одинаково в обоих направлениях.
+ *
+ * Примеры:
+ * 121 → true
+ * -121 → false (из-за минуса)
+ * 10 → false
+ */
+class Solution {
+    /**
+     * Проверяет, является ли число палиндромом
+     * @param x число для проверки
+     * @return true, если число является палиндромом, иначе false
+     */
+    public boolean isPalindrome(int x) {
+        // Отрицательные числа не могут быть палиндромами
+        // Также числа, оканчивающиеся на 0 (кроме 0) не могут быть палиндромами
+        if (x < 0 || (x % 10 == 0 && x != 0)) {
+            return false;
+        }
+
+        int reversedHalf = 0;
+
+        // Переворачиваем половину числа
+        while (x > reversedHalf) {
+            int lastDigit = x % 10; // Получаем последнюю цифру
+            reversedHalf = reversedHalf * 10 + lastDigit; // Добавляем цифру к перевернутой половине
+            x /= 10; // Удаляем последнюю цифру из исходного числа
+        }
+
+        // Для чисел с четным количеством цифр x == reversedHalf
+        // Для нечетного количества цифр x == reversedHalf / 10 (средняя цифра не важна)
+        return x == reversedHalf || x == reversedHalf / 10;
+    }
+}

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

@@ -0,0 +1,89 @@
+9\. Palindrome Number
+
+Easy
+
+Given an integer `x`, return `true` if `x` is palindrome integer.
+An integer is a **palindrome** when it reads the same backward as forward. 
+For example, `121` is palindrome while `123` is not.
+
+**Example 1:**
+**Input:** x = 121
+**Output:** true 
+
+**Example 2:**
+**Input:** x = -121
+**Output:** false
+
+**Explanation:** From left to right, it reads -121. From right to left, it becomes 121-. Therefore it is not a palindrome. 
+
+**Example 3:**
+**Input:** x = 10
+**Output:** false
+**Explanation:** Reads 01 from right to left. Therefore it is not a palindrome. 
+
+**Example 4:**
+**Input:** x = -101
+**Output:** false 
+
+**Constraints:**
+*   <code>-2<sup>31</sup> <= x <= 2<sup>31</sup> - 1</code>
+**Follow up:** Could you solve it without converting the integer to a string?
+
+To solve the Palindrome Number problem in Java using a `Solution` class, we'll follow these steps:
+
+1. Define a `Solution` class with a method named `isPalindrome`.
+2. Handle special cases where `x` is negative or divisible by 10 but not equal to zero, as they cannot be palindromes.
+3. Initialize variables to keep track of the reversed number (`reversed`) and the original number (`original`).
+4. Iterate through the digits of the original number `x`:
+   - Extract the least significant digit using the modulo operator and append it to the reversed number.
+   - Update `original` by removing the least significant digit using integer division.
+5. Check if the reversed number is equal to the original number. If so, return `true`; otherwise, return `false`.
+
+Here's the implementation:
+
+```java
+public class Solution {
+
+    public boolean isPalindrome(int x) {
+        // Special cases:
+        // As discussed, negative numbers are not palindromes.
+        // Also, if the last digit of the number is 0, it can't be a palindrome unless the number is 0 itself.
+        if (x < 0 || (x % 10 == 0 && x != 0)) {
+            return false;
+        }
+
+        int reversed = 0;
+        int original = x;
+
+        while (original > reversed) {
+            int digit = original % 10;
+            reversed = reversed * 10 + digit;
+            original /= 10;
+        }
+
+        // When the length is an odd number, we can get rid of the middle digit by reversed / 10
+        // For example when the input is 12321, at the end of the while loop we get x = 12, reversed = 123,
+        // since the middle digit doesn't matter in palidrome(it will always equal to itself), we can simply get rid of it.
+        return original == reversed || original == reversed / 10;
+    }
+
+    public static void main(String[] args) {
+        Solution solution = new Solution();
+
+        // Test cases
+        int x1 = 121;
+        System.out.println("Example 1 Output: " + solution.isPalindrome(x1));
+
+        int x2 = -121;
+        System.out.println("Example 2 Output: " + solution.isPalindrome(x2));
+
+        int x3 = 10;
+        System.out.println("Example 3 Output: " + solution.isPalindrome(x3));
+
+        int x4 = -101;
+        System.out.println("Example 4 Output: " + solution.isPalindrome(x4));
+    }
+}
+```
+
+This implementation provides a solution to the Palindrome Number problem in Java.

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

@@ -0,0 +1,10 @@
+Подходы к решению
+1. Преобразование в строку (простой, но не оптимальный)
+Самый простой способ - преобразовать число в строку и
+сравнить ее с перевернутой версией. Однако это требует
+дополнительной памяти для строки.
+
+2. Математический подход (оптимальный)
+Более эффективное решение - перевернуть половину числа
+и сравнить с оставшейся половиной. Это работает без преобразования
+в строку и использует O(1) дополнительной памяти.

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

@@ -0,0 +1,47 @@
+package org.example.g0001_0100.s0069_sqrtx;
+
+/**
+ * LeetCode Easy
+ * Необходимо вычислить целочисленный квадратный корень из
+ * неотрицательного числа
+ *
+ * Примеры
+ * 4 → 2
+ * 8 → 2 (так как 2.828... округляется вниз до 2)
+ * 0 → 0
+ *
+ * Эффективное решение - бинарный поиск
+ */
+class Solution {
+    /**
+     * Вычисляет целочисленный квадратный корень из x
+     * @param x неотрицательное целое число
+     * @return квадратный корень, округленный вниз
+     */
+    public int mySqrt(int x) {
+        // Обработка крайних случаев
+        if (x < 2) {
+            return x;
+        }
+
+        // Устанавливаем границы бинарного поиска
+        int left = 1;
+        int right = x / 2; // Квадратный корень не может быть больше x/2 при x > 1
+
+        while (left <= right) {
+            int mid = left + (right - left) / 2; // Предотвращаем переполнение
+            long square = (long) mid * mid; // Используем long для больших чисел
+
+            if (square == x) {
+                return mid; // Нашли точный квадратный корень
+            } else if (square < x) {
+                left = mid + 1; // Ищем в правой половине
+            } else {
+                right = mid - 1; // Ищем в левой половине
+            }
+        }
+
+        // Возвращаем right, так как left превысил right
+        return right;
+    }
+}

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

@@ -0,0 +1,20 @@
+69\. Sqrt(x)
+
+Easy
+Given a non-negative integer `x`, compute and return _the square root of_ `x`.
+Since the return type is an integer, the decimal digits are **truncated**, and only **the integer part** of the result is returned.
+
+**Note:** You are not allowed to use any built-in exponent function or operator, such as `pow(x, 0.5)` or `x ** 0.5`.
+
+**Example 1:**
+**Input:** x = 4
+**Output:** 2 
+
+**Example 2:**
+**Input:** x = 8
+**Output:** 2
+
+**Explanation:** The square root of 8 is 2.82842..., and since the decimal part is truncated, 2 is returned.
+
+**Constraints:**
+*   <code>0 <= x <= 2<sup>31</sup> - 1</code>

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

@@ -0,0 +1,8 @@
+Подходы к решению
+1. Линейный поиск (простой, но неэффективный)
+Перебираем числа от 0 до x, пока квадрат числа не превысит x. Сложность O(n).
+
+2. Бинарный поиск (оптимальный)
+Используем бинарный поиск для нахождения корня, что дает сложность O(log n).
+
+===========