Задания Оценки Ведомость Материалы

Ведомость и материалы для обучения

Все памятки, материалы и ссылки отныне находятся в разделе "материалы".

Новые домашние задания

Оценки (на вкладке "информатика")

Почта преподавателя: valeriy.fedotov [...] gmail.com

Дополнительные занятия проходят по понедельникам с 15:15 до 17:00 и по четвергам с 14:15 по 17:00.

Лекции по мере записи выкладываются здесь.

Задание 22. Бинарное дерево

Надо написать программу для подсчёта кратностей слов в тексте. Программу можно написать как самостоятельно, так и выдрать из нашей любимой книги K&R (не у товарища, а именно из книги, так как для этого тоже нужна определённая сноровка).

Если хотите написать программу самостоятельно, то узел бинарного дерева, в котором будут храниться слово и его кратность, выглядит так:

struct node {
    char *word;
    int count;
    struct node *left;
    struct node *right;
};

а пустое дерево -- это просто нулевой указатель.

где left и right -- указатели на левое и правое поддеревья, в которых будут хранится слова, стоящие раньше и позже слова word по алфавиту, соответственно. Отсутствие левого или правого поддерева обозначается с помощью нулевого указателя.

Необходимо написать две рекурсивные функции, одну для обработки поступившего слова с созданием нового узла, если такое слово встретилось впервые, либо с увеличением кратности слова в уже существующем узле. Как всегда, надо продумать терминальную и рекурсивную ветви. Рекурсивную следует писать таким образом, чтобы поддерживать дерево в отсортированном виде.

Рекурсивная функция для печати результата должна выводить слова с их кратностями в алфавитном порядке. Если она правильно написана, то она прекрасна и укладывается в 5-6 строк.

Рисунки с пояснениями к заданию смотрите в тетради.

Задание 21. Односвязный список

Нужно написать программу, реализующую основные операции с односвязным списком. В ячейках списка в данной программе нужно хранить числа int, то есть структура данных для ячейки списка должна выглядеть так:

struct cell {
    int value;
    struct node *next;
};

Сам список в этом случае должен выглядеть следующим образом:

struct cell *list = NULL;

Константа NULL в данном случае применяется для обозначения пустого списка.

Программа должна в цикле выводить меню и выполнять выбранные пользователем пункты.

  1. Создать новый пустой список. В начале список и так должен быть пуст, если же он не пуст, то следует правильно освободить память из-под всех ячеек.

  2. Распечатать содержимое списка.

  3. Добавить ячейку с новым значением в начало списка (операция push в англоязычной терминологии).

  4. Удалить ячейку из начала списка, напечатав её значение (операция pop в англоязычной терминологии).

  5. Вставить ячейку с новым значением перед элементом с указанным индексом. Если указанный индекс равен нулю, операция аналогична пункту 3.

  6. Удалить ячейку с указанным индексом. Если индекс равен нулю, аналогично пункту 4.

Те, кому интересно задание посложнее, могут реализовать ещё один пункт, перестановка указателей в списке таким образом, чтобы ячейки шли в обратном порядке. Здесь потребуется немного размышлений и пара рисунков на бумаге.

Также интересно написать пару из этих пунктов в виде рекурсивных функций, должно получиться достаточно элегантно.

Рисунки к пунктам 2, 3, 4, 5 смотрите в тетрадях тех, кто был на уроке, я добавлю их к этому заданию не сразу.

Задание 20, односвязный список

Написать программу для хранения целых чисел в односвязном списке. Программа должна реализовывать следующие действия, в цикле предлагая их пользователю в виде меню:

  1. Создать пустой список. При этом, память из-под старого списка (если на данный момент уже есть список ненулевой длины) должна быть освобождена.

  2. Подсчитать число элементов в списке. (Это число нужно не хранить в переменной, а получить проходом по всему списку.)

  3. Добавить элемент (целое число) в начало списка.

  4. Удалить элемент из начала списка.

  5. Вставить элемент в произвольное место списка по индексу.

  6. Удалить произвольный элемент списка по индексу.

Напомню, что определение ячейки односвязного списка выглядит как

struct cell {
    int x;
    struct cell *next;
}

а конец списка определяется по нулевому указателю в поле next последней ячейки.

Пояснительные картинки смотрите в тетради.

Задание 19, записная книжка

Теоретический вопрос

Есть определение структуры

struct my_struct {
    int a;
    char b;
};

