Инструкции к выполнению

Пошаговое руководство по созданию программ с циклическими структурами

📋 Подготовка к работе

Откройте Visual Studio
Запустите Visual Studio 2022
Создайте новый проект
File → New → Project → Console App (.NET)
Назовите проект
Используйте имя "Lab4_CyclicAlgorithms"
Подготовьте среду
Откройте Solution Explorer и настройте редактор кода

🎯 Этап 1: Изучение теории циклов

Основные понятия

Цикл — управляющая конструкция, которая позволяет многократно выполнять блок кода до тех пор, пока выполняется определённое условие.

Основные элементы цикла:

Инициализация — установка начальных значений
Условие продолжения — логическое выражение
Тело цикла — повторяющиеся действия
Модификация — изменение управляющей переменной

📝 Этап 2: Задание 1 - Цикл while

Задача: Вычисление факториала

Напишите программу для вычисления факториала числа используя цикл while

using System;

namespace Lab4_CyclicAlgorithms
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("=== Вычисление факториала (while) ===");
            
            Console.Write("Введите число: ");
            int n = Convert.ToInt32(Console.ReadLine());
            
            if (n < 0)
            {
                Console.WriteLine("Факториал отрицательного числа не определён!");
            }
            else
            {
                long factorial = 1;
                int i = 1;
                
                while (i <= n)
                {
                    factorial *= i;
                    Console.WriteLine($"{i}! = {factorial}");
                    i++;
                }
                
                Console.WriteLine($"\nРезультат: {n}! = {factorial}");
            }
            
            Console.ReadKey();
        }
    }
}

🔢 Этап 3: Задание 2 - Цикл for

Задача: Таблица умножения

Создайте программу для вывода таблицы умножения используя вложенные циклы for

Console.WriteLine("=== Таблица умножения ===\n");

// Заголовок таблицы
Console.Write("   |");
for (int i = 1; i <= 10; i++)
{
    Console.Write($"{i,4}");
}
Console.WriteLine();
Console.WriteLine("---+" + new string('-', 40));

// Тело таблицы
for (int i = 1; i <= 10; i++)
{
    Console.Write($"{i,3}|");
    
    for (int j = 1; j <= 10; j++)
    {
        Console.Write($"{i * j,4}");
    }
    
    Console.WriteLine();
}

// Дополнительно: выделение диагонали
Console.WriteLine("\n=== Квадраты чисел (диагональ) ===");
for (int i = 1; i <= 10; i++)
{
    Console.WriteLine($"{i}² = {i * i}");
}

🔄 Этап 4: Задание 3 - Числа Фибоначчи

Задача: Последовательность Фибоначчи

Выведите первые N чисел Фибоначчи разными способами

Console.WriteLine("=== Числа Фибоначчи ===");

Console.Write("Сколько чисел вывести? ");
int count = Convert.ToInt32(Console.ReadLine());

// Способ 1: Цикл for
Console.WriteLine("\n1. Используя for:");
long a = 0, b = 1;
for (int i = 0; i < count; i++)
{
    if (i == 0)
    {
        Console.Write($"{a} ");
    }
    else if (i == 1)
    {
        Console.Write($"{b} ");
    }
    else
    {
        long temp = a + b;
        Console.Write($"{temp} ");
        a = b;
        b = temp;
    }
}

// Способ 2: Цикл while с массивом
Console.WriteLine("\n\n2. Используя while и массив:");
if (count > 0)
{
    long[] fib = new long[count];
    fib[0] = 0;
    if (count > 1) fib[1] = 1;
    
    int index = 2;
    while (index < count)
    {
        fib[index] = fib[index - 1] + fib[index - 2];
        index++;
    }
    
    // Вывод массива
    foreach (long num in fib)
    {
        Console.Write($"{num} ");
    }
}

// Способ 3: Рекурсивная формула (для сравнения)
Console.WriteLine("\n\n3. Золотое сечение:");
double phi = (1 + Math.Sqrt(5)) / 2;
Console.WriteLine($"φ = {phi:F10}");

🎯 Этап 5: Задание 4 - Поиск простых чисел

