From 8d1034ed9eff4942936e24561970234ebc4b74fe Mon Sep 17 00:00:00 2001
From: Shell26 <socialkii@yandex.ru>
Date: Sun, 7 Sep 2025 19:01:03 +0300
Subject: [PATCH] Fixed code block in Core section

---
 core.md | 36 ++++++++++++++++++------------------
 1 file changed, 18 insertions(+), 18 deletions(-)

diff --git a/core.md b/core.md
index 84a1e6a..89cc63b 100644
--- a/core.md
+++ b/core.md
@@ -287,10 +287,10 @@ short s = 7;    // 0000 0000 0000 0111
 ## Как применяют побитовые операции?
 
 + Маски (битовые флаги)
-+ 
+
 Маска — это число, в котором каждый бит используется как отдельный флаг (true/false). Это позволяет хранить несколько булевых значений в одной переменной int или long.
 
-`
+````
 final int READ    = 1 << 0; // 0001 = 1
 final int WRITE   = 1 << 1; // 0010 = 2
 final int EXECUTE = 1 << 2; // 0100 = 4
@@ -306,7 +306,7 @@ rights |= EXECUTE; // теперь 0111 = 7
 
 // Уберём WRITE
 rights &= ~WRITE;  // теперь 0101 = 5 (READ + EXECUTE)
-`
+````
 
 Здесь | используется для добавления флага,
 & для проверки,
@@ -314,7 +314,7 @@ rights &= ~WRITE;  // теперь 0101 = 5 (READ + EXECUTE)
 
 В Java часто вместо масок используют EnumSet, но маски полезны, если надо хранить очень много флагов компактно (например, при работе с сетью или драйверами).
 
-`
+````
 enum Permission {
     READ(1 << 0),
     WRITE(1 << 1),
@@ -323,13 +323,13 @@ enum Permission {
     final int mask;
     Permission(int mask) { this.mask = mask; }
 }
+````
 
-`
 + Быстрое умножение/деление на степени двойки
 
 Сдвиги влево и вправо работают быстрее, чем умножение/деление.
 
-`
+````
 int x = 5 << 1; // 10 (5 * 2)
 int y = 20 >> 2; // 5 (20 / 4)
 
@@ -337,39 +337,39 @@ int z = 7;
 
 int mul = z << 1; // 14 (7 * 2)
 int div = z >> 1; // 3  (7 / 2)
-`
+````
 
 + Оптимизация в алгоритмах
 __Проверка чётности__
-`
+````
 int n = 10;
 if ((n & 1) == 0) {
     System.out.println("Чётное");
 } else {
     System.out.println("Нечётное");
 }
-`
+````
 __Быстрый модуль по степени двойки__
-`
+````
 int n = 77;
 int mod = n & (8 - 1); // 77 % 8 = 5
 System.out.println(mod); // 5
-`
+````
 
 __Переключение флага (toggle)__
-`
+````
 int flags = 0;
 
 // переключаем WRITE
 flags ^= WRITE; // включили WRITE
 flags ^= WRITE; // снова выключили WRITE
+````
 
-`
 __Очистка всех флагов, кроме одного__
-`
+````
 int flags = READ | WRITE | EXECUTE;
 flags &= READ; // оставляем только READ
-`
+````
 
 __Интересные применения__
 
@@ -384,13 +384,13 @@ __Интересные применения__
 ## Разница >> и >>>
 
 >>> и <<< сдвиги без учета знака
-`
+````
 int x = -8;        // 11111111111111111111111111111000
 
 System.out.println(x >> 2);  // -2 (111111...1110) — арифметический сдвиг
 System.out.println(x >>> 2); // 1073741822 (001111...1110) — логический сдвиг
-
-`
+````
+q
 Зачем нужен >>>, если есть >>?
 
 Ответ: для работы с int/long как беззнаковыми числами (например, при работе с сетевыми протоколами или бинарными файлами).