Фильтрация элементов массива

1. Задача: вывод только чётных чисел

Условие

Из массива чисел вывести только те, которые делятся на 2 без остатка.

Пример 

Массив: [12, 7, 23, 14, 9, 18, 5, 20]
Чётные: 12 14 18 20

2. Алгоритм

Шаги:

  1. Пройти по всем элементам массива
  2. Проверить каждый элемент: число % 2 == 0
  3. Если условие выполнено → вывести число

3. Реализация 

data := [8]int{12, 7, 23, 14, 9, 18, 5, 20}

fmt.Print("Чётные числа: ")
for i := 0; i < len(data); i++ {
    if data[i] % 2 == 0 {  // Остаток от деления на 2
        fmt.Printf("%d ", data[i])
    }
}
fmt.Println()

Вывод:

Чётные числа: 12 14 18 20

4. Проверка чётности: оператор %

Модуль (остаток от деления) 

12 % 2 == 0  // true  → чётное
7  % 2 == 1  // false → нечётное
14 % 2 == 0  // true  → чётное
9  % 2 == 1  // false → нечётное

Правило: Если число % 2 == 0 → число чётное.

5. Пошаговая трассировка

Массив 

Индекс:  0   1   2   3   4   5   6   7
Данные: [12, 7, 23, 14, 9, 18, 5, 20]

Итерация по элементам

i=0: data[0] = 12

12 % 2 == 0?  → ДА
Вывод: 12

i=1: data[1] = 7

7 % 2 == 0?  → НЕТ (остаток 1)
Пропускаем

i=2: data[2] = 23

23 % 2 == 0?  → НЕТ
Пропускаем

i=3: data[3] = 14

14 % 2 == 0?  → ДА
Вывод: 14

i=4: data[4] = 9

9 % 2 == 0?  → НЕТ
Пропускаем

i=5: data[5] = 18

18 % 2 == 0?  → ДА
Вывод: 18

i=6: data[6] = 5

5 % 2 == 0?  → НЕТ
Пропускаем

i=7: data[7] = 20

20 % 2 == 0?  → ДА
Вывод: 20

Результат: 12 14 18 20 ✅

6. Применение со случайными числами 

rand.Seed(time.Now().UnixNano())

var nums [10]int
for i := 0; i < len(nums); i++ {
    nums[i] = rand.Intn(100) + 1
}

fmt.Printf("Массив: %v\n", nums)
fmt.Print("Чётные: ")
for i := 0; i < len(nums); i++ {
    if nums[i] % 2 == 0 {
        fmt.Printf("%d ", nums[i])
    }
}

Пример вывода:

Массив: [36, 34, 83, 45, 80, 14, 48, 86, 36, 33]
Чётные: 36 34 80 14 48 86 36

7. Варианты фильтрации

Только нечётные числа 

for i := 0; i < len(data); i++ {
    if data[i] % 2 != 0 {  // Остаток не равен 0
        fmt.Printf("%d ", data[i])
    }
}

Числа больше порога 

threshold := 15
for i := 0; i < len(data); i++ {
    if data[i] > threshold {
        fmt.Printf("%d ", data[i])
    }
}

Числа, кратные 3 

for i := 0; i < len(data); i++ {
    if data[i] % 3 == 0 {
        fmt.Printf("%d ", data[i])
    }
}

Положительные числа 

data := [5]int{-3, 7, -1, 0, 12}
for i := 0; i < len(data); i++ {
    if data[i] > 0 {
        fmt.Printf("%d ", data[i])
    }
}
// Вывод: 7 12

8. Подсчёт отфильтрованных элементов 

count := 0
for i := 0; i < len(data); i++ {
    if data[i] % 2 == 0 {
        count++
    }
}
fmt.Printf("Чётных чисел: %d\n", count)

9. Сохранение результата в новый массив 

data := [8]int{12, 7, 23, 14, 9, 18, 5, 20}
var evens [8]int  // Максимум столько же элементов
evenCount := 0

for i := 0; i < len(data); i++ {
    if data[i] % 2 == 0 {
        evens[evenCount] = data[i]
        evenCount++
    }
}

// Вывести только заполненную часть
fmt.Printf("Чётные: %v\n", evens[:evenCount])

Вывод:

Чётные: [12 14 18 20]

10. Отладка через debugger

Точка останова 

for i := 0; i < len(data); i++ {
    // ← breakpoint
    if data[i] % 2 == 0 {
        fmt.Printf("%d ", data[i])
    }
}

Что отслеживать

  1. i — текущий индекс
  2. data[i] — проверяемое число
  3. data[i] % 2 — остаток (0 или 1)
  4. Условие — выполнилось или нет

Совет: Если непонятно — пройдите каждую итерацию с F10.

11. Итоги

✅ Фильтрация = цикл + условие
✅ % (модуль) — проверка делимости
✅ Чётное: число % 2 == 0
✅ Нечётное: число % 2 != 0
✅ Можно комбинировать несколько условий

Паттерн:

for i := 0; i < len(array); i++ {
    if условие(array[i]) {
        // Действие с элементом
    }
}

Практика: Выведите числа, кратные 5; числа в диапазоне ; отрицательные числа.