Задача: Решето Эратосфена

Найдите все простые числа до заданного N

Console.WriteLine("=== Поиск простых чисел ===");

Console.Write("Введите верхнюю границу: ");
int limit = Convert.ToInt32(Console.ReadLine());

// Метод 1: Проверка делимости
Console.WriteLine("\n1. Метод проверки делимости:");
int primeCount = 0;

for (int number = 2; number <= limit; number++)
{
    bool isPrime = true;
    
    // Проверяем делимость только до корня из числа
    for (int divisor = 2; divisor <= Math.Sqrt(number); divisor++)
    {
        if (number % divisor == 0)
        {
            isPrime = false;
            break;
        }
    }
    
    if (isPrime)
    {
        Console.Write($"{number} ");
        primeCount++;
    }
}

Console.WriteLine($"\nНайдено простых чисел: {primeCount}");

// Метод 2: Решето Эратосфена
Console.WriteLine("\n2. Решето Эратосфена:");
bool[] isPrimeArray = new bool[limit + 1];

// Инициализация - все числа считаем простыми
for (int i = 2; i <= limit; i++)
{
    isPrimeArray[i] = true;
}

// Отсеивание составных чисел
for (int i = 2; i * i <= limit; i++)
{
    if (isPrimeArray[i])
    {
        // Отмечаем все кратные как составные
        for (int j = i * i; j <= limit; j += i)
        {
            isPrimeArray[j] = false;
        }
    }
}

// Вывод результата
primeCount = 0;
for (int i = 2; i <= limit; i++)
{
    if (isPrimeArray[i])
    {
        Console.Write($"{i} ");
        primeCount++;
    }
}

Console.WriteLine($"\nНайдено простых чисел: {primeCount}");

📊 Этап 6: Задание 5 - Работа с массивами

Задача: Обработка массива

Выполните различные операции над массивом используя циклы

Console.WriteLine("=== Обработка массива ===");

Console.Write("Введите размер массива: ");
int size = Convert.ToInt32(Console.ReadLine());

int[] array = new int[size];
Random random = new Random();

// Заполнение массива случайными числами
Console.WriteLine("\nИсходный массив:");
for (int i = 0; i < size; i++)
{
    array[i] = random.Next(1, 101);
    Console.Write($"{array[i]} ");
}

// 1. Поиск минимума и максимума
int min = array[0], max = array[0];
int minIndex = 0, maxIndex = 0;

for (int i = 1; i < size; i++)
{
    if (array[i] < min)
    {
        min = array[i];
        minIndex = i;
    }
    if (array[i] > max)
    {
        max = array[i];
        maxIndex = i;
    }
}

Console.WriteLine($"\n\nМинимум: array[{minIndex}] = {min}");
Console.WriteLine($"Максимум: array[{maxIndex}] = {max}");

// 2. Вычисление суммы и среднего
int sum = 0;
foreach (int element in array)
{
    sum += element;
}
double average = (double)sum / size;

Console.WriteLine($"\nСумма элементов: {sum}");
Console.WriteLine($"Среднее арифметическое: {average:F2}");

// 3. Подсчёт чётных и нечётных
int evenCount = 0, oddCount = 0;
for (int i = 0; i < size; i++)
{
    if (array[i] % 2 == 0)
        evenCount++;
    else
        oddCount++;
}

Console.WriteLine($"\nЧётных элементов: {evenCount}");
Console.WriteLine($"Нечётных элементов: {oddCount}");

// 4. Реверс массива
Console.WriteLine("\nРеверсированный массив:");
for (int i = 0; i < size / 2; i++)
{
    int temp = array[i];
    array[i] = array[size - 1 - i];
    array[size - 1 - i] = temp;
}

foreach (int element in array)
{
    Console.Write($"{element} ");
}

🔀 Этап 7: Задание 6 - Вложенные циклы и паттерны

Задача: Рисование фигур

Создайте различные геометрические паттерны используя вложенные циклы

Console.WriteLine("=== Геометрические паттерны ===");

Console.Write("Введите размер фигур: ");
int n = Convert.ToInt32(Console.ReadLine());