Чему равно выражение sizeof(struct my_struct) и почему оно именно такое?

Записная книжка

Требуется написать программу, которая будет вести телефонную книгу. При запуске программа входит в интерактивный режим работы, предоставляя пользователю меню. Пользователь выбирает интересующее его действие, программа это действие выполняет и снова выводит меню. Хранение записей в записной книжке нужно реализовать с помощью массива структур.

Пункты меню.

  1. «Создать новую книгу». Программа освобождает все ресурсы, связанные с текущей телефонной книгой, запрашивает у пользователя значение максимального числа записей и создает новую, пустую книгу.

  2. «Просмотреть содержимое». Программа выводит содержимое всех непустых записей и их полное количество. Каждая запись должна иметь свой уникальный номер по которому ее можно распознать.

  3. «Добавить запись». Программа спрашивает пользователя о имени и телефоне объекта и создает новую запись, если это возможно.

  4. «Удалить запись». Программа требует ввода номера записи, которая будет удалена, и проводит процедуру удаления записи.

  5. «Поиск по имени». Пользователь вводит имя объекта, а программа в ответ выводит все записи, у которых имена объектов совпадают с введенным пользователем.

  6. «Поиск по номеру телефона». То же, что и предыдущий пункт, только критерием поиска является телефон объекта.

  7. «Отсортировать записи по имени». Можно воспользоваться одним из известных алгоритмов сортировки или функцией qsort.

  8. «Сохранить книгу в файл». Программа запрашивает у пользователя имя файла и сохраняет текущее содержимое телефонной книги в указанный файл.

  9. «Восстановить книгу из файла». Программа запрашивает у пользователя имя файла и восстанавливает содержимое ранее сохраненной книги. Если восстановление успешно, то все ресурсы, связанные с предыдущей книгой освобождаются. При неудачном восстановлении текущая телефонная книга не уничтожается.

  10. «Выход».

Программа должна быть написана с использованием структур.