// 1. Прямоугольный треугольник
Console.WriteLine("\n1. Прямоугольный треугольник:");
for (int i = 1; i <= n; i++)
{
    for (int j = 1; j <= i; j++)
    {
        Console.Write("* ");
    }
    Console.WriteLine();
}

// 2. Перевёрнутый треугольник
Console.WriteLine("\n2. Перевёрнутый треугольник:");
for (int i = n; i >= 1; i--)
{
    for (int j = 1; j <= i; j++)
    {
        Console.Write("* ");
    }
    Console.WriteLine();
}

// 3. Равнобедренный треугольник
Console.WriteLine("\n3. Равнобедренный треугольник:");
for (int i = 1; i <= n; i++)
{
    // Пробелы
    for (int j = 1; j <= n - i; j++)
    {
        Console.Write(" ");
    }
    // Звёздочки
    for (int j = 1; j <= 2 * i - 1; j++)
    {
        Console.Write("*");
    }
    Console.WriteLine();
}

// 4. Ромб
Console.WriteLine("\n4. Ромб:");
// Верхняя часть
for (int i = 1; i <= n; i++)
{
    for (int j = 1; j <= n - i; j++)
        Console.Write(" ");
    for (int j = 1; j <= 2 * i - 1; j++)
        Console.Write("*");
    Console.WriteLine();
}
// Нижняя часть
for (int i = n - 1; i >= 1; i--)
{
    for (int j = 1; j <= n - i; j++)
        Console.Write(" ");
    for (int j = 1; j <= 2 * i - 1; j++)
        Console.Write("*");
    Console.WriteLine();
}

// 5. Числовая пирамида
Console.WriteLine("\n5. Числовая пирамида:");
for (int i = 1; i <= n; i++)
{
    for (int j = 1; j <= n - i; j++)
        Console.Write(" ");
    for (int j = 1; j <= i; j++)
        Console.Write($"{j}");
    for (int j = i - 1; j >= 1; j--)
        Console.Write($"{j}");
    Console.WriteLine();
}

🎮 Этап 8: Задание 7 - Игра "Угадай число"

Задача: Интерактивная игра с циклами

Создайте игру с использованием циклов и условий

Console.WriteLine("=== Игра 'Угадай число' ===");

Random rand = new Random();
int secretNumber = rand.Next(1, 101);
int attempts = 0;
int maxAttempts = 7;
bool guessed = false;

Console.WriteLine("Я загадал число от 1 до 100.");
Console.WriteLine($"У вас есть {maxAttempts} попыток.\n");

while (attempts < maxAttempts && !guessed)
{
    attempts++;
    Console.Write($"Попытка {attempts}/{maxAttempts}. Ваше число: ");
    
    if (!int.TryParse(Console.ReadLine(), out int guess))
    {
        Console.WriteLine("Введите корректное число!");
        attempts--; // Не считаем неверный ввод
        continue;
    }
    
    if (guess < 1 || guess > 100)
    {
        Console.WriteLine("Число должно быть от 1 до 100!");
        attempts--; // Не считаем неверный диапазон
        continue;
    }
    
    if (guess == secretNumber)
    {
        guessed = true;
        Console.ForegroundColor = ConsoleColor.Green;
        Console.WriteLine($"\n🎉 Поздравляю! Вы угадали число {secretNumber}!");
        Console.WriteLine($"Использовано попыток: {attempts}");
        
        // Оценка результата
        string rating = attempts switch
        {
            1 => "Невероятно! Вы экстрасенс!",
            2 or 3 => "Отличный результат!",
            4 or 5 => "Хороший результат!",
            6 or 7 => "Неплохо, но можно лучше!",
            _ => ""
        };
        Console.WriteLine(rating);
    }
    else
    {
        string hint = guess < secretNumber ? "больше" : "меньше";
        Console.WriteLine($"Не угадали! Загаданное число {hint}.");
        
        // Дополнительная подсказка
        int diff = Math.Abs(secretNumber - guess);
        if (diff <= 5)
            Console.WriteLine("🔥 Очень горячо!");
        else if (diff <= 10)
            Console.WriteLine("♨️ Горячо!");
        else if (diff <= 20)
            Console.WriteLine("🌡️ Тепло");
        else
            Console.WriteLine("❄️ Холодно");
    }
}