Задание 18, указатели на функции

  1. Переписать программу №16 для решения уравнений методом деления отрезка пополам таким образом, чтобы:

    • Для указания того уравнения, которое нужно решать, использовались указатели на функции. Таким образом, к методу деления отрезка пополам и методу хорд добавится один дополнительный аргумент, а к методу Ньютона – два, если вы конечно используете производную в аналитическом виде. Если производная вычисляете по формуле \( f'(x) = \frac{f(x + h) – f(x – h)} {2 h} \), то дополнительный аргумент в методе Ньютона будет один.

    • Программа должна быть разбита на модули таким образом, чтобы вся функциональность для решения уравнений находилась в файле solver.c, а прототипы этих функций находились бы в solver.h. Конкретные уравнения

      • sin(x) = 0,

      • cos(x) = 0,

      • ln(x) – 1 = 0,

      которые должна решать программа, должны быть заданы с помощью функций уже в файле main.c, где также будет находится ваша функция main.

    Компилировать программу нужно с помощью команды

    gcc -o solver.out solver.c main.c -lm -Wall
    

    После успешной компиляции должен появиться файл solver.out. Подробнее о разделении программы на несколько файлов с исходным кодом можно прочитать в лекции.

  2. Написать функцию для сортировки массива, которая умеет работать с функцией-критерием сортировки.

    Критерием сортировки должна быть функция, принимающая два элемента сортируемого массива и возвращающая отрицательное число, ноль или положительное число, если первый её аргумент меньше, равен или больше второго соответсвенно.

    То есть ваша функция сортировки должна иметь прототип примерно следующего вида:

    void mysort(int *array, int n, int (*f)(int, int));
    

    Тогда, опрелелив функцию сравнения как

    int comparer1(int a, int b)
    {
        return a — b;
    }
    

    с помощью вызова mysqort(a, n, comparer1) можно отсортировать массив a размером n.

    Если же определить критерий сортировки как

    int comparer2(int a, int b)
    {
        return (a % 10) — (b % 10);
    }
    

    то вызов mysqort(a, n, comparer2) отсортирует массив в порядке возрастания младшей цифры.

    Как работает реальная функция qsort из стандартной библиотеки языка C, можно почитать в записи лекции. Там за счёт использования нетипизированного указателя void * и указания не только количества элементов в массиве, но и размера одного элемента, становится возможным сортировать массив со значениями произвольного типа. Если хотите, можете реализовать функцию mysort так же, хотя это немного сложнее.

P.S. Расписал задание подробно, но, на самом деле, оно очень лёгкое.

Задание 17, рекурсия

  1. Рекурсивная функция возведения в степень (очень простое задание).

  2. Функция быстрого возведения в степень, так же рекурсивная. Быстрое возведение в степень основано на том факте, что если представить \( x ^ {100} \) в виде \( (x ^ {50}) ^ 2 \), то для возведения потребуется не 99 умножений, а 50 (49 для степени 50 и ещё одно для возвдения в квадрат). Ну а если произвести такое преобразование ещё раз, то получится \( ((x ^ {25}) ^ 2) ^ 2 \). Это выражение вычисляется за 26 умножений.

  3. Рекурсивный вариант функции линейного поиска. Функция линейного поиска выглядит следующим образом:

int left_find(int x, int *a, int n)
{
    int i;
    for (i = 0; i < n; ++i) {
        if (a[i] == x) {
            return i;
        }
    }
    return -1;
}
  1. Написать сортировку слиянием. Идея сортировки слиянием основана на принципе "разделяй и властвуй": мы разбиваем исходную задачу на поздадачи меньшего размера, успешно решаем их, и объединяем решения.

    Сортировка слиянием разбивает массив на два подмассива, каждый из которых она сортирует с помощью рекурсивного вызова самой себя. Объединение двух отсортированных массивов происходит с помощью простого алгоритма, который записывает по двум отсортированным массивам слева направо и записывает в результирующий массив меньшее из текущих чисел a[i], b[i].

    Терминальной ветьвью сортировки слиянием является случай, когда в сортируемом подмассиве содержится всего один элемент. В этом случае ну нужно делать ничего, массив отсортирован.

Перестановки множества (дополнение к заданию 17 для сдачи на 4)

Программа должна спрашивать у пользователя число n и распечатывает все возможные перестановки множества чисел 0,...,n-1. Алгоритм нужно реализовать рекурсивно. Вывод программы для n=5 должен выглядеть следующим образом:

0 1 2 3
0 1 3 2
0 2 1 3
0 2 3 1
0 3 1 2
0 3 2 1
1 0 2 3
1 0 3 2
1 2 0 3
1 2 3 0
1 3 0 2
1 3 2 0
2 0 1 3
2 0 3 1
2 1 0 3
2 1 3 0
2 3 0 1
2 3 1 0
3 0 1 2
3 0 2 1
3 1 0 2
3 1 2 0
3 2 0 1
3 2 1 0

Написать такую функцию несложно, если понимать, что каждый рекурсивный вызов должен добавлять в некоторый массив новую цифру, которой нет среди уже заполненных, и конечная терминальная ветвь должна выводить содержимое полностью заполненного массива. Таким образом, прототип функции должен выглядеть так:

void print_permutations(int n, int filled, int *numbers);

где n -- число из условия задачи, filled -- количество уже заполненных элементов массива, numbers -- массив, в котором ведётся накопление перестановки.

Задание 16, находим корни уравнений

Написать программу для нахождения корня уравнения \[ \cos(x) = 0 \] методами деления отрезка пополам, хорд, Ньютона.

Каждый метод реализовать в отдельной функции. Производную в методе Ньютона можно вычислять аналитически, либо приближённо по формуле \[ f'(x) = \frac{f(x + h) - f(x - h)}{2h} \]

Прошлогодняя контрольная находится здесь

Метод золотого сечения (дополнение к заданию 16 для сдачи на 4)

Необходимо найти максимум непрерывной функции \(f\) на отрезке \([a, b]\). Конечно, эту задачу можно решать с помощью нахождения корня производной этой функции на отрезке \([a, b]\), однако не все непрерывные функции являются дифференцируемыми. Для нахождения экстремумов непрерывных функций применяется метод золотого сечения.

Суть метода состоит в том, что на исходном отрезке [a, b] длиной L=b-a выбираются две точки \(x_{1}=b-L/\varphi\) и \(x_{2}=a+L/\varphi\). В этом выражении используется константа золотого сечения \(\varphi=\frac{\sqrt{5}+1}{2}\). Далее, если \(f(x_{1})>f(x_{2})\), то на следующем шаге метода в качестве исходного отрезка используется \([a,x_{2}]\), иначе используется \([x_{1},b]\). Эти действия необходимо повторять до тех пор, пока длина отрезка больше параметра точности \(\varepsilon\). Константа золотого сечения используется в методе для того, чтобы при повторном разбиении отрезка на точки \(x_{1}\), \(x_{2}\) одна из этих точек находилась на том же месте, что и старая точка с другим индексом (например, новое \(x_{1}\) на месте старого \(x_{2}\)).

Задание 15, подсчёт кратностей в длинном тексте

В задании №14 было некоторое упрощение для работы со входными данными: текст, в котором нам нужно было подсчитать кратности слов, не мог быть длиннее 10000 символов, а самих слов не могло быть больше 5000.

Снимите это ограничение с помощью выделения памяти с помощью функции malloc и перевыделения с помощью realloc, когда памяти начинает не хватать. (Примечание: увеличение количество выделенной памяти на 1 байт крайне неэффективно, так как внутри функции realloc может происходить копирование куска памяти. Лучше увеличивать количество веделенной памяти вдвое.)

Задание 14, подсчёт кратности слов

Написать программу для подсчёта кратностей слов в файле. Пользователь вводить имя файла, программа выдаёт сколько раз встречается каждое слово в нём.

Пример содержимого файла:

cat dog bird
dog fish fox penguin
bird dog dog fish

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

bird 2
cat 1
dog 4
fish 2
fox 1
penguin 1

Рекомендуется (хотя это и не строго обязательно) после подсчёта кратностей отсортировать слова по алфавиту и выводить таблицу в алфавитном порядке. Для сравнения строк можно использовать функцию strcmp.

Задание 13, указатели возвращаются

Переписать функции из задания 8 с использованием указателей.

Прототипы функций должны выглядеть следующим образом:

int mystrlen(char *s);
int mystrcpy(char *dest, char *src);
int mystrncpy(char *dest, char *src, int n);
int strreverse(char *s);
int mystrcat(char *dest, char *src);
int mystrstr(char *haystack, char *needle);

Использовать операции s[i] и *(s + i) не разрешается, только сдвиги указателя ++s и --s, только хардкор. Если точнее, нельзя использовать s[i] и *(s + i) в циклах, вне циклов сдвигать указатель вперёд на некоторое число можно.

Примеры реализации mystrlen были на лекциях.

Задание 12, указатели

Нужно реализовать сортировку четырех пар начальных скоростей снаряда, летящего в поле тяжести и не испытывающего сопротивления воздуха. Критерии сортировки такие:

  1. по возрастанию максимальной высоты подъема снаряда;

  2. по возрастанию дальности полета снаряда.

После сортировки, например, по возрастанию дальности полёта, первая пара скоростей (вектор vx,vy) должна иметь наименьшую дальность, вторая — большую, чем первая, третья — большую чем вторая и последняя — наибольшую дальность.

Значения скоростей должны быть заданы в программе, но также должен присутствовать пункт меню, позволяющий изменить значения всех скоростей.

sort4(int sort_type,
      double *vx1, double *vy1, double *vx2, double *vy2,
      double *vx3, double *vy3, double *vx4, double *vy4)
{
    //...
}

Сами пары скоростей снарядов должны храниться в отдельных переменных. Массивы использовать не разрешается. Функция сортировки sort4 должна принимать восемь указателей на отдельные координаты и параметр, определяющий тип сортировки. При этом sort4 должна только сортировать, выводом получившихся точек на экран должна заниматься либо отдельная функция, либо функция main.

В качестве результата любой из сортировок должны выводиться 4 строчки, в каждой из которых указаны два составляющих скорости, дальность полета и максимальная высота подъема снаряда для данной начальной скорости.

Программа с функцией swap

Задание 11, конечный автомат

На входе программы есть строка со строками и комментариями в стиле языка Си, то есть:

"Hello, world" /* comment with "surprise" */ "Some abracadabra: \" /* 1234"

Программа должна корректно разбивать входную строки на лексические единицы (так как это делает компилятор языка Си):

String: Hello, world
Comment: comment with "surprise"
String: Some abracadabra: " /* 1234

Заметьте, что программу не должны сбивать с толку двойные кавычки внутри комментариев и попытки открыть или закрыть комментарий внутри строки. Так же в строках может встречаться и сам символ двойных кавычек, который экранируется в этом случае так же, как и в Си.

В случае, если входная строка не соответствует заданному формату (есть ещё что-то помимо комментариев и строк) или после окончания ввода не закрыта строка или комментарий, следует сообщить пользователю об ошибке.

Программа, делающая аналогичные действия только ввода состоящего из строк

Задача 10, двумерные массивы

Написать программу (или программы) для заполнения массива

  1. Змейкой:

 0  1  2  3  4  5
11 10  9  8  7  6
12 13 14 15 16 17
23 22 21 20 19 18
24 25 26 27 28 29
35 34 33 32 31 30
36 37 38 39 40 41
  1. По спирали:

 0  1  2  3  4  5
21 22 23 24 25  6
20 35 36 37 26  7
19 34 41 38 27  8
18 33 40 39 28  9
17 32 31 30 29 10
16 15 14 13 12 11
  1. Зигзагом:

 0  1  5  6 14 15
 2  4  7 13 16 26
 3  8 12 17 25 27
 9 11 18 24 28 35
10 19 23 29 34 36
20 22 30 33 37 40
21 31 32 38 39 41

Программа для заполнения массива в обычном порядке

Не забывайте, что размеры массива обязательно должны быть заданы через #define

Задание 9, работа с файлами

Написать программу, которая считывает содержимое файла и выводит:

Одно из решений последнего пункта предполагает использование флага (см. тетрадь).

Результат работы программы необходимо напечатать как на терминал, так и в файл с названием result.txt.

Задание 8, сортировки и поиски

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

Действия, которые необходимо реализовать:

  1. Заполнение массива. Пользователь вводит желаемый размер массива n, который должен быть меньше либо равен некоторому максимальному размеру, заданному через #define, программа считывает требуемое количество элементов и с этого момента считает, что размер массива равен n. Он может измениться при добавлении или удалении элемента, или при следующем заполнении массива с помощью этого действия.

  2. Печать всех элементов массива.

  3. Изменение элемента по индексу. Пользователь вводит индекс и новое значение элемента.

  4. Вставка по индексу. После вставки по заданному индексу появляется введённое значение, все остальные значения сдвигаются с изменением размера массива на 1.

  5. Удаление по индексу. После удаления "хвост" массива после удалённого элемента сдвигается влево и размер массива уменьшается на 1.

  6. Поиск числа в массиве. Вывести индекс найденного элемента.

  7. Поиск минимума в массиве.

  8. Поиск максимума.

  9. Сортировка массива по возрастанию.

  10. Сортировка пар в массиве. Все элементы массива разбиваются на пары (0-ой и 1-ый, 2-ой и 3-ий и т.д.) и происходит сортировка этих пар по возрастанию суммы. Из массива

    1 10 2 8 3 4 5 3
    (суммы пар 11 10 9 8)
    

    будет получен массив

    5 3 3 4 2 8 1 10
    (суммы пар 8 9 10 11)
    
  11. Добавление элемента в только что отсортированный массив. Индекс в этом случае не требуется, функция должна добавлять элемент в массив так, чтобы после добавления массив по-прежнему был отсортирован. Размер массива при этом нужно увеличить на 1. Требуется что-нибудь более эффективное, чем добавление элемента в конец и последующая сортировка.

Все пункты меню должны быть реализованы как отдельные функции. Напоминаю, что функции не могут изменять свои аргументы-числа, но могут изменять свои аргументы-массивы.

Если пункт меню принимает пользовательский ввод, если это возможно, считывайте этот ввод до вызова функции. Так функции более пригодны для повторного использования из других функций.

Напоминаю про правильную тактику написания и отладки программ: написали небольшой кусок (в данном случае функцию) и отлаживаем его, пока не заработает, потом двигаемся дальше.

PS. На уроке при написании одной из двух сортировок была допущена неточность, в результате которой функция сортировки утратила стабильность. Сортировка называется стабильной, если она сохраняет порядок равных элементов. То есть, для двух элементов a[i] == a[j], i < j, после сортировки получающих индексы i1 и j1 соответственно, должно выполняться условие i1 < j1. Подумайте, какой из алгоритмов не удовлетворяет этому свойству и какие изменения надо в него внести.

Задание 7, строковые функции

Написать следующие функции:

// Функция должна возвращать длину строки,
// не считая символ конца строки.
int mystrlen(char s[]);

// Функция должна копировать содержимое строки
// src в dest.
int mystrcpy(char dest[], char src[]);

// Функция должна копировать содержимое строки
// src в dest. Считается, что параметр n содержит
// размер массива dest, и всего должно быть скопировано
// не более n символов. На последней позиции как при
// полном копировании src, так и при частичном,
// должен стоят символ конца строки.
// Если длина строки src меньше n, лишние символы
// копироваться не должны.
int mystrncpy(char dest[], char src[], int n);

// Функция, которая переставляет буквы строки
// в обратном порядке. То есть, из строки "abcd"
// должна получиться строка "dcba".
int strreverse(char s[]);

// Функция для дописывания строки src в конец строки
// dest.
int mystrcat(char dest[], char src[]);

// Функция для поиска подстроки needle в строке haystack.
// Должна возвращать индекс начала найденной подстроки,
// или -1, если искомая подстрока не найдена. Если таких
// подстрок несколько, должен возвращаться индекс крайней
// левой.
int mystrstr(char haystack[], char needle[]);

Примечания:

Задание 6, функции

Переписать программу вычисления экспоненты, синуса, косинуса так, чтобы они работали через функции.

Все три функции должны принимать как аргументы x и Nmax (число членов ряда в сумме).

Задание 5, массив

Пользователь вводит массив из 10 чисел (константу нужно задать через #define), затем программа в цикле выводит меню из следующих пунктов и выполняет выбранные:

Как обычно, быстрее и проще писать и отлаживать пункты один за другим, чем пытаться написать всё сразу. Если непонятен сам алгоритм работы, то лучше не смотреть в код, а нарисовать алгоритм на бумаге.

Задание 4, экспонента, синус, косинус

Пользователь вводит число с плавающей точкой x, программа расчитывает значения функций экспонеты, синуса и косинуса для этого x.

Формулы:

\[ \exp(x) = \sum_{n=0}^{n=\infty} \frac{x^n}{n!} \]

\[ \cos(x) = \sum_{n=0}^{n=\infty} \frac{(-1)^n x^{2n}}{(2n)!} \]

\[ \sin(x) = \sum_{n=0}^{n=\infty} \frac{(-1)^n x^{2n+1}}{(2n+1)!} \]

Чтобы приближённые суммы ряда получались с хорошей точностью для \( | x | < 8 \), вместо бесконечности верхним пределом суммы можно взять \( N_{max} = 10 \). Для проверки экспоненты воспользуйтесь значениями \( \exp(0) = 1 \), \( \exp(1) \approx 2.72 \), \( \exp(2) \approx 7.38 \).

Рекоммендуемый план написания программы:

В дальнейшем, вы сами будете писать программы по частям, самостоятельно разбивая задачу на подзадачи. Но для этой программы я предлагаю придерживаться этого плана.

P.S. Если не видны формулы, включайте в браузере JavaScript.

Задание 3, минимумы, максимумы, корни

Пользователь вводит числа a, b, N. а - левая граница отрезка, b - правая граница отрезка, N - число шагов по отрезку. Необходимо вывести максимумы, минимумы и приблизительное положение корней функции cos(x). Для этого необходимо двигаться по отрезку с шагом $$h = \frac{b-a}{N}. $$

Считать, что у функции есть максимум на отрезке [x-h, x+h], если её значение в точке x больше значений в точках x-h и x+h. Дробить отрезок дальше и находить максимум точнее не требуется.

У функции есть корень на отрезке [x, x+h], если она принимает на концах этого отрезка разные знаки.

Не забывайте, что программу надо компилировать с ключом -lm для подключения математической библиотеки, иначе компилятор не найдёт функцию cos(x).

Задание на этот урок получилось достаточно сложным, поэтому стараемся написать как можно больше без посторонней помощи, если не получилось всё написать, приходим на урок и спрашиваем у меня. Списывание первых программ приведёт к полному непониманию всего курса 10-го класса.

Ещё мне можно писать на почту и задавать вопросы.

Пример работы программы (вывод вашей программы может быть оформлен по-другому):

Enter a, b, N: 
-0.1 10 101
max at [-0.100000, 0.100000]
root at [1.500000, 1.600000]
min at [3.000000, 3.200000]
root at [4.700000, 4.800000]
max at [6.200000, 6.400000]
root at [7.800000, 7.900000]
min at [9.300000, 9.500000]

Задание 2, факториал

Написать программу, выводящую факториал числа, введённого пользователем.

Напоминаю, что 0! = 1.

Задание 1

Вывести кубы чисел от 6 до 16 с шагом 2.

Вывести квадраты чисел от 20 до 10 с шагом 1.

Необходимо написать два цикла. Хотя бы один из них должен быть циклом for.