if (!guessed)
{
    Console.ForegroundColor = ConsoleColor.Red;
    Console.WriteLine($"\n😢 Вы не угадали! Число было: {secretNumber}");
}

Console.ResetColor();

// Статистика игры
Console.WriteLine("\n=== Статистика игры ===");
Console.WriteLine($"Попыток использовано: {attempts}/{maxAttempts}");
Console.WriteLine($"Попыток осталось: {maxAttempts - attempts}");
Console.WriteLine($"Результат: {(guessed ? "Победа" : "Поражение")}");

🔍 Этап 9: Задание 8 - Поиск и сортировка

Задача: Алгоритмы поиска и сортировки

Реализуйте базовые алгоритмы с использованием циклов

Console.WriteLine("=== Поиск и сортировка ===");

// Создание массива
int[] numbers = { 64, 34, 25, 12, 22, 11, 90, 88, 45, 50 };
Console.WriteLine("Исходный массив:");
foreach (int num in numbers)
    Console.Write($"{num} ");

// 1. Линейный поиск
Console.Write("\n\nВведите число для поиска: ");
int target = Convert.ToInt32(Console.ReadLine());

int position = -1;
for (int i = 0; i < numbers.Length; i++)
{
    if (numbers[i] == target)
    {
        position = i;
        break;
    }
}

if (position != -1)
    Console.WriteLine($"Число {target} найдено на позиции {position}");
else
    Console.WriteLine($"Число {target} не найдено");

// 2. Пузырьковая сортировка
Console.WriteLine("\n2. Пузырьковая сортировка:");
int[] bubbleArray = (int[])numbers.Clone();

for (int i = 0; i < bubbleArray.Length - 1; i++)
{
    bool swapped = false;
    
    for (int j = 0; j < bubbleArray.Length - i - 1; j++)
    {
        if (bubbleArray[j] > bubbleArray[j + 1])
        {
            // Обмен элементов
            int temp = bubbleArray[j];
            bubbleArray[j] = bubbleArray[j + 1];
            bubbleArray[j + 1] = temp;
            swapped = true;
        }
    }
    
    // Если обменов не было, массив отсортирован
    if (!swapped)
        break;
}

Console.WriteLine("Отсортированный массив:");
foreach (int num in bubbleArray)
    Console.Write($"{num} ");

// 3. Сортировка выбором
Console.WriteLine("\n\n3. Сортировка выбором:");
int[] selectionArray = (int[])numbers.Clone();

for (int i = 0; i < selectionArray.Length - 1; i++)
{
    int minIndex = i;
    
    // Поиск минимального элемента
    for (int j = i + 1; j < selectionArray.Length; j++)
    {
        if (selectionArray[j] < selectionArray[minIndex])
            minIndex = j;
    }
    
    // Обмен с текущим элементом
    if (minIndex != i)
    {
        int temp = selectionArray[i];
        selectionArray[i] = selectionArray[minIndex];
        selectionArray[minIndex] = temp;
    }
}

Console.WriteLine("Отсортированный массив:");
foreach (int num in selectionArray)
    Console.Write($"{num} ");

// 4. Бинарный поиск (в отсортированном массиве)
Console.WriteLine("\n\n4. Бинарный поиск:");
Console.Write("Введите число для поиска: ");
target = Convert.ToInt32(Console.ReadLine());

int left = 0;
int right = bubbleArray.Length - 1;
position = -1;

while (left <= right)
{
    int mid = (left + right) / 2;
    
    if (bubbleArray[mid] == target)
    {
        position = mid;
        break;
    }
    else if (bubbleArray[mid] < target)
        left = mid + 1;
    else
        right = mid - 1;
}

if (position != -1)
    Console.WriteLine($"Число {target} найдено на позиции {position}");
else
    Console.WriteLine($"Число {target} не найдено");

⚡ Этап 10: Задание 9 - Операторы break и continue

Задача: Управление выполнением цикла

Используйте операторы break и continue для управления циклами

Console.WriteLine("=== Управление циклами ===");

// 1. Использование continue
Console.WriteLine("1. Вывод только нечётных чисел (continue):");
for (int i = 1; i <= 20; i++)
{
    if (i % 2 == 0)
        continue; // Пропускаем чётные числа
    
    Console.Write($"{i} ");
}

// 2. Использование break
Console.WriteLine("\n\n2. Поиск первого делителя (break):");
Console.Write("Введите число: ");
int number = Convert.ToInt32(Console.ReadLine());

for (int i = 2; i < number; i++)
{
    if (number % i == 0)
    {
        Console.WriteLine($"Первый делитель числа {number}: {i}");
        Console.WriteLine($"Число {number} - составное");
        break;
    }
    
    if (i == number - 1)
        Console.WriteLine($"Число {number} - простое");
}

// 3. Вложенные циклы с break
Console.WriteLine("\n3. Поиск в матрице:");
int[,] matrix = {
    {1, 2, 3, 4},
    {5, 6, 7, 8},
    {9, 10, 11, 12},
    {13, 14, 15, 16}
};

Console.Write("Искать число: ");
int searchValue = Convert.ToInt32(Console.ReadLine());
bool found = false;

for (int i = 0; i < 4; i++)
{
    for (int j = 0; j < 4; j++)
    {
        if (matrix[i, j] == searchValue)
        {
            Console.WriteLine($"Найдено на позиции [{i},{j}]");
            found = true;
            break;
        }
    }
    
    if (found)
        break; // Выход из внешнего цикла
}

if (!found)
    Console.WriteLine("Число не найдено в матрице");

// 4. Меню с бесконечным циклом
Console.WriteLine("\n4. Интерактивное меню:");
while (true)
{
    Console.WriteLine("\n--- МЕНЮ ---");
    Console.WriteLine("1. Действие 1");
    Console.WriteLine("2. Действие 2");
    Console.WriteLine("3. Действие 3");
    Console.WriteLine("0. Выход");
    Console.Write("Выбор: ");
    
    int choice = Convert.ToInt32(Console.ReadLine());
    
    if (choice == 0)
    {
        Console.WriteLine("Выход из программы...");
        break;
    }
    
    switch (choice)
    {
        case 1:
            Console.WriteLine("Выполнено действие 1");
            break;
        case 2:
            Console.WriteLine("Выполнено действие 2");
            break;
        case 3:
            Console.WriteLine("Выполнено действие 3");
            break;
        default:
            Console.WriteLine("Неверный выбор!");
            continue; // Переход к следующей итерации
    }
}

🐛 Отладка циклов

Основные приемы отладки:

Проверка условий
Убедитесь, что условие цикла корректно и достижимо
Контроль счётчика
Отслеживайте изменение управляющей переменной
Граничные значения
Проверяйте первую и последнюю итерации
Бесконечные циклы
Используйте отладчик для обнаружения зацикливания

Частые ошибки:

Неверное условие - цикл не выполняется или выполняется лишний раз
Забытое изменение счётчика - бесконечный цикл
Выход за границы массива - ошибка IndexOutOfRange
Неправильная инициализация - неверные начальные значения
Путаница с вложенными циклами - неверное использование переменных

💡 Полезные советы

Выбирайте тип цикла в зависимости от задачи
Используйте for когда известно количество итераций
Применяйте while для условий с неизвестным числом повторений
Помните про do-while когда нужна хотя бы одна итерация
Используйте foreach для безопасного перебора коллекций
Избегайте модификации коллекции внутри foreach
Минимизируйте вложенность циклов
Выносите инвариантные вычисления из цикла
Документируйте сложную логику циклов
Тестируйте граничные случаи и пустые коллекции

📝 Требования к отчету

Отчет должен содержать:

Титульный лист с названием работы
Цель и задачи работы
Теоретическую часть (типы циклов, операторы управления)
Блок-схемы для каждого задания
Листинги программ с комментариями
Скриншоты выполнения программ
Таблицы тестирования с различными входными данными
Анализ эффективности алгоритмов
Сравнение различных подходов
Выводы по работе