Лабораторный практикум по программированию на языке Си (Степанов)

Для заказа лабораторной работы пишите на почту administrator@videoege.ru

 

Содержание:

Информация для всех студентов, а особенно для студентов МГТУ им.Баумана
Нужна ли регистрация на сайте для заказа лабораторной работы?
Лабораторная работа №1 (программирование алгоритмов разветвляющейся структуры)
  Образец выполнения (вариант №7)
Лабораторная работа №2 (программирование циклов с управляющим параметром)
  Образец выполнения (вариант №3)
Лабораторная работа №3 (программирование циклов с предусловием и с постусловием)
  Образец выполнения (вариант №15)
Лабораторная работа №4 (программирование алгоритмов работы с одномерными массивами)
  Образец выполнения (вариант №15)
Лабораторная работа №5 (программирование алгоритмов с вложенными циклами)
  Образец выполнения (вариант №7)
Лабораторная работа №6 (программирование алгоритмов сортировки массивов)
  Образец выполнения (вариант №12)
Лабораторная работа №7 (программирование алгоритмов с использованием двумерных массивов)
  Образец выполнения (вариант №18)
Лабораторная работа №8 (программирование алгоритмов с использованием строк)
  Образец выполнения (вариант №1)
Лабораторная работа №9 (программирование алгоритмов с использованием массивов структур)
  Образец выполнения (вариант №13)
Лабораторная работа №10 (программирование алгоритмов работы с текстовыми файлами)
  Образец выполнения (вариант №5)
Лабораторная работа №11 (программирование алгоритмов работы с бинарными файлами)
  Образец выполнения (вариант №13)
О качестве программного кода
Закодируем студенческие работы на любом из следующих языков программирования: C, C++, C#, Pascal, Delphi
Скидка 50% при заказе всех вариантов лабораторных/курсовых работ
А какими способами можно оплатить заказанные работы?
Окажем вам полную информационную поддержку, по заказанным у нас работам

Информация для всех студентов, а особенно для студентов МГТУ им.Баумана

Здравствуйте! Мы - команда из $3$-х программистов, которые оказывают квалифицированную помощь студентам со всех уголков России, в написании лабораторных, курсовых и дипломных работ по программированию.

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

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

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

Хочу отметить, что наибольшее количество моих учеников-студентов являются бауманцами. Возможно, это связано с тем, что я сам окончил МГТУ им.Баумана (прим. с красным дипломом).

yes Кстати, если хотите научиться безошибочно выполнять вузовские лабораторные работы по программированию, а также на достойном уровне выучить язык "чистый" Си, то записывайтесь ко мне на индивидуальную подготовку. Мой контактный №тел.: $8\ (926)\ 610 - 61 - 95$.

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

Для навигации по лабораторным работам используйте ссылочное меню в верхней части данной веб-страницы.

Также стоит учитывать тот факт, что издание могло переиздаваться. Следовательно, своего варианта, возможно, вы не сможете обнаружить в перечне заданий. В этом случае обязательно пишите нам на почту: administrator@videoege.ru. Поддержка оказывается круглосуточно!yes

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

Нужна ли регистрация на сайте для заказа лабораторной работы?

Нет, для заказа требуемой вам лабораторной работы не нужна никакая регистрация на сайте! Все, что вам необходимо - написать на наш электронный адрес: administrator@videoege.ru.
enlightened Мы готовы оказать вам любую информационную поддержку круглосуточно.

Лабораторная работа №1 (программирование алгоритмов разветвляющейся структуры)

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

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

enlightened ВАЖНО!

  • Стоимость программы из любого варианта составляет $200$ рублей.

  • Стоимость алгоритма (в виде отчета в формате *.doc из любого варианта составляет $200$ рублей (заказывается опционально на ваше усмотрение, чтобы детально разобраться с решением лабораторной работы, например, не прибегая к консультации репетитора).

Варианты заданий:

№ вар. Функция
1. Найти действительные корни биквадратного уравнения. Предусмотреть выдачу нужных сообщений.
2. Координаты заданных четырех точек на плоскости соединяются последовательно в порядке перечисления. Найти площадь получившейся фигуры.
3. Корабль может двигаться четырьмя курсами: на север, на юг, на запад и на восток. Капитан может дать команду на изменение курса: влево, вправо, вперед, назад. Определить новый курс корабля.
4. Решить систему двух линейных уравнений с двумя неизвестными . Предусмотреть выдачу сообщений: "нет решения", "бесконечное множество решений", "одно решение", "прямые параллельны или перпендикулярны".
5. Найти координаты точки пересечения прямой $y = kx + b$ и окружности заданного радиуса $r$ с центром в начале координат. В каких координатных четвертях находятся точки пересечения? Если точки пересечения нет или прямая только касается окружности, выдать соответствующее сообщение.
6. Поле шахматной доски задается парой натуральных чисел, первое из которых задает номер вертикали, а второе - номер горизонтали. Конь расположен на позиции $(a, b)$, а ладья - на $(c, d)$. Определить, угрожает ли конь ладье? Определить также, угрожает ли ладья коню?
7. Задают координаты трех точек на плоскости, которые последовательно соединяются между собой. Определить тип получаемого треугольника: прямоугольный, остроугольный, тупоугольный. Если треугольник построить нельзя, то сообщить, что точки лежат на одной прямой.
8. Задаются четыре различных числа: $a, b, c, d$. Выбрать из них три таких числа, которые составляют стороны треугольника наибольшей площади.
9. Координаты заданных четырех точек на плоскости соединяются последовательно в порядке перечисления. Определить вид получаемой геометрической фигуры: квадрат, прямоугольник, параллелограмм, трапеция, ромб, четырехугольник.
10. Координаты заданных четырех точек на плоскости соединяются последовательно в порядке перечисления. Является ли полученная фигура выпуклой?
11. Можно ли из прямоугольного металлического листа размером $a • b$ вырезать две прямоугольные заготовки размерами $c • d$ и $k • p$? Заготовки можно вырезать только параллельно сторонам листа.
12. С клавиатуры вводится номер года. Напечатать римскими цифрами век, к которому относится данный год.
13. Координаты заданных трех точек на плоскости соединяются последовательно в порядке перечисления. Определить площадь получаемого треугольника. Вычислить высоты и вывести их на экран в порядке возрастания.
14. Два прямоугольника, расположенные в первом квадранте, задаются координатами левого верхнего и правого нижнего углов. Вычислить площадь пересечения этих прямоугольников.
15. Образуют ли прогрессию цифры заданного четырехзначного числа? Определить вид и тип прогрессии.
16. Два отрезка на плоскости заданы координатами своих концов. Определить, имеют ли эти отрезки общие точки. Отрезки могут располагаться на одной прямой, на параллельных или пересекащихся прямых.
17. Заданы координаты вершин треугольника на плоскости. Вывести их значения в порядке обхода по часовой стрелке, начиная отсчет угла с оси $OY$.
18. Четырехугольник задается координатами своих вершин на плоскости. Определить, является ли он выпуклым.
19. Определить, лежат ли на одной прямой точки с координатами: $(x1; y1)$, $(x2; y2)$, $(x3; y3)$. Если точки лежат на одной прямой, то указать координаты точки, попавшей внутрь отрезка.
20. Заданы координаты трех вершин треугольника. Вводятся координаты четвертой точки. Определить, внутри или вне треугольника находится эта точка.
21. Заданы координаты вершин треугольника. Вывести расстояния от начала координат до вершин в порядке обхода против часовой стрелки, ведя отсчет от оси ординат.
22. Для двух окружностей одинакового радиуса задаются координаты их центров. Определить, пересекаются ли они? Если пересекаются, то вычислить площадь четырехугольника, образуемого центрами окружностей и точками их пересечения.
23. Координаты двух точек на плоскости задают прямую, которая делит плоскость на две полуплоскости. Вводятся координаты еще двух точек. Определить, принадлежат ли эти точки разным полуплоскостям или они лежат на той же самой прямой?
24. Поле шахматной доски задается парой натуральных чисел, первое из которых задает номер вертикали, а второе - номер горизонтали. Ферзь расположен на позиции $(a, b)$. Можно ли за один ход попасть на позицию $(c, d)$. Если нет, то как это сделать за два хода?
25. Определить, является ли палиндромом дробная часть действительного числа, имеющего до четырех значащих цифр?

Лабораторная работа $№1$ предполагает написание программы на языке Си. При заказе работы своего варианта вы получите качественно написанную и хорошо прокомментированную программу.

Если дополнительно закажите алгоритм решения вашей задачи (мы крайне рекомендуем это сделать), то получите аккуратно оформленный отчет-алгоритм, поясняющий все тонкости решения поставленной задачи.

Образец выполнения (вариант №7)

Напомним условие задания к варианту $№7$:

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

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

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

  Прямоугольный треугольник Остроугольный треугольник Тупоугольный треугольник
Внешний вид
Определение

Прямоугольный треугольник - треугольник, в котором один угол прямой (то есть $90$ градусов)

$\angle C = 90º$

Остроугольным называют треугольник, у которого все углы острые (то есть меньше $90$ градусов)

$\angle A \lt 90º$, $\angle B \lt 90º$, $\angle C \lt 90º$

Тупоугольным называют треугольник, у которого один из углов тупой (то есть больше $90$ градусов)

$\angle C \gt 90º$

Свойство Сумма квадратов двух сторон равна квадрату его наибольшей третьей стороны (т. Пифагора): $AC^2 + BC^2 = AB^2$. Сумма квадратов двух сторон больше квадрата его наибольшей третьей стороны: $AC^2 + BC^2 > AB^2$. Сумма квадратов двух сторон меньше квадрата его наибольшей третьей стороны: $AC^2 + BC^2 < AB^2$.

enlightened То есть, зная длины сторон треугольника, можно однозначно определить его тип!

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

Если даны две точки $A(x_{1}; y_{1})$ и $B(x_{2}; y_{2})$, то формула имеет вид: $L = \sqrt{(x_{2} - x_{1})^2 + (y_{2} - y_{1})^2}$.

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

Обратите внимание, что во всех этих условиях: $AC^2 + BC^2 = AB^2$, $AC^2 + BC^2 > AB^2$, $AC^2 + BC^2 < AB^2$, нужно знать наибольшую сторону треугольника ($AB$). Понятно, что отыскать ее не составляет никакой сложности, написав соответвующую функцию на языке Си, но при этом придется запомнить оставшиеся $2$ стороны, как ненаибольшие. Проблема в плане кодирования в том, что, используя три переменных для сторон треугольника, неизвестно, какая из них будет выражать наибольшую сторону!

Поэтому применяем следующий прием - к обоим частям выражений добавляем квадрат длины наибольшей стороны:

  • $AC^2 + BC^2 + AB^2 = 2·AB^2$ - прямоугольный треугольник;

  • $AC^2 + BC^2 + AB^2 > 2·AB^2$ - остроугольный треугольник;

  • $AC^2 + BC^2 + AB^2 < 2·AB^2$ - тупоугольный треугольник.

Обратите внимание, что в левой части происходит суммирование всех длин сторон треугольника, а в правой фигурирует лишь наидлинейшая сторона (конкретно в этом примере это сторона $AB$). Алгоритмически это означает, что в процессе кодирования, нам придется отыскать лишь самую длинную сторону и этого будет достаточно.

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

Условие существования треугольника применительно к нашему случаю: длина наибольшей стороны треугольника должна быть строго меньше суммы двух других сторон треугольника ($AB < AC + BC$).

А теперь давайте выделим функции, которые нам пригодятся в процессе кодирования:

№ функции Назначение функции
1 Считывание координат вершины треугольника. Это можно вынести в отдельную функцию, т к у треугольника $3$ вершины, следовательно, данная операция потребуется трижды.
2 Нахождение длины стороны треугольника. У треугольника целых $3$ стороны, поэтому данная операция нам потребуется трижды.
3 Нахождение максимального значения из двух заданных значений. Это функция нам потребуется, когда придется определять самую длинную сторону треугольника.
4 И последняя функция - функция main(). Данная функция является точкой входой в программы на языке Си, следовательно, она присутствует вообще в любой Си-программе.

Реализация задачи на языке Си:

#include <stdio.h>      // для ввода, вывода (scanf, printf)
#include <conio.h>      // для задержки программы (getch)
#include <math.h>       // возвдение в степень, извлечения корня, модуль (pow, sqrt, fabs)
#include <locale.h>     // для руссификации программы (setlocale)

#define EPS 0.000001    // точность расчетов
//---------------------------------------------------------------------------------------
// структура "Точка на плоскости"
//---------------------------------------------------------------------------------------
struct TPoint
{
    int x;      // отвечает за значение абсциссы
    int y;      // отвечает за значение ординаты
};
//---------------------------------------------------------------------------------------
// ввод с клавиатуры координат текущей точки (А, В или С)
//---------------------------------------------------------------------------------------
struct TPoint InputPointCoords(const char* pmessage)
{
    struct TPoint tmp;
   
    printf(pmessage);
    printf("\t- введите координату по оси абсцисс(x): ");
    scanf("%d", &tmp.x);
    printf("\t- введите координату по оси ординат(y): ");
    scanf("%d", &tmp.y);

    return tmp;
}
//---------------------------------------------------------------------------------------
// нахождение расстояние между двумя точками на плоскости
//---------------------------------------------------------------------------------------
float GetDistanceBetweenPoints(const struct TPoint ppoint1, const struct TPoint ppoint2)
{
    float distance = sqrt(pow((ppoint1.x - ppoint2.x), 2.0) + pow((ppoint1.y - ppoint2.y), 2.0));
    return distance;
}
//---------------------------------------------------------------------------------------
// нахождение максимального из 2-х величин
//---------------------------------------------------------------------------------------
float GetMax(const float pa, const float pb)
{
    if(pa > pb)
        return pa;
    return pb;
}
//---------------------------------------------------------------------------------------
int main(void)
{
    struct TPoint a, b, c;          // вершины треугольника (А, В, С)
    float sideAB, sideBC, sideCA;   // длины сторон треугольника (АВ, ВС, СА)
    float sideMax;                  // самая длинная сторона из всех сторон треугольника
    float typeTriangle;             // позволяет определить тип треугольника

    setlocale(LC_ALL, "rus");       // руссификация диалогов программы

    // запрашиваем с клавиатуры координаты всех вершин треугольника
    a = InputPointCoords("Ввод координат точки А\n");
    b = InputPointCoords("\nВвод координат точки B\n");
    c = InputPointCoords("\nВвод координат точки C\n");
   
    // вычисляем длины сторон треугольника (AB, BC, CA)
    sideAB = GetDistanceBetweenPoints(a, b);
    sideBC = GetDistanceBetweenPoints(b, c);
    sideCA = GetDistanceBetweenPoints(c, a);

    // находим самую длинную сторону среди всех сторон треугольника
    sideMax = GetMax(GetMax(sideAB, sideBC), sideCA);

    // проверка треугольника на существование
    // сумма длин меньших 2-х сторон должна быть больше 3-й стороны (a + b > c)
    // или сумма длин ВСЕХ сторон, должна быть больше удвоенной длины наибольшей стороны (a + b + c > 2c)
    if(fabs(sideAB + sideBC + sideCA - 2 * sideMax) <= EPS)
    {
        printf("\nТреугольник с заданными координатами вершин не существует!");
        printf("\nТочки лежат на одной прямой! Программа закрывается...");
        getch();
        return 0;
    }

    // если выполняется условие a^2 + b^2 = c^2 - треугольник прямоугольный
    // перепишем это условие немного по-другому: a^2 + b^2 + c^2 = 2c^2 - прямоугольный
    // a^2 + b^2 + c^2 > 2c^2 - остроугольный      a^2 + b^2 + c^2 < 2c^2 - тупоугольный
    typeTriangle = pow(sideAB, 2) + pow(sideBC, 2) + pow(sideCA, 2) - 2 * pow(sideMax, 2);
    printf("\n\nТреугольник с заданными координатами вершин является: ");
    if(fabs(typeTriangle) <= EPS)
        printf("прямоугольным");
    else
        if(typeTriangle > 0)
            printf("остроугольным");
        else
            printf("тупоугольным");
    printf("\nДля завершения работы программы нажмите клавишу ENTER...");
    getch();    // задержка программы, чтобы можно было просмотреть результат
    return 0;   // завершение программы и передача управления в ОС
}
//---------------------------------------------------------------------------------------

Результаты работы программы:

№ теста Тип треугольника Результат
1

2
3
4

Лабораторная работа №2 (программирование циклов с управляющим параметром)

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

Задана функция на отрезке в виде графика. Задаются произвольный отрезок $[a; b]$ и число табулирования $n > 100$. Протабулировать функцию и постранично вывести результат на экран в виде таблицы с "шапкой", состоящей из четрыех столбцов: номер точки, аргумент, значение функции, минимальное или максимальное значение.

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

enlightened ВАЖНО!

  • Стоимость программы из любого варианта составляет $150$ рублей.

  • Стоимость блок-схемы из любого варианта составляет $150$ рублей.

Варианты заданий:

Вариант Заданная функция
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.

Лабораторная работа $№2$ предполагает написание программы на языке Си. При заказе работы своего варианта вы получите качественно написанную и хорошо прокомментированную программу.

Если дополнительно закажите алгоритм решения вашей задачи (мы крайне рекомендуем это сделать), то получите аккуратно оформленный отчет-алгоритм, поясняющий все тонкости решения поставленной задачи.

Образец выполнения (вариант №3)

находится в разработке...

Лабораторная работа №3 (программирование циклов с предусловием и с постусловием)

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

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

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

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

Результаты напечатать в виде таблицы из четырех столбцов с соответствующей "шапкой".

enlightened ВАЖНО!

  • Стоимость программы из любого варианта составляет $200$ рублей.

  • Стоимость блок-схемы из любого варианта составляет $200$ рублей.

Варианты заданий:

Вариант Ряд Функция и область сходимости
1. $x - \frac{x^3}{3!} + \frac{x^5}{5!} - \frac{x^7}{7!} +\ ...$  
2. $sin(\alpha) + xcos(\alpha) - x^2\frac{sin(\alpha)}{2!} - x^3\frac{cos(\alpha)}{2!} + x^4\frac{sin(\alpha)}{4!} +\ ...$  
3. $1 - \frac{x^2}{2!} + \frac{x^4}{4!} - \frac{x^6}{6!} +\ ...$  
4. $cos(\alpha) + xsin(\alpha) - x^2\frac{cos(\alpha)}{2!} - x^3\frac{sin(\alpha)}{2!} + x^4\frac{cos(\alpha)}{4!} +\ ...$  
5. $x + \frac{x^3}{3!} + \frac{x^5}{5!} + \frac{x^7}{7!} +\ ...$  
6. $1 + \frac{x^2}{2!} + \frac{x^4}{4!} + \frac{x^6}{6!} +\ ...$  
7. $1 + x + \frac{x}{2!} + \frac{x}{3!} +\ ...$  
8. $1 + x·ln(\alpha) + \frac{(x\ ·\ ln(\alpha))^2}{2!} + \frac{(x\ ·\ ln(\alpha))^3}{3!} +\ ...$  
9. $(x - 1) - \frac{(x - 1)^2}{2} + \frac{(x - 1)^3}{3} - \frac{(x - 1)^4}{4} +\ ...$  
10. $x + \frac{x^7}{2·3} + 3·\frac{x^5}{2·4·5} + 3·5·\frac{x^7}{2·4·6·7} +\ ...$  
11. $\pi - (x + \frac{x^7}{2·3} + 3·\frac{x^5}{2·4·5} + 3·5·\frac{x^7}{2·4·6·7} +\ ...)$  
12.

$\pm \frac{\pi}{2} - \frac{1}{x} + \frac{1}{3}·x^3 - \frac{1}{5}·x^5 + \frac{1}{7}·x^7 -\ ...$

первый член со знаком плюс, при $x \gt 0$ и со знаком минус при $x \lt 0$

 
13. $\frac{\pi}{2} - (x - \frac{x^3}{3} + \frac{x^5}{5} - \frac{x^7}{7} -\ ...)$  
14. $x·\frac{3 + x}{3!} - x^3·\frac{5 + x}{5!} + x^5·\frac{7 + x}{7!} -\ ...$ $\frac{1 - cos(x) - sin(x)}{x}$
15. $\frac{x}{3!} - \frac{x^3}{5!} + \frac{x^5}{7!} - \frac{x^7}{9!} +\ ...$ $\frac{x - sin(x)}{x^2}$
16. $\frac{2x}{1!} - \frac{3x^2}{2!} + \frac{4x^3}{3!} - \frac{5x^4}{4!} +\ ...$ $x·e^{-x} - e^x + 1$
17. $x^2(\frac{1}{1!} + \frac{1}{2!}) - x^4(\frac{1}{2!} + \frac{1}{4!}) + x^6(\frac{1}{3!} + \frac{1}{6!}) +\ ...$ $2 - e^{-x} - cos(x)$
18. $x(\frac{1}{1} + \frac{1}{1!}) - x^2(\frac{1}{2} + \frac{1}{2!}) + x^3(\frac{1}{3} + \frac{1}{3!}) +\ ...$ $ln(1 + x) - x·e^{-x} + 1$
19. $x(\frac{1}{1!} - \frac{1}{2!}) - x^2(\frac{1}{2!} - \frac{1}{4!}) + x^3(\frac{1}{3!} - \frac{1}{6!}) +\ ...$ $cos(x) - e^{-x}$
20. $x·\frac{2 + x}{2!} - x^3·\frac{4 + x}{4!} - x^5·\frac{6 + x}{6!} +\ ...$ $sin(x) - cos(x) + 1$
21. $1 - \frac{3x^2}{2!} + \frac{5x^4}{4!} - \frac{7x^6}{6!} +\ ...$ $cos(x) - x·sin(x)$
22. $\frac{2x^6}{3!} - \frac{4x^{10}}{5!} + \frac{6x^{14}}{7!} - \frac{8x^{18}}{9!} +\ ...$ $sin(x^2) - x^2·cos(x^2)$
23. $x·\frac{2 - x}{2!} + x^5·\frac{6 - x}{6!} + x^9·\frac{10 - x}{10!} +\ ...$ $\frac{sin(x) + cos(x) - e^{-x}}{2}$
24. $x^2(\frac{1}{1!} + \frac{1}{1!}) - x^4(\frac{1}{2!} + \frac{1}{3!}) + x^6(\frac{1}{3!} + \frac{1}{5!}) -\ ...$ $x·sin(x) - e^{-x} + 1$
25. $\frac{x^2}{4!} - \frac{x^4}{6!} + \frac{x^6}{8!} - \frac{x^8}{10!} +\ ...$ $\frac{cos(x) - 1}{x^2} + \frac{1}{2}$

Лабораторная работа $№3$ предполагает написание программы на языке Си. При заказе работы своего варианта вы получите качественно написанную и хорошо прокомментированную программу.

Если дополнительно закажите алгоритм решения вашей задачи (мы крайне рекомендуем это сделать), то получите аккуратно оформленный отчет-алгоритм, поясняющий все тонкости решения поставленной задачи.

Образец выполнения (вариант №15)

Напомним условие задания к варианту $№15$:

Вариант Ряд Функция и область сходимости
15. $\frac{x}{3!} - \frac{x^3}{5!} + \frac{x^5}{7!} - \frac{x^7}{9!} + ...$ $\frac{x - sin(x)}{x^2}$

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

По условии задания просят использовать рекуррентные соотношения. Попробуем получить эту рекуррентность. Рассмотрим первых $3$ слагаемых данного ряда:

№ слагаемого Знак Значение
1. $+$ $\frac{x}{3!}$
2. $-$ $\frac{x^3}{5!}$
3. $+$ $\frac{x^5}{7!}$

Смысл рекуррентных соотношений заключается в том, чтобы очередное слагаемое, в нашем случае ряда, можно было вычислить, используя предыдущее слагаемое этого же ряда. Найдем отношение слагаемых заданного ряда под $№2$ и $№1$: $k_{1} = \frac{Слагаемое_{2}}{Слагаемое_{1}} = \frac{x^3}{5!} : \frac{x}{3!} = \frac{x^3\ ·\ 3!}{5!\ ·\ x} = \frac{x^2}{4\ ·\ 5}$.

То есть, чтобы вычислить слагамое ряда, стоящее на $2$-й позиции, нужно взять слагаемое под $№1$ и умножить его на этот коэффициент $k_{1}$, равный $\frac{x^2}{4\ ·\ 5}$. Также не стоит забыть еще поставить перед $2$-ым слагаемым знак "минус", т к заданный ряд является знакочередующимся.

Сейчас рассмотрим отношение $3$-го и $2$-го члена данного ряда: $k_{2} = \frac{x^5}{7!} : \frac{x^3}{5!} = \frac{x^5\ ·\ 5!}{7!\ ·\ x^3} = \frac{x^2}{6\ ·\ 7}$. То есть, чтобы вычислить слагамое ряда, стоящее на $3$-й позиции, нужно взять слагаемое под $№2$ и умножить его на этот коэффициент $k_{2}$, равный $\frac{x^2}{6\ ·\ 7}$. Третий член ряда также должен быть положительным.

enlightened В итоге мы видим, что рекуррентное соотношение не является постоянным ($k_{1} \neq k_{2})$. Это важнейший момент в данном алгоритме! Такую зависимость принято называть рекуррентным соотношением с непостоянным коэффициентом.

Если продолжить вычислять последующие коэффициенты рекуррентных соотношений: $k_{3},\ k_{4},\ ...$, то можно заметить, что все они являются дробями, числитель которых строго равен $x^2$, а вот знаменатель будет меняться, но при этом знаменатель будет всегда равен произведению двух натуральных чисел.

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

$Слагаемое_{2} = Слагаемое_{1}\ ·\ k_{1} = \frac{x}{3!}\ ·\ \frac{x^2}{4\ ·\ 5}$. На момент, когда происходит вычисление $2$-го члена ряда, в сумму уже было включено значение $1$-го члена, значит, количество уже учтенных слагаемых равно $1$. Тогда, попытаемся связать формулой количество уже учтенных слагаемых, со знаменателем соответствующего коэффициента рекуррентного соотношения:

  • $4 = (количество\ учтенных\ слагаемых\ +\ 1)\ ·\ 2$.

  • $5 = (количество\ учтенных\ слагаемых\ +\ 1)\ ·\ 2\ +\ 1$.

Эти зависимости будут справедливы абсолютно для любого коэффициента рекуррентного соотношения.

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

Что касается знакочередования слагаемых в ряду, то учеть это досаточно просто: необходимо при вычислении текущего члена домножать его на $(-1)$.

И последнее, на что хотелось бы обратить внимание! В условии говорится, что вычисление суммы заданного ряда заканчивается, если модуль очередного слагаемого ряда меньше заданной точности. Это означает, что, как только условие $(|текущее\ слагаемое| >= точность)$ становится ложным, все расчеты прекращаются. И это слагаемое НЕ попадает в результат.

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

Реализация задачи на языке Си:

#include <stdio.h>      // для ввода-вывода (scanf, printf)
#include <conio.h>      // для задержки программы (getch)
#include <locale.h>     // для руссификации (setlocale)
#include <math.h>       // для мат.функций (sin)

//---------------------------------------------------------------------------------------------
// функция, которая находит сумму ряда, последний учтенный член ряда, общее кол-во членов ряда
// px - текущее значение аргумента
// psumSeries - отвечает за накопление суммы ряда
// plastTerm - отвечает за последний учтенный член ряда
// pcountTerm - отвечает за общее кол-во учтенных членов суммы ряда
// peps - точность расчетов
//---------------------------------------------------------------------------------------------
void F(const float px, long double *psumSeries, long double *plastTerm, int *pcountTerm, const float peps)
{
    long double currentTerm = +1 * px / (1 * 2 * 3);    // инициализация значением 1-го слагаемого ряда (x / 3!)
    long int denominatorFactorial;      // помогает использовать рекуррентную зависимость

    // сумму ряда, кол-во слагаемых нужно обнулять до начала всех расчетов
    *psumSeries = *plastTerm = *pcountTerm =  0;

    // пока модуль текущего слагаемого ряда не меньше заданной точности
    // это текущее слагаемое добавляется к общей сумме ряда
    while(fabs(currentTerm) >= peps)
    {
        (*pcountTerm)++;                // увеличиваем общее кол-во членов ряда на 1
        *psumSeries += currentTerm;     // сумма ряда увеличивается на величину последнего учтенного слагаемого
        *plastTerm = currentTerm;       // текущее слагаемое на данный момент является последним учтенным

        // вычисляем знаменатель дроби, на которую будет домножаться текущий член для получения следующего
        denominatorFactorial = ((*pcountTerm + 1) * 2) * ((*pcountTerm + 1) * 2 + 1);
        // вычисляем рекуррентно очередное слагаемое ряда (в итоговой сумме оно еще не учтено)   
        currentTerm = -currentTerm * ((px * px) / (denominatorFactorial));
    }
}
//---------------------------------------------------------------------------------------------
// главная функция программы (точка входа)
//---------------------------------------------------------------------------------------------
int main()
{
    float x;                // входное значение
    long double sumSeries;  // сумма ряда
    long double lastTerm;   // последнее учтенное слагаемое
    int countTerm;          // количество учтенных слагаемых

    setlocale(LC_ALL, "rus");   // настройка руссификации диалогов

    // запрашиваем вводом с клавиатуры входное значение х
    printf("Введите значение Х для вычислений: ");
    scanf("%f", &x);

    // выводим на экран шапку таблицы результатов
    printf("\n\nТаблица результатов:");
    printf("\n--------------------------------------------------------------------------------------\n");
    printf("|  Сумма ряда  | Последнее слагаемое ряда | Количество слагаемых | Точность расчетов |\n");
    printf("--------------------------------------------------------------------------------------\n");

    // производим все вычисления с точностю = 0.001
    F(x, &sumSeries, &lastTerm, &countTerm, 0.001);
    printf("| %12.3lf | %24.3lf | %20d | %17.3f |\n", sumSeries, lastTerm, countTerm, 0.001);
    printf("--------------------------------------------------------------------------------------\n");

    // производим все вычисления с точностю = 0.0001 (отличие на порядок, чем шагом раньше)
    F(x, &sumSeries, &lastTerm, &countTerm, 0.0001);
    printf("| %12.4lf | %24.4lf | %20d | %17.4f |\n", sumSeries, lastTerm, countTerm, 0.0001);
    printf("--------------------------------------------------------------------------------------\n");

    // производим все вычисления с точностю = 0.00001 (отличие на порядок, чем шагом раньше)
    F(x, &sumSeries, &lastTerm, &countTerm, 0.00001);
    printf("| %12.5lf | %24.5lf | %20d | %17.5f |\n", sumSeries, lastTerm, countTerm, 0.00001);
    printf("--------------------------------------------------------------------------------------\n");

    // вычисляем сумму ряда по контрольной формуле и выводим на экран с большой точностью (до 10 цифр)
    printf("Значение, полученное по контрольной формуле: %0.10f", (x - sin(x)) / (x * x));

    printf("\n\nДля завершения работы программы нажмите клавишу ENTER...");
    getch();    // задержка программы, чтобы можно было просмотреть результаты
    return 0;   // завершение программы и передача управления в ОС
}
//---------------------------------------------------------------------------------------------

Результаты работы программы:

Лабораторная работа №4 (программирование алгоритмов работы с одномерными массивами)

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

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

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

enlightened ВАЖНО!

  • Стоимость программы из любого варианта составляет $200$ рублей.

  • Стоимость алгоритма (в виде отчета в формате *.doc из любого варианта составляет $200$ рублей (заказывается опционально на ваше усмотрение, чтобы детально разобраться с решением лабораторной работы, например, не прибегая к консультации репетитора).

Варианты заданий:

Вариант Задание
1. В одномерном массиве, состоящем из $n$ вещественных чисел, вычислить сумму положительных элементов с нечетными номерами и максимальное произведение положительных подряд идущих элементов. Сформировать новый массив, состоящий из отрицательных элементов исходного массива.
2. В одномерном массиве, состоящем из $n$ целых чисел, вычислить сумму положительных четных элементов и минимальное произведение отрицательных подряд идущих элементов. Сформировать новый массив, состоящий из минимальных элементов исходного массива.
3. В одномерном массиве, состоящем из $n$ вещественных чисел, вычислить сумму максимальных элементов с четными номерами и максимальное произведение отрицательных подряд идущих элементов. Сформировать новый массив, состоящий из элементов исходного массива, равных первому элементу.
4. В одномерном массиве, состоящем из $n$ вещественных чисел, вычислить сумму минимальных элементов с нечетными номерами и максимальное произведение трех соседних элементов. Сформировать новый массив, состоящий из элементов исходного массива, равных предпоследнему элементу.
5. В одномерном массиве, состоящем из $n$ вещественных чисел, вычислить сумму отрицательных элементов с четными номерами и максимальное произведение трех соседних элементов. Сформировать новый массив, состоящий из элементов исходного массива, равных предпоследнему элементу.
6. В одномерном массиве, состоящем из $n$ вещественных чисел, вычислить сумму положительных элементов с нечетными номерами и минимальную сумму трех соседних элементов. Сформировать новый массив, состоящий из элементов исходного массива, равных предпоследнему элементу.
7. В одномерном массиве, состоящем из $n$ целых чисел, вычислить сумму минимальных элементов, равных максимальному элементу, и максимальное произведение двух равноотстоящих от центра элементов. Сформировать новый массив, состоящий из элементов исходного массива, равных среднеарифметическому значению максимального и минимального элементов.
8. В одномерном массиве из $n$ целых чисел вычислить среднегеометрическое всех положительных элементов массива и сумму положительных элементов массива, расположенных после второго максимального элемента. Сформировать новый массив, состоящий из последних элементов исходного массива, сумма которых равна сумме максимальных и минимальных элементов.
9. В одномерном массиве из $n$ целых чисел вычислить сумму всех положительных элементов массива с номерами, кратными заданному целому числу, и сумму нечетных элементов массива, расположенных между вторым минимальным и первым максимальным элементами. Сформировать новый массив, состоящий из элементов исходного массива, из которого удалены первый максимальный и последний минимальный элементы.
10. В одномерном массиве из $n$ целых чисел вычислить сумму всех положительных элементов массива, расположенных до последнего максимального элемента, и сумму четных элементов массива, расположенных между первым и вторым минимальными элементами. Сформировать новый массив, состоящий из элементов исходного массива, из которого удалены первый минимальный и последний минимальный элементы.
11. В одномерном массиве из $n$ целых чисел вычислить сумму всех положительных элементов массива, расположенных между минимальным и максимальным элементами, и сумму элементов массива, расположенных до последнего минимального элемента. Сформировать новый массив, состоящий из элементов исходного массива, из которого удалены все минимальные элементы.
12. В одномерном массиве из $n$ целых чисел вычислить сумму всех положительных элементов массива, расположенных между первым и последним минимальными элементами, и сумму нечетных элементов массива, расположенных до последнего максимального элемента. Сформировать новый массив, состоящий из элементов исходного массива, из которого удалены все нулевые элементы.
13. В одномерном вещественном массиве из $n$ чисел вычислить сумму всех положительных элементов массива, расположенных между первым и последним максимальными элементами, и сумму элементов массива, расположенных до предпоследнего минимального элемента. Сформировать новый массив, состоящий из элементов исходного массива, из которого удалены все отрицательные элементы.
14. В одномерном массиве, состоящем из $n$ вещественных чисел, вычислить сумму положительных элементов с четными номерами и максимальное произведение знакочередующихся двух соседних элементов. Сформировать новый массив, состоящий из положительных элементов исходного массива, расположенных после максимального элемента.
15. В одномерном массиве, состоящем из $n$ целых чисел, вычислить сумму положительных нечетных элементов и максимальную сумму подряд идущих отрицательных элементов. Сформировать новый массив из элементов, расположенных между первым и последним минимальными элементами исходного массива.
16. В одномерном массиве, состоящем из $n$ вещественных чисел, вычислить сумму минимальных элементов с нечетными номерами и минимальное произведение отрицательных подряд идущих элементов. Сформировать новый массив, состоящий из элементов исходного массива, находящихся между максимальным и предпоследним элементами.
17. В одномерном массиве, состоящем из $n$ вещественных чисел, вычислить сумму максимальных элементов массива и максимальное произведение подряд идущих положительных элементов массива. Сформировать новый массив, состоящий из элементов исходного массива, находящихся между минимальным и последним положительным элементами массива.
18. В одномерном массиве, состоящем из $n$ вещественных чисел, вычислить сумму положительных элементов с нечетными номерами и максимальную сумму трех соседних знакочередующихся элементов. Сформировать новый массив, состоящий из элементов исходного массива, находящихся между максимальным и первым положительным элементами массива.
19. В одномерном массиве, состоящем из $n$ вещественных чисел, вычислить сумму элементов с четными номерами, которые больше заданного числа $M$, и минимальную сумму двух элементов, равноотстоящих от середины массива. Сформировать новый массив, состоящий из элементов исходного массива, находящихся между среднеарифметическим и максимальным значениями элементов.
20. В одномерном массиве, состоящем из $n$ целых чисел, вычислить сумму минимальных элементов, находящихся на нечетных местах, а также максимальную сумму двух равноотстоящих от центра элементов и их номера. Сформировать новый массив, состоящий из элементов исходного массива, равных среднеарифметическому значению максимального и минимального элементов.
21. В одномерном массиве из $n$ целых чисел вычислить среднегеометрическое всех положительных элементов массива и сумму положительных элементов массива, расположенных после второго максимального элемента. Сформировать новый массив, состоящий из начальных элементов исходного массива, сумма которых равна сумме максимальных и минимальных элементов.
22. В одномерном массиве из $n$ целых чисел вычислить сумму элементов массива, кратных заданному целому числу, и сумму нечетных элементов массива, расположенных между последним минимальным и вторым максимальным элементами. Сформировать новый массив, состоящий из элементов исходного массива, из которого удалены максимальные и первый минимальный элементы.
23. В одномерном массиве из $n$ целых чисел вычислить сумму элементов массива, расположенных до первого максимального элемента, и сумму нечетных элементов массива, расположенных между вторым и последним минимальными элементами. Сформировать новый массив, состоящий из элементов исходного массива, из которого удален последний максимальный элемент.
24. В одномерном массиве из $n$ целых чисел вычислить сумму всех положительных элементов массива, расположенных между вторым четным и максимальным элементами, и сумму элементов массива, расположенных до первого нечетного отрицательного элемента. Сформировать новый массив, состоящий из элементов исходного массива, из которого удалены все отрицательные элементы.
25. В одномерном массиве из $n$ целых чисел вычислить сумму всех положительных элементов массива, расположенных между первым нечетным и последним максимальным элементами, и сумму четных элементов массива, расположенных после последнего максимального элемента. Сформировать новый массив, состоящий из элементов исходного массива, из которого удалены все элементы, кратные заданному числу.

Лабораторная работа $№4$ предполагает написание программы на языке Си. При заказе работы своего варианта вы получите качественно написанную и хорошо прокомментированную программу.

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

Образец выполнения (вариант №15)

Напомним условие задания к варианту $№15$:

В одномерном массиве, состоящем из $n$ целых чисел, вычислить сумму положительных нечетных элементов и максимальную сумму подряд идущих отрицательных элементов. Сформировать новый массив из элементов, расположенных между первым и последним минимальными элементами исходного массива.

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

Сначала выделим список проблем, которыми обладает текущая постановка задачи:

  1. В условии ни слова не сказано о максимальном количестве элементов одномерного массива.

  2. В условии ни слова не сказано о допустимых значениях элементов одномерного массива.

Рассмотрим первую проблему. Стоит ли давать пользователю работать с массивом, состоящим из $1$-го элемента? Очевидно, что нет! Стоит ли давать пользователю работать с массивом, состоящим из одного миллиона элементов? Очевидно также, что нет, т к заполнение элементов производится вводом с клавиатуры, а, например, не случайным образом. Какое максимальное количество элементов можно задать по умолчанию? Сделаем по аналогию с примером, показанным в данном пособии, то есть ограничим это количество элементов числом $30$.

Рассмотрим вторую проблему. В условии говорится, что элементы массива представляют собой целые числа. Но диапазон целых чисел, с точки зрения математики, бесконечен. Следовательно, нам нужно ввести какие-то здравые ограничения. Предлагаю работать с целыми числами на отрезке $[-100; +100]$. Этого диапазона вполне будет достаточно, чтобы продемонстрировать все необходимые вычисления.

enlightened Рассмотрим фрагмент постановки задачи: "вычислить сумму положительных нечетных элементов". Вспомним, что число называется положительным, если оно строго больше нуля (например: $11$, $7$, $90$, $55$ и т.д.). Вспомним, что число называется нечетным, если оно не делится на $2$ без остатка (например: $11$, $7$, $55$ и т.д.).

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

-17 0 3 23 6 -6 -6 10 значение элемента массива
0 1 2 3 4 5 6 7 индекс элемента массива

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

enlightened Рассмотрим следующий фрагмент постановки задачи: "максимальную сумму подряд идущих отрицательных элементов". Вспомним, что число называется отрицательным, если оно строго меньше нуля (например: $-7$, $-20$, $-99$, $-1$ и т.д.). Также стоит учесть, что сумма отрицательных значений тем больше, чем она ближе к нулю.

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

-3 -10 -5 16 -4 17 1 -90 -1 4 -5 -6 значение
0 1 2 3 4 5 6 7 8 9 10 11 индекс
1-я цепочка   2- цепочка     3-я цепочка   4-я цепочка № цепочки

Обратите внимание, что цепочку может образовывать даже один отрицательный элемент (цепочка $№2$). Найдем сумму отрицательных элементов каждой из этих $4$-рех цепочек:

  • Сумма цепочки №1 $= (-3) + (-10) + (-5) = -18$.

  • Сумма цепочки №2 $= -4$.

  • Сумма цепочки №3 $= (-90) + (-1) = -91$.

  • Сумма цепочки №4 $= (-5) + (-6) = -11$.

Нам нужно взять максимальное значение из этих $4$-рех полученных. Очевидно, что максимальным является число $-4$, так как оно ближе всех к нулю.

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

enlightened Рассмотрим завершающий фрагмент постановки задачи: "Сформировать новый массив из элементов, расположенных между первым и последним минимальными элементами исходного массива".

  1. Минимальный элемент точно присутствует в заданном массиве.

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

Рассмотрим одномерный массив целых чисел, состоящий из $10$ элементов (визуализация с точки зрения языка Си):

Самый наименьший элемент среди элементов заданного массива имеет значение $-77$. Первый минимальный элемент занимает позицию с индексом $2$, а последний минимальный элемент - позицию с индексом $8$. Следовательно, в новый массив мы должны перености все элементы, находящиеся между элементами с индексами $2$ и $8$. Сформированный массив будет состоять из пяти элементов.

Важно понимать, что сформированный массив будет состоять из количества элементов, равных исходному. Но "хвостовые" элементы (это элементы с индексами $[5 .. 9]$ имеют сероватый фон на рисунке выше) будут иметь неопределенное значение.

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

  • Ввод количества элементов одномерного массива (InputCountElements).

  • Заполнение элементов одномерного массива целых чисел вводом с клавиатуры (FillVectorByKeyboard).

  • Вывод значения элементов одномерного массива на экран (PrintVector).

  • Вычисление суммы положительных нечетных элементов (GetSumPlusOddElements).

  • Вычисление максимальной суммы подряд идущих отрицательных элементов (GetMaxSumMinusElements).

  • Нахождение минимального элемента исходного массива (GetMinElement).

  • Получение индекса первого минимального элемента (GetIndexFirstMinElement).

  • Получение индекса последнего минимального элемента (GetIndexLastMinElement).

  • Формирование нового массива из элементов между первым и последним минимальным (FormVectorBetweenMin).

Итого получилось $9$ функций. Каждая из этих функций выполняет строго одно действие и это важнейший момент правильного программирования.

Реализация задачи на языке Си:

#include <stdio.h>      // для ввода, вывода (scanf, printf)
#include <locale.h>     // для руссификации (setlocale)
#include <conio.h>      // для задержки программы (getch)

#define nmax 30         // максимально возможное число элементов в массиве
//------------------------------------------------------------------------------------
// ввод с клавиатуры количества элементов массива
//------------------------------------------------------------------------------------
int InputCountElements(void)
{
    int countElements;
    do
    {
        printf("Введите количество элементов одномерного массива из отрезка [2 ... %d]: ", nmax);
        scanf("%d", &countElements);
    }
    while((countElements < 2) || (countElements > nmax));
    return countElements;
}
//------------------------------------------------------------------------------------
// Заполнение элементов одномерного массива целых чисел вводом с клавиатуры
//------------------------------------------------------------------------------------
void FillVectorByKeyboard(int pvector[], const int pcount)
{
    int i;
    printf("\nВам предстоит ввести %d целых чисел из отрезка [-100 ... +100].\n", pcount);
    for(i = 0; i < pcount; i++)
    {
        printf("\t- введите %d-й элемент массива: ", (i + 1));
        scanf("%d", &pvector[i]);
    }
}
//------------------------------------------------------------------------------------
// Вывод значения элементов одномерного массива на экран
//------------------------------------------------------------------------------------
void PrintVector(const int pvector[], const int pcount, const char* pmessage)
{
    int i;
    printf(pmessage);
    for(i = 0; i < pcount; i++)
        printf("%7d", pvector[i]);
}
//------------------------------------------------------------------------------------
// Вычисление суммы положительных нечетных элементов
//------------------------------------------------------------------------------------
int GetSumPlusOddElements(const int pvector[], const int pcount)
{
    int sum = 0;
    int i;
    for(i = 0; i < pcount; i++)
        if((pvector[i] > 0) && (pvector[i] % 2 == 1))
            sum += pvector[i];
    return sum;
}
//------------------------------------------------------------------------------------
// Вычисление максимальной суммы подряд идущих отрицательных элементов
//------------------------------------------------------------------------------------
int GetMaxSumMinusElements(const int pvector[], const int pcount)
{
    int i;
    int maxSum = 0;
    int currentSum = 0;
    for(i = 0; i < pcount; i++)
    {
        if(pvector[i] < 0)
            if(currentSum == 0)
                currentSum = pvector[i];
            else
                currentSum += pvector[i];
        if((pvector[i] >= 0) && (currentSum != 0))
        {
            if((currentSum > maxSum) || (maxSum == 0))
                maxSum = currentSum;
            currentSum = 0;
        }
    }
    if((currentSum < 0) && ((currentSum > maxSum) || (maxSum == 0)))
        maxSum = currentSum;
    return maxSum;
}
//------------------------------------------------------------------------------------
// Нахождение минимального элемента исходного массива
//------------------------------------------------------------------------------------
int GetMinElement(const int pvector[], const int pcount)
{
    int minElement = pvector[0];
    int i;
    for(i = 1; i < pcount; i++)
        if(pvector[i] < minElement)
            minElement = pvector[i];
    return minElement;
}
//------------------------------------------------------------------------------------
// Получение индекса первого минимального элемента
//------------------------------------------------------------------------------------
int GetIndexFirstMinElement(const int pvector[], const int pcount, const int pminElem)
{
    int i;
    int index;
    for(i = 0; i < pcount; i++)
        if(pvector[i] == pminElem)
        {
            index = i;
            break;
        }
    return index;
}
//------------------------------------------------------------------------------------
// Получение индекса последнего минимального элемента
//------------------------------------------------------------------------------------
int GetIndexLastMinElement(const int pvector[], const int pcount, const int pminElem)
{
    int i;
    int index;
    for(i = (pcount - 1); i >= 0; i--)
        if(pvector[i] == pminElem)
        {
            index = i;
            break;
        }
    return index;
}
//------------------------------------------------------------------------------------
// Формирование нового массива из элементов между первым и последним минимальным
//------------------------------------------------------------------------------------
void FormVectorBetweenMin(const int pvector[], const int pfirstIndex,
                                    const int plastIndex, int pformVector[])
{
    int i;
    int insertPosition = -1;
    for(i = (pfirstIndex + 1); i < plastIndex; i++)
        pformVector[++insertPosition] = pvector[i];
}
//------------------------------------------------------------------------------------
// главная функция программы (точка входа)
//------------------------------------------------------------------------------------
int main(void)
{
    int vector[nmax];               // исходный одномерный массив
    int formVector[nmax];           // сформированный в результате обработки массив
    int count;                      // количество активных элементов исходного массива
    int sumMinus;                   // максимальная сумма подряд идущих отриц.элементов
    int minElem;                    // значение минимального элемента в исходном массиве
    int indexFirst, indexLast;      // индексы соот-но первого и последнего минимального

    setlocale(LC_ALL, "rus");       // настройка руссификации диалогов в программе

    count = InputCountElements();
    FillVectorByKeyboard(vector, count);
    PrintVector(vector, count, "\nЭлементы исходного массива: ");
    printf("\nСумма положительных нечетных элементов массива: %d", GetSumPlusOddElements(vector, count));
    sumMinus = GetMaxSumMinusElements(vector, count);
    if(sumMinus == 0)
        printf("\nИсходный массив не содержит ни одного отрицательного элемента!");
    else
        printf("\nМаксимальная сумма подряд идущих отрицательных элементов: %d", sumMinus);
    minElem = GetMinElement(vector, count);
    printf("\nМинимальный элемент исходного массива имеет значение: %d", minElem);
    indexFirst = GetIndexFirstMinElement(vector, count, minElem);
    indexLast = GetIndexLastMinElement(vector, count, minElem);
    if(indexFirst == indexLast)
        printf("\nСформировать новый массив невозможно, т к исходный массив содержит единственный минимальный!");
    else
    {
        FormVectorBetweenMin(vector, indexFirst, indexLast, formVector);
        PrintVector(formVector, (indexLast - indexFirst - 1), "\nЭлементы сформированного массива: ");
    }

    printf("\n\nДля завершения работы программы нажмите ENTER...");
    getch();        // задержка программы, чтобы можно было просмотреть результат
    return 0;       // завершение работы программы и передача управления в ОС
}
//------------------------------------------------------------------------------------

Результаты работы программы:

Лабораторная работа №5 (программирование алгоритмов с вложенными циклами)

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

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

Создаваемая функция должна иметь возвращаемое значение и список параметров.

enlightened ВАЖНО!

  • Стоимость программы из любого варианта составляет $200$ рублей.

  • Стоимость алгоритма (в виде отчета в формате *.doc из любого варианта составляет $200$ рублей (заказывается опционально на ваше усмотрение, чтобы детально разобраться с решением лабораторной работы, например, не прибегая к консультации репетитора).

Варианты заданий:

Вариант Задание
1. В числовую переменную последовательно вводятся целые числа, не равные нулю. Количество вводимых чисел заранее неизвестно. Требуется найти сумму тех введенных чисел, в которых встречаются $n$ заданных цифр. Число цифр $n$ и сама цифра вводятся с клавиатуры.
2. Среди всех $n$-значных чисел ($n$ задается с клавиатуры) найти числа, запись которых в шестнадцатеричной системе счисления представляет собой палиндром, и подсчитать количество таких чисел (палиндром - число, которое читается одинаково слева направо и справа налево).
3. Среди простых чисел, не превосходящих заданного натурального числа $N$, найти такое, запись которого в двоичной системе счисления содержит максимальное число единиц. Если таких чисел несколько, найти минимальное число.
4. Найти все такие простые числа, не превосходящие заданного натурального числа $n$, запись которых в двоичной системе счисления представляет чередующуюся последовательность единиц и нулей, начинающуюся с единицы.
5. Найти все простые числа, не превосходящие натурального числа $n$, двоичная запись которых представляет собой палиндром; $n$ - задано и не должно превосходить $1000$ (палиндром - число, которое одинаково читается слева направо и справа налево).
6. Найти все натуральные $n$-значные числа, не превосходящие заданного числа $m$, которые делятся на каждую из своих цифр. Если таких чисел нет, выдать соответствующее сообщение. Произвести проверку вводимой информации.
7. Найти все натуральные числа $n$, не превосходящие заданного числа $m$ ($0 < m < 20$), такие, что у числа $n! + 5$ $(n! = 1 · 2 · 3 ·\ ...\ · n$) сумма цифр - простое число. Если таких чисел нет, выдать соответствующее сообщение. Выполнить проверку вводимой информации.
8. Среди всех натуральных $n$-значных чисел выбрать и вывести на экран - палиндромы, а также сумму цифр каждого числа (палиндром - числое, которое одинаково читается слева направо и справа налево).
9. Ввести с клавиатуры границы диапазон $n$ и $m$ натуральных чисел ($n < m$). Из чисел, входящих в этот диапазон, необходимо напечатать только те, цифры которых являются соседними в натуральном ряду. Подсчитать количество этих чисел и определить, сколько среди них четных и нечетных. Предусмотреть проверку правильности ввода информации.
10. В числовую переменную вводится отличное от нуля целое число. Необходимо вывести на экран цифры этого числа в столбец, начиная со старшего разряда, если это число отрицательное, в противном случае - начиная с младшего разряда. Кроме того, вывести на экран сообщение: четная или нет сумма цифр данного числа. Предусмотреть проверку правильности ввода информации.
11. В числовую переменную вводится целое число в десятичной системе счисления, имеющее заданное $n$ количество значащих разрядов. Необходимо вывести на экран представление этого числа в двоичной системе счисления. Предусмотреть проверку правильности ввода информации.
12. В числовую переменную вводится отличное от нуля вещественное десятичное число, меньшее нуля. Необходимо вывести на экран представление этого числа в двоичной системе счисления. Перевод дробной части числа ограничить пятью знаками десятичного числа. Предусмотреть проверку правильности ввода информации.
13. В числовую переменную вводится отличное от нуля вещественное десятичное число. Необходимо вывести на экран представление этого числа в восьмеричной системе счисления. Перевод дробной части числа ограничить семью знаками. Предусмотреть проверку правильности ввода информации.
14. Среди всех $n$-значных целых чисел найти числа, запись которых в восьмеричной системе счисления представляет собой палиндром, и подсчитать количество таких чисел (палиндром - число, которое одинаково читается слева направо и справа налево).
15. Вводятся последовательно цифры. Количество вводимых цифр заранее неизвестно. Из этих цифр составить число таким образом, чтобы цифры числа были расположены в порядке, обратном вводу. Предусмотреть проверку правильности ввода цифровой информации.
16. Вводятся последовательно цифры. Количество вводимых цифр заранее неизвестно. Из этих цифр составить число таким образом, чтобы цифры числа были расположены в порядке ввода. Предусмотреть проверку правильности ввода цифровой информации.
17. В числовую переменную вводится отличное от нуля вещественное десятичное число. Необходимо вывести на экран числа, значения сумм цифр целой и дробной частей которого равны между собой. Перевод дробной части ограничить количеством цифр, равным количествую цифр в его целой части. Предусмотреть проверку правильности ввода информации.
18. Ввести число, содержащее нечетное количество цифр. Из введенного числа сформировать число удалением средних цифр и вывести результат. Предусмотреть проверку правильности ввода чисел с нечетным количеством цифр.
19. Среди последовательности вводимых натуральных чисел определить количество чисел, содержащих цифру $n$. Количество вводимых цифр заранее неизвестно. Предусмотреть проверку правильности ввода информации.
20. Дана последовательность из $n$ натуральных чисел. Определить, сколько раз в числах этой последовательности встречалась каждая из цифр. Числа последовательно вводятся в одну переменную.
21. Дана последовательность натуральных чисел. Найти наибольшую цифру в каждом члене последовательности и их сумму. Числа последовательно вводятся в одну переменную.
22. Два натуральных числа вводятся с клавиатуры. Число цифр каждого заранее неизвестно. Определить, образуют ли цифры хотя бы одного числа арифметическую прогрессию. Указать вид прогрессии и номер числа.
23. Дана последовательность чисел, которые вводятся в память в одну переменную. Найти минимальную цифру каждого числа этой последовательности и их произведение.
24. Для каждого числа из последовательности вводимых $n$ чисел, переставить первую и последнюю цифры и вывести его на печать.
25. Для каждого числа из последовательности вводимых $n$ чисел прибавить заданную цифру к первой цифре этого числа.

Лабораторная работа $№5$ предполагает написание программы на языке Си. При заказе работы своего варианта вы получите качественно написанную и хорошо прокомментированную программу.

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

Образец выполнения (вариант №7)

Напомним условие задания к варианту $№7$:

Найти все натуральные числа $n$, не превосходящие заданного числа $m$ ($0 < m < 20$), такие, что у числа $n! + 5$ $(n! = 1 · 2 · 3 ·\ ...\ · n$) сумма цифр - простое число. Если таких чисел нет, выдать соответствующее сообщение. Выполнить проверку вводимой информации.

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

После прочтения условия становится очевидным, что составители задания требуют от студентов применения плохого стиля программирования. Составители требуют, чтобы было строго лишь $2$ функции:

  • главная функция программы (main);

  • вычислительная функция (со списком параметров и возвращаемым значением).

enlightened Но, если внимательно прочитать условие данной лабораторной, то, очевидно, что нужно ни $2$ функции, а как минимум следующие:

  1. Ввод с клавиатуры с проверкой на корректность входной информации.

  2. Нахождение факториала заданного натурального числа.

  3. Нахождение суммы цифр заданного натурального числа.

  4. Проверка заданного натурального числа на простоту.

  5. Главная функция проекта (main).

И это минимум! angry Непреложной истиной в программировании является утверждение: "Одна функция - одно действие". Составители же требуют от студентов смешения абсолютно несвязанных операций в рамках одной и той же функции. Разумеется, мы реализуем через $2$ функции данную задачу, но, на наш скромный взгляд и с точки зрения структурного программирования это очень и очень неправильно.

Переходим непосредственно к алгоритмизации данной задачи.

Название операции Описание операции
1. Диапазон целых чисел Допустим, пользователь введет предельное значение $m = 19$, значит, предстоит расчет $19!$. Это огромное число, равное $121 645 100 408 832 000$. Из целочисленных типов данных языка программирования Си, только тип данных long long может выдержать такой диапазон. Будем использовать именно его, а не какой-нибудь int.
2. Факториал числа Факториал натурального числа можно рассчитывать рекурсивно и итерационно. Поскольку для рекурсии требуется отдельная функция, то ничего не остается, как считать факториал в цикле по рекуррентной формуле $n! = n · (n - 1)!$.
3. Сумма цифр Для нахождения суммы цифр заданного натурального числа воспользуемся классическим подходом. Будет в цикле получать самый младщий разряд (это самая правая цифра числа) и добавлять его к результирующей сумме. После добавления к сумме, это цифру нужно отбросить, разделив натуральное число на 10.
4. Простота числа

Число называется простым, если оно делится без остатка только на $1$ и на само себя (например: $2$, $3$, $7$, $11$, $29$ и т.д.). Чтобы узнать, является ли заданное натуральное число простым, нужно перебрать всевозможные делители от $2$ до корня из этого числа.

Например, нужно узнать, является ли число $29$ простым. Для этого в цикле пробуем разделить нацело число $29$ на следующие числа: $2$, $3$, $4$, $5$. Все, поскольку число $29$ не кратно ни одному из этих чисел, делаем вывод, что оно является простым!

Многие зададутся вопросам, а почему проверка делимости заканчивается на $5$. Как было сказано выше, достаточно проверять потенциальные делители до корня из данного числа, то есть до числа $ \leq sqrt(29)$, а это значение равно $5$.

Реализация задачи на языке Си:

#include <stdio.h>      // для ввода, вывода (scanf, printf)
#include <locale.h>     // для руссификации (setlocale)
#include <conio.h>      // задержка программы (getch)
#include <math.h>       // извлечение корня (sqrt)

//--------------------------------------------------
// вычислительная функция
// 0 - текущее n не подходит
// 1 - текущее n подходит
//--------------------------------------------------
int Calculate(const int pm, const int pn, long long *pvalue, int *psumDigit)
{
    int i;  // счетчик циклов
    long long factorial_n;      // хранит факториал числа n!
    long long dvalue;           // хранит копию выражения n! + 5
   
    // находим n! итерационно в цикле
    factorial_n = 1;
    for(i = 2; i <= pn; i++)
        factorial_n *= i;
    // формируем выражение n! + 5
    *pvalue = factorial_n + 5;
    dvalue = *pvalue;

    // считаем сумму цифр в выражении n! + 5
    *psumDigit = 0;
    while(dvalue != 0)
    {
        *psumDigit += dvalue % 10;
        dvalue /= 10;
    }

    // число, равное сумме цифр выражения (n! + 5), проверяем на простоту
    for(i = 2; i <= sqrt((float)*psumDigit); i++)
        if(*psumDigit % i == 0)     // если число непростое, то обрываем расчеты
            return 0;
    return 1;
}
//--------------------------------------------------
// главная функция программы (точка входа)
//--------------------------------------------------
int main(void)
{
    int m;      // входное значение
    int n;      // отвечает за искомые значения n
    int i;      // счетчик цикла
    int count = 0;      // количество подходящих n
    long long value;    // хранит выражение n! + 5
    int sumDigit;   // сумма цифр выражения n! + 5

    setlocale(LC_ALL, "rus");   // настройка русскификации в диалогах

    // запрашиваем с проверкой входное значение m
    do
    {
        printf("Введите значение m из интервала (0 .. 20): ");
        scanf("%d", &m);
    }
    while((m <= 0) || (m >= 20));

    // выводим шапку таблицы результатов
    printf("\nСписок всех натуральных n, удовлетворяющих условию:\n");
    printf("\t-------------------------------------------------------\n");
    printf("\t|  n  |         n! + 5         | Сумма цифр | Простое |\n");
    printf("\t-------------------------------------------------------\n");

    for(n = 1; n <= m; n++)
    {
        // начинаем все вычисления
        // если сумма цифр выражения n! + 5 - просто, то выводим результат
        if(Calculate(m, n, &value, &sumDigit) == 1)
        {
            count++;    // увеличиваем на 1 кол-во подходящих n
            printf("\t| %3d | %22lld | %10d |  да     |\n", n, value, sumDigit);
        }
    }
    printf("\t-------------------------------------------------------\n");
    if(count == 0)
        printf("\t- нет ни одного подходящего значения n");

    printf("\n\nДля завершения работы программы нажмите клавишу ENTER...");
    getch();        // задержка программы, чтобы можно было просмотреть результат
    return 0;       // завершение работы программы и передача управления в ОС
}
//--------------------------------------------------

Результаты работы программы:

№ теста Результат
1.
2.
3.

Лабораторная работа №5 (программирование алгоритмов сортировки массивов)

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

Задается размер массива $n$ и затем с клавиатуры вводится вещественный массив заданного размера. Решить задачу с применением указателя на массив и функций:

  • ввода количества элементов и элементов массива с клавиатуры;

  • построчного вывода элементов массива на экран;

  • обработки массива в соответствии с заданием.

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

enlightened ВАЖНО!

  • Стоимость программы из любого варианта составляет $200$ рублей.

  • Стоимость алгоритма (в виде отчета в формате *.doc из любого варианта составляет $200$ рублей (заказывается опционально на ваше усмотрение, чтобы детально разобраться с решением лабораторной работы, например, не прибегая к консультации репетитора).

Варианты заданий:

Вариант Задание
1. Упорядочить массив таким образом, чтобы его элементы возрастали по четным номерам и убывали по нечетным.
2. Упорядочить массив таким образом, чтобы его элементы возрастали до середины и затем до конца убывали.
3. Переставить элементы массива таким образом, чтобы сначала были расположены отрицательные элементы по возрастанию, затем нули, а после - остальные элементы.
4. Удалить все отрицательные элементы массива и расположить оставшиеся по убыванию.
5. Упорядочить элементы массива по возрастанию, удалив все повторяющиеся элементы.
6. Осуществить циклический сдвиг элементов массива на заданное число $k$, которое может быть положительным и отрицательным. Если $k > 0$, то последние $k$ элементов массива перемещаются на первые $k$ мест.
7. Удалить из массива наиболее повторяющееся число и отсортировать остальные элементы по возрастанию.
8. В одномерном массиве найти минимальный элемент среди элементов с нечетными номерами и максимальный элемент среди элементов с четными номерами. Отсортировать по неубыванию элементы массива, расположенные между этими элементами, включая оба числа.
9. Упорядочить массив таким образом: первым поставить минимальный элемент, вторым - максимальный, затем минимальный из оставшихся элементов и максимальный из оставшихся и т.д.
10. Вводятся два массива. Получить результирующий отсортированный массив, состоящий из неповторяющихся элементов двух массивов.
11. Удалить из массива повторяющиеся отрицательные элементы и упорядочить оставшиеся по невозрастанию.
12. Отсортировать по убыванию элементы массива, находящиеся между первым минимальным и последним максимальными элементами.
13. Отсортировать по возрастанию элементы массива, находящиеся между первым и последним нулевыми элементами.
14. Отсортировать по возрастанию элементы массива, находящиеся до минимального элемента.
15. Отсортировать по убыванию элементы массива, находящиеся после максимального элемента.
16. Отсортировать элементы массива, находящиеся между первым нулевым и первым максимальным элементами.
17. Удалить из массива все минимальные элементы, оставшиеся отсортировать по возрастанию.
18. Удалить из массива все отрицательные элементы, находящиеся между первым и вторым нулевыми элементами, и отсортировать оставшиеся по возрастанию.
19. Преобразовать массив таким образом, чтобы в первой его половине располагались элементы, стоящие в нечетных позициях, а во второй половине - элементы, стоящие в четных позициях.
20. Преобразовать массив таким образом, чтобы сначала стояли все минимальные элементы, затем все максимальные элементы, а после них - остальные элементы.
21. Отсортировать элементы массива, находящиеся между первым минимальным и последним отрицательным максимальным элементами, включая оба числа.
22. Отсортировать элементы массива, находящиеся между первым максимальным и последним положительным максимальным элементами, включая оба числа.
23. Отсортировать элементы массива, находящиеся между первым минимальным и последним отрицательным максимальным элементами, включая оба числа.
24. Отсортировать элементы таким образом, чтобы нечетные элементы были расположены по возрастанию, а четные элементы - по убыванию.
25. Отсортировать элементы массива таким образом, чтобы положительные элементы были расположены по возрастанию, отрицательные элементы - по убыванию, а нулевые остались на своих местах.

Лабораторная работа $№6$ предполагает написание программы на языке Си. При заказе работы своего варианта вы получите качественно написанную и хорошо прокомментированную программу.

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

Образец выполнения (вариант №12)

Напомним условие задания к варианту $№12$:

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

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

enlightened Какими бы ни были значения элементов исходного массива, в таком массиве всегда найдется минимальный и максимальный элемент, поэтому, процесса сортировки неизбежать (даже в случае, когда все элементы равны друг другу).

enlightened Как найти первый минимальный элемент, а, точнее, индекс первого минимального элемента?

  1. Для решения этой подзадачи опишем отдельную функцию в программе.

  2. Запустим сканирование всех элементов массива от последнего к первому (обычно в процессе обработки массива его элементы просматривают, начиная с $1$-го, и двигаются к конечному). И будем просто нестрого сравнивать значение текущего элемента на равенство с минимальным из уже проверенных элементов. Это позволит найти последний минимальный при движении с конца в начало, но этот элемент будет являться первым минимальным, то есть иметь самый меньший индекс из всех минимальных элементов.

enlightened Как найти последний максимальный элемент, а, точнее, индекс последнего максимального элемента?

  1. Для решения этой подзадачи опишем отдельную функцию в программе.

  2. Запустим сканирование всех элементов массива от первого к последнему. Будем просто нестрого сравнивать значение текущего элемента на равенство с максимальным из уже проверенных элементов. Это позволит найти последний максимальный при движении из начала в конец, то есть этот элемент будет иметь самый больший индекс из всех максимальных элементов.

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

Вот список функций, которые нам потребуется реализовать в программе:

Название функции Назначение функции
1. GetIndexFirstMin Получение индекса первого минимального элемента массива.
2. GetIndexLastMax Получение индекса последнего максимального элемента массива.
3. FillVector Ввод количества элементов исходного массива и заполнение элементов массива вводом с клавиатуры.
4. PrintVector Построчный вывод элементов массива на экран.
5. SortVector Сортировка по убыванию элементов массива, находящихся между первым минимальным и последним максимальным элементами.
6. main Главная функция программы (точка входа).

Единственное, очень желательно было бы разбить функцию FillVector на две подфункции: ввод количества элементов и заполнение элементов массива, т к все-таки это разные действия. Но составители требуют, чтобы эти действия выполнялись в рамках одной функции. Хорошо, реализуем так, как требуют в постановке задания.

no Также составители хотят, чтобы студенты использовали для динамического выделения памяти оператор new, а для удаления динамической памяти оператор delete. Все хорошо, да вот только это операторы языка программирования С++ и к языку "чистый" Си они не имеют абсолютно никакого отношения. В языке Си для динамического перераспределения памяти используют функции malloc, calloc, realloc и free. По идее, именно эти функции и нужно бы применять...

Реализация задачи на языке Си (с фрагментами С++: new/delete):

#include <stdio.h>      // для ввода, вывода (scanf, printf)
#include <locale.h>     // для руссификации (setlocale)
#include <conio.h>      // для задержки программы (getch)

#define MAX 30          // максимально возможное количество элементов
//-------------------------------------------------------------------------------
// ввод количества элементов исходного массива и заполнение элементов массива вводом с клавиатуры.
// pcount - количество элементов массива
//-------------------------------------------------------------------------------
float* FillVector(int *pcount)
{
    int i;
    float* vector;

    do
    {
        printf("Введите количество элементов массива из отрезка [1 .. %d]: ", MAX);
        scanf("%d", pcount);
    }
    while((*pcount < 1) || (*pcount > MAX));

    // выделяем динамическую память под одномерный массив дробных чисел
    vector = new float[*pcount];

    printf("\nВам предстоит ввести с клавиатуры %d вещественных чисел.\n", *pcount);
    for(i = 0; i < *pcount; i++)
    {
        printf("\t- введите %d-й элемент массива: ", (i + 1));
        scanf("%f", &(*(vector + i)));
    }

    return vector;
}
//-------------------------------------------------------------------------------
// построчный вывод элементов массива на экран
// pvector - одномерный массив дробных чисел, элементы которого печатаются
// pcount - количество элементов массива
// pmessage - сообщение, которое выдается на экран перед печатью
//-------------------------------------------------------------------------------
void PrintVector(const float pvector[], const int pcount, const char* pmessage)
{
    int i;
    printf(pmessage);
    for(i = 0; i < pcount; i++)
        printf("%8.3f", *(pvector + i));
    printf("\n");
}
//-------------------------------------------------------------------------------
// получение индекса первого минимального элемента массива
// pvector - одномерный массив дробных чисел
// pcount - количество элементов массива
// в качестве ответа нужно вернуть индекс 1-го минимального элемента
//-------------------------------------------------------------------------------
int GetIndexFirstMin(const float pvector[], const int pcount)
{
    int i;
    int index = pcount - 1;

    for(i = (pcount - 2); i >= 0; i--)
        if(pvector[i] <= pvector[index])
            index = i;

    return index;
}
//-------------------------------------------------------------------------------
// получение индекса последнего максимального элемента массива
// pvector - одномерный массив дробных чисел
// pcount - количество элементов массива
// в качестве ответа нужно вернуть индекс последнего максимального элемента
//-------------------------------------------------------------------------------
int GetIndexLastMax(const float pvector[], const int pcount)
{
    int i;
    int index = 0;

    for(i = 1; i < pcount; i++)
        if(pvector[i] >= pvector[index])
            index = i;

    return index;
}
//-------------------------------------------------------------------------------
// сортировка по убыванию элементов массива,
// находящихся между первым минимальным и последним максимальным элементами
// pvector - сортируемый одномерный массив дробных чисел
// pstart - индекс первого элемента, который подлежит сортировке
// pend - индекс последнего элемента, который подлежит сортировке
// используется сортировка методом "пузырька" или обменом
//-------------------------------------------------------------------------------
void SortVector(float *pvector, const int pstart, const int pend)
{
    int i, j;
    int bb = 1;
    float buf;

    i = pend;
    while(bb)
    {
        bb = 0;
        for(j = pstart; j < i; j++)
            if(*(pvector + j) < *(pvector + j + 1))
            {
                buf = *(pvector + j);
                *(pvector + j) = *(pvector + j + 1);
                *(pvector + j + 1) = buf;
                bb = 1;
            }
        i--;
    }
}
//-------------------------------------------------------------------------------
// главная функция программы (точка входа).
//-------------------------------------------------------------------------------
int main(void)
{
    float *vector = NULL;   // динамический одномерный вещественный массив
    int countElement;       // активное количество элементов массива
    int indexFirstMin;      // индекс первого минимального элемента
    int indexLastMax;       // индекс последнего максимального элемента

    setlocale(LC_ALL, "rus");   // руссификация диалогов в программе

    vector = FillVector(&countElement);
    PrintVector(vector, countElement, "\nИсходный массив имеет вид: ");
    indexFirstMin = GetIndexFirstMin(vector, countElement);
    indexLastMax = GetIndexLastMax(vector, countElement);

    printf("\nНомер первого минимального элемента: %d\n", indexFirstMin + 1);
    printf("Номер последнего максимального элемента: %d\n", indexLastMax + 1);

    SortVector(vector, indexFirstMin + 1, indexLastMax - 1);
    PrintVector(vector, countElement, "\nОтсортированный массив имеет вид: ");
    delete []vector;    // удаляем память из-под массива

    printf("\n\nДля завершения работы программы нажмите клавишу ENTER...");
    getch();    // задержка программы, чтобы можно было просмотреть результаты
    return 0;   // завершение работы программы и передача управления в ОС
}
//-------------------------------------------------------------------------------

Результаты работы программы:

№ теста Смысл Результат
1. Все элементы равны друг другу (отсортированный массив равен исходному)
2. Первый минимальный и последний максимальный соседние элементы (отсортированный массив равен исходному)
3. Между первым минимальным и последним максимальным элементом стоят $3$ элемента, но они изначально идут по убыванию (отсортированный массив равен исходному)
4. Между первым минимальным и последним максимальным стоят $4$ элемента (происходит сортировка "внутренних" элементов массива)

Лабораторная работа №7 (программирование алгоритмов с использованием двумерных массивов)

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

Для решения задачи следует применить указатель на указатель на массив и функции: ввода количества строк $n$ и столбцов $m$ и элементов двумерного массива, вывода элементов массива на экран, обработки массива в соответствии с заданием.

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

enlightened ВАЖНО!

  • Стоимость программы из любого варианта составляет $250$ рублей.

  • Стоимость алгоритма (в виде отчета в формате *.doc из любого варианта составляет $250$ рублей (заказывается опционально на ваше усмотрение, чтобы детально разобраться с решением лабораторной работы, например, не прибегая к консультации репетитора).

Варианты заданий:

Вариант Задание
1. Дана квадратная вещественная матрица $A$ размером $n • n$. Вычислить $k$-ую степень этой матрицы.
2. Дана вещественная матрица размером $n • m$. Переставляя ее строки и столбцы, добиться того, чтобы наименьший элемент оказался в верхнем левом углу.
3. Дана вещественная матрица размером $n • m$. Упорядочить ее строки по возрастанию наименьших элементов в строках матрицы.
4. Задан массив размером $n • n$, состоящий из нулей и единиц. Повернуть элементы массива на 90° против хода часовой стрелки.
5. Элемент матрицы называется седловой точкой, если он является наименьшим в своей строке и наибольшим в своем столбце (или наоборот, наибольшим в своей строке и наименьшим в своем столбце). Для заданной целочисленной матрицы размером $n • m$ определить все седловые точки.
6. Дана вещественная матрица размером $n • n$, все элементы которой различны. Найти скалярное произведение строки, в которой находится наименьший элемент матрицы, и столбца с наибольшим элементом.
7. Дана вещественная матрица размером $n • m$, Определить строки, содержащие хотя бы один нулевой элемент; столбец, в котором находится самая длинная серия одинаковых элементов.
8. Определить, является ли произведение двух вещественных матриц размером $n • n$ магическим квадратом. Для магического квадрата сумма элементов во всех строках и столбцах одинакова.
9. Даны две вещественные матрицы $A$ и $B$ размером $n • n$. Показать, что произведения матриц $A·B \neq B·A$.
10. Даны вещественная матрица $A$ и единичная матрица $E$ одинаковых размеров $n • n$. Показать, что произведения матрица $A·E \neq E·A$.
11. Дана вещественная матрица размером $n • m$. Найти сумму наименьших элементов ее нечетных строк и наибольших элементов ее четных строк.
12. Дана вещественная матрица $A$ размером $n • n$. Удалить из матрицы строку и столбец, где находится минимальный элемент, и затем определить обратную матрицу.
13. Дана вещественная матрица $A$ размером $n • n$. Составить матрицу $B$, в которой находятся все элементы матрицы $A$ между минимальным и максимальным элементами.
14.

Дана действительная квадратная матрица порядка $2 • n$. Получить новую матрицу, переставляя ее блоки размером $n • n$:

15.

Дана действительная квадратная матрица порядка $2 • n$. Получить новую матрицу, переставляя ее блоки размером $n • n$:

16. Дана вещественная матрица размером $n • m$. Определить максимальные элементы матрицы, лежащие выше главной диагонали, и все элементы, находящиеся в "окрестности" этих элементов.
17. Дана вещественная матрица $A$ размером $n • n$. Найти максимальную сумму элементов из всех диагоналей, параллельных главной, начиная с двухэлементной диагонали.
18. Дана вещественная матрица $A$ размером $n • n$. Найти минимальную сумму элементов из всех диагоналей, параллельных побочной, начиная с одноэлементной диагонали.
19. Дана вещественная матрица размером $n • m$. Определить минимальные элементы матрицы, лежащие ниже побочной диагонали, и все элементы, находящиеся в "окрестности" этих элементов.
20. Элемент матрицы называется седловой точкой, если он является наименьшим в своей строке и наибольшим в своем столбце (или наоборот, наибольшим в своей строке и наименьшим в своем столбце). Для заданной целой матрицы размером $n • m$ удалить все строки и столбцы, где находятся седловые точки.
21. Дана вещественная матрица размером $n • m$. Удалить из матрицы все строки и столбцы, где находятся минимальные элементы.
22. Дана вещественная матрица размером $n • m$. Удалить из матрицы все строки и столбцы с нулевыми элементами, которые лежат выше главной и побочной диагоналей матрицы.
23. Дана вещественная матрица размером $n • m$. Элемент матрицы назовем локальным минимумом, если он меньше всех окружающих его элементов. Заменить все локальные минимумы матрицы на значение, задаваемое с клавиатуры.
24. Дана вещественная матрица размером $n • m$. Составить новую матрицу, состоящую из строк и столбцов исходной матрицы, где находятся минимальные элементы матрицы.
25. Дана вещественная матрица размером $n • m$. Составить новую матрицу, состоящую из строк и столбцов исходной матрицы, где находятся максимальные элементы матрицы.

Лабораторная работа $№7$ предполагает написание программы на языке Си. При заказе работы своего варианта вы получите качественно написанную и хорошо прокомментированную программу.

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

Образец выполнения (вариант №18)

Напомним условие задания к варианту $№18$:

Дана вещественная матрица $A$ размером $n • n$. Найти минимальную сумму элементов из всех диагоналей, параллельных побочной, начиная с одноэлементной диагонали.

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

enlightened Сразу хочется отметить, что работать с побочной диагональю, нежели с главной, менее приятно и более сложно!

Вспомним визуальные и формульные отличия главной и побочной диагоналей. Рассмотрим $2$ матрицы размером $5 • 5$. Не забывайте, что в языке программирования "чистый" Си индексация элементов любых массивов начинается с $0$, а не с $1$.

Работа с главной диагональю Работа с побочной диагональю
7 -12 0 5 8
11 17 3 3 -9
6 5 -5 4 11
0 12 29 -3 -2
3 15 17 -9 -8
7 -12 0 5 8
11 17 3 3 -9
6 5 -5 4 11
0 12 29 -3 -2
3 15 17 -9 -8

Нужна зависимость, которая, например, получает индекс колонки элемента по индексу строки этого же элемента (иногда удобнее выражать индекс строки через индекс колонки):

индекс_колонки = функция(индекс_строки)

Такая функция есть, при этом она достаточно простая:
индекс_колонки = индекс_строки или $j = i$, где

  • $i$ - индекс строки элемента, стоящего на главной диагонали;

  • $j$ - индекс колонки этого же элемента.

Действительно, если посмотреть на элементы главной диагонали (эти элементы имеют лазурный фон), то, очевидно, что у каждого из этих элементов номер строки и номер колонки совпадают:

$A[0][0] = 7$ $A[1][1] = 17$ $...$ $A[4][4] = -8$

индекс_колонки = функция(индекс_строки)

Такая функция есть, при этом она гораздо сложнее, чем соответствующая функция для главной диагонали:
индекс_колонки = размер_матрицы - индекс_строки - 1 или $j = N - i - 1$, где

  • $N$ - размер квадратной матрицы;

  • $i$ - индекс строки элемента, стоящего на побочной диагонали;

  • $j$ - индекс колонки этого же элемента.

Действительно, если посмотреть на элементы побочной диагонали (эти элементы имеют желтый фон), то, очевидно, что для каждого из этих элементов работает вышеприведенная зависимость:

$A[0][4] = 8$ $A[1][3] = 3$ $...$ $A[4][0] = 3$

Рассмотрим квадратную матрицу размером $4 • 4$ (для удобства восприятия информации заполним матрицу натуральными числами, идущими по возрастанию):

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

Данная матрица имеет $6$ диагоналей, параллельных побочной диагонали (нумерация диагоналей условная):

$№$ диагонали $1$ $2$ $3$ $4$ $5$ $6$
Элементы диагонали $1$ $2, 5$ $3, 6, 9$ $8, 11, 14$ $12, 15$ $16$

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

Например, зададимся вопросом, как пройтись по элементам диагонали $№2$, то есть просуммировать элементы $2$ и $5$? Для этого мы должны рассмотреть лишь фрагмент заданной матрицы размером $2 • 2$; для этого фрагмента искомая диагональ $№2$ будет являться главной побочной диагональю. А работать с формулой, позволяющей обрабатывать элементы побочной диагонали, мы уже умеем. yes

Значит, выделяя фрагмент нужного размера из заданной матрицы, мы сможем обращаться к элементам нужной нам диагонали, параллельной побочной исходной матрицы. Все это можно достаточно просто закодировать через циклические структуры (идеально подойдет управляющий цикл $for(;;)$);

С пробежкой по диагоналям $№1$, $№2$ и $№3$ проблем нет вообще. А как правильно обработать диагонали под $№4$, $№5$ и $№6$? Снова пытаться выводить зависимость? Есть способ более простой! Рассмотрим следующее изображение:

Элемент $A[0][1]$ имеет значение равно $2$. Обратимся к элементу, симметричному относительного "красной точки". Это элемент $A[3][2] = 15$. Нам нужно попытаться вывести зависимость, которая получает индекс строки и индекс колонки этого симметричного элемента. А эта зависимость, оказывается, есть!

Для получения индекса строки: индекс_строки_симметричного_элемента = размер_матрицы - индекс_строки - 1.
Для получения индекса колонки: индекс_колонки_симметричного_элемента = размер_матрицы - индекс_колонки - 1.

Проверяем (не забываем, что для данного примера размер матрицы равен $4$)!

  • $3 = 4 - 0 - 1$ - верно!

  • $2 = 4 - 1 - 1$ - верно!

Проверьте "желтые" элементы самостоятельно yes.

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

enlightened Список необходимых функций, требующихся для успешного кодирования поставленной задачи:

  • Ввод размера квадратной матрицы (порядка матрицы) и заполнение данной вещественной матрицы числами вводом с клавиатуры (FillMatrix).

  • Вывод квадратной матрицы в табличном виде на экран (PrintMatrix).

  • Нахождение минимальной суммы элементов из всех диагоналей, параллельных побочной диагонали (GetMinSumSecondaryDiagonal).

no Также составители хотят, чтобы студенты использовали для динамического выделения памяти оператор new, а для удаления динамической памяти оператор delete. Все хорошо, да вот только это операторы языка программирования С++ и к языку "чистый" Си они не имеют абсолютно никакого отношения. В языке Си для динамического перераспределения памяти используют функции malloc, calloc, realloc и free. По идее, именно эти функции и нужно бы применять...

Реализация задачи на языке Си (с фрагментами С++: new/delete):

#include <stdio.h>      // для ввода, вывода (scanf, printf)
#include <locale.h>     // для руссификации (setlocale)
#include <conio.h>      // для задержки программы (getch)

#define MAX_N 10    // предельно возможное количество строк/колонок матрицы
//-----------------------------------------------
// ввод порядка матрицы и заполнение матрицы
// pn - активное кол-во строк/колонок матрицы
//-----------------------------------------------
float** FillMatrix(int* pn)
{
    float** matrix;
    int i, j;

    do
    {
        printf("Введите кол-во строк/колонок матрицы из отрезка [1 .. %d]: ", MAX_N);
        scanf("%d", pn);
    }
    while((*pn < 1) || (*pn > MAX_N));
    printf("\n");

    // выделяем память под динамическую матрицу
    matrix = new float*[*pn];
    // выделяем память под каждую строку матрицы
    for(i = 0; i < *pn; i++)
        matrix[i] = new float[*pn];

    // заполняем элементы матрицы вводом с клавиатуры
    for(i = 0; i < *pn; i++)
    {
        for(j = 0; j < *pn; j++)
        {
            printf("Введите элемент матрицы A[%d][%d]: ", (i + 1), (j + 1));
            scanf("%f", &(*(*(matrix + i) + j)));
        }
    }
    return matrix;  // вернули в качестве ответа динамическую матрицу
}
//-----------------------------------------------
// вывод матрицы в табличном виде на экран
// pmatrix - печатаемая матрица
// pn - количество строк/колонок матрицы
//-----------------------------------------------
void PrintMatrix(float** pmatrix, const int pn)
{
    int i, j;
    printf("\n\nЭлементы матрицы имеют вид:\n");
    for(i = 0; i < pn; i++)
    {
        for(j = 0; j < pn; j++)
            printf("%10.3f", *(*(pmatrix + i) + j));
        printf("\n\n");
    }
}
//-----------------------------------------------
// нахождение минимальной суммы элементов из всех
// диагоналей, параллельных побочной
// pmatrix - матрица с данными
// pn - количество строк/колонок матрицы
//-----------------------------------------------
float GetMinSumSecondaryDiagonal(float** pmatrix, const int pn)
{
    int size;
    int indexRow;       // индекс строки суммируемого элемента
    int indexColumn;    // индекс колонки суммируемого элемента
    float minSum =  **pmatrix;      // обращение к элементу матрицы с индексами [0][0]
    float currentSum;   // сумма элементов текущей диагонали, параллельной побочной

    // анализируются диагонали, находящиеся слева (и выше) от побочной
    for(size = 1; size < (pn - 1); size++)
    {
        currentSum = 0;
        for(indexRow = 0; indexRow <= size; indexRow++)
        {
            indexColumn = size - indexRow;
            currentSum += *(*(pmatrix + indexRow) + indexColumn);
        }

        if(currentSum < minSum)
            minSum = currentSum;
    }

    // анализируются диагонали, находящиеся справа (и ниже) от побочной
    for(size = 0; size < (pn - 1); size++)
    {
        currentSum = 0;
        for(indexRow = 0; indexRow <= size; indexRow++)
        {
            indexColumn = pn - (size - indexRow) - 1;
            currentSum += *(*(pmatrix + (pn - indexRow - 1)) + indexColumn);
        }

        if(currentSum < minSum)
            minSum = currentSum;
    }

    // в качестве ответа возвращается минимальная сумма элементов
    return minSum;
}
//-----------------------------------------------
// главная функция программы (точка входа)
//-----------------------------------------------
int main(void)
{
    float** A;  // входная динамическая матрица
    int i;      // счетчик цикла
    int n;      // кол-во строк/колонок матрица А

    setlocale(LC_ALL, "rus");   // настройка руссификации диалогов

    A = FillMatrix(&n);     // вводим габариты матрицы и заполняем дробными числами вводом с клавиатуры
    PrintMatrix(A, n);      // выводим заданную матрицу на экран в табличном формате

    // запускаем поиск минимальной суммы элементов и сразу выводим результат поиска на экран
    printf("\nМинимальная сумма элементов из всех диагоналей, параллельных побочной: %0.3f", GetMinSumSecondaryDiagonal(A, n));

    // удаляем память из-под динамической матрицы (в 2 этапа)
    for(i = 0; i < n; i++)
        delete []A[i];
    delete []A;

    printf("\n\nДля завершения работы программы нажмите клавишу ENTER...");
    getch();    // задержка работы программы, чтобы можно было просмотреть результат
    return 0;   // завершение работы программы и передача управления в ОС
}
//-----------------------------------------------

Результаты работы программы:

№ теста Результат
1.
2.
3.

Лабораторная работа №8 (программирование алгоритмов с использованием строк)

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

Вводится предложение в виде строки. Слова в предложении разделяются между собой пробелом или запятой. Для решения задачи следует применять функции из библиотеки string.h.

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

enlightened ВАЖНО!

  • Стоимость программы из любого варианта составляет $150$ рублей.

  • Стоимость алгоритма (в виде отчета в формате *.doc из любого варианта составляет $150$ рублей (заказывается опционально на ваше усмотрение, чтобы детально разобраться с решением лабораторной работы, например, не прибегая к консультации репетитора).

Варианты заданий:

Вариант Задание
1. Определить самое длинное слово-палиндром в строке. Палиндром - слово, которое читается одинаково слева направо и справа налево. Если палиндромов максимальной длины несколько, то напечатать эти слова по алфавиту.
2. Напечатать самое длинное и самое короткое слово в строке и все слова, находящиеся между ними, по алфавиту.
3. Напечатать по алфавиту все слова, которые не содержат гласных букв.
4. Напечатать по алфавиту все слова, которые содержат по одной цифре.
5. Напечатать все слова, которые частично или полностью совпадают с заданным словом.
6. Преобразовать строку таким образом, чтобы сначала в ней были напечатаны только буквы, а потом только цифры, не меняя порядка следования символов в строке.
7. Преобразовать строку так, чтобы все буквы в ней были отсортированы по возрастанию.
8. Преобразовать строку так, чтобы все цифры в ней были отсортированы по убыванию.
9. Преобразовать строку так, чтобы в ней остались только слова-идентификаторы из заданного списка, а слова, состоящие только из цифр, удалить.
10. Напечатать все слова-палиндромы по алфавиту.
11. Преобразовать строку таким образом, чтобы в ее начале были записаны слова, содержащие только цифры, потом слова, содержащие только буквы, а затем слова, которые содержат и буквы, и цифры.
12. Преобразовать строку таким образом, чтобы все слова в ней были напечатаны перевернутыми относительно центра.
13. Преобразовать строку таким образом, чтобы буквы каждого слова в ней были отсортированы по возрастанию.
14. Преобразовать строку таким образом, чтобы цифры каждого слова в ней были отсортированы по убыванию.
15. Преобразовать строку таким образом, чтобы в ней остались только слова, содержащие буквы и цифры в алфавитном порядке, остальные слова удалить.
16. Определить, сколько раз встречается каждое слово в строке. Выдать этот список в алфавитном порядке.
17. Определить, какие слова встречаются в строке по одному разу, и напечатать их по алфавиту.
18. Все слова строки, которые начинаются с буквы, отсортировать в алфавитном порядке.
19. Все слова, которые начинаются с цифры, отсортировать по убыванию. Напечатать сумму цифр слов строки.
20. Удалить из строки все слова из заданного списка, которые не являются служебными словами языка Си. Напечатать оставшиеся слова по убыванию.
21. Выделить из строки слова из заданного списка, являющиеся служебными словами языка Си, и отсортировать их по алфавиту.
22. Удалить из строки все слова-палиндромы и напечатать оставшиеся слова по убыванию длин.
23. Выделить из строки все слова, состоящие из чисел, и напечатать оставшиеся по возрастанию длин.
24. Выделить из строки все неповторяющиеся слова, состоящие из чисел, и напечатать оставшиеся по убыванию длин.
25. Выделить из строки все неповторяющиеся слова-палиндромы и напечатать их в алфавитном порядке.

Лабораторная работа $№8$ предполагает написание программы на языке Си. При заказе работы своего варианта вы получите качественно написанную и хорошо прокомментированную программу.

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

Образец выполнения (вариант №1)

Напомним условие задания к варианту $№1$:

Определить самое длинное слово-палиндром в строке. Палиндром - слово, которое читается одинаково слева направо и справа налево. Если палиндромов максимальной длины несколько, то напечатать эти слова по алфавиту.

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

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

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

enlightened Как проверить слово на палиндромность?

Рассмотрим слово, например, "наворован". Рассмотрим алгоритм проверки на палиндромность на данном слове.

С точки зрения языка программирования Си, слово "наворован" имеет такую структуру:

'н' 'а' 'в' 'о' 'р' 'о' 'в' 'а' 'н' '\0' символ
0 1 2 3 4 5 6 7 8 9 индекс

Напомним, что палиндром - это такое слово, которое читается одинаково слева направо и справа налево. Это означает, что в таком слове $1$-я буква должна быть равна последней, $2$-я буква - предпоследней, $3$-я буква - предпредпоследней и т.д. Следовательно, когда идет проверка слова на палиндромность, нужно сравнить пары символов, которые симметричны относительно экватора слова.

Экватор слова - это центральный символ, если количество букв в слове нечетное (например, в слове "теремок" экватором выступает буква 'e'). Если в слове четное количество букв, то экватор вырождается в точку, т к абсолютно каждой букве есть симметричная пара.

Слово "наворован" образует следующие пары проверямых символов:

'н' 'а' 'в' 'о' 'р' 'о' 'в' 'а' 'н' '\0' символ
0 1 2 3 4 5 6 7 8 9 индекс

enlightened Буква 'р', стоящая на позиции с индексом $4$, является экватором, поэтому в расчетах участия не принимает.

Осталось вывести формулу, которая связывает пару симметричных символов. Во-первых, в цикле со счетчиком (for(;;)) начинаем пробежку по слову, начиная с самой первой буквы. Во-вторых, потребуется знать длину анализируемого слова. В этом поможет функция strlen из заголовочного файла string.h.

Формулы для образования пары симметричных символов относительно экватора:

  • буква$[i]$ - получение левой буквы пары.

  • буква$[длина\_слова - i - 1]$ - получение правой буквы пары.

Длина слова "наворован" составляет $9$. "Желтая" пара букв имеет индексы $\{0; 8\}$. $8$-ка была получена по выше озвученной зависимости: $8 = 9 - 0 - 1$.

"Серая" пара букв имеет индексы: $\{1, 9 - 1 - 1\} = \{1, 7\}$. И так далее...Итак, с проверкой слова на палиндромность разобрались.

enlightened В условии задачи есть такая фраза: "Если палиндромов максимальной длины несколько, то напечатать эти слова по алфавиту.". Это означает, что слова-палиндромы максимальной длины нужно куда-то запоминать, чтобы потом была возможность их отсортировать.

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

Рассмотрим следующую входную строку: "На рынке казак купил радар и подарил его узизу". Очевидно, что в этой строке встречаются слова-палиндромы, вот их перечень:

  • казак

  • радар

  • и

  • узизу

Три слова из этих слов-палиндромов одновременно имеют максимальную длину, равную $5$-ти. Четвертое слово-палиндром "и" обладает не максимальной длиной, поэтому в дальнейших расчетах участия не принимает.

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

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

enlightened Очень важно помнить о том, что в языке Си две строковые переменные ни в коем случае нельзя сравнивать на равенство значений, используя оператор $==$. Так как в этом случае будут сравниваться адреса первых элементов этих строк, а не хранимое ими значение. Си предоставляет специальную функцию сравнения двух строк по значению - это функция strcmp, которая находится в заголовочном файле string.h.

enlightened И еще важный момент! Для обмена значений двух строковых переменных нужно использовать вспомогательный строковый буфер и производить копирование строк через функцию strcpy.

Вот список функций, которые нам потребуется реализовать в программе:

Название функции Назначение функции
1. main Главная функция программы (точка входа). В рамках этой функции будет реализован ввод входной строки, разбивка входной строки на отдельные слова и формирование массива слов-палиндромов максимальной длины.
2. IsPalindrom Эта функция принимает на вход текущее слово и проверяет, является ли оно палиндромом.
3. SortBubblePalindroms Эта функция принимает на вход массив, хранящий слова-палиндромы максимальной длины и их количество. Происходит упорядочивание слов-палиндромов по алфавиту методом пузырьковой сортировки.
4. PrintPalindroms Эта функция принимает на вход отсортированный по алфавиту массив слов-палиндромов и их количество. Происходит печать результатов работы программы.

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

Реализация задачи на языке Си:

#include <stdio.h>      // для ввода, вывода (gets, printf)
#include <conio.h>      // для задержки (getch)
#include <string.h>     // для обработки строк (strcpy, strcmp, strlen, strtok)
#include <Windows.h>    // для руссификации (consoleCP, outputConsoleCP)

#define MAX_LENGHT_STRING 200       // максимальная длина любой строки программы
#define MAX_COUNT_PALINDROM 50      // максимальное кол-во палиндромов максимальной длины
//---------------------------------------------------------------------------------------
// проверка текущего слова на палиндромность
// 0: текущее слово - НЕ палиндром
// 1: текущее слово - палиндром
//---------------------------------------------------------------------------------------
int IsPalindrom(const char* pcurrentWord)
{
    int i;
    int lengthWord = strlen(pcurrentWord);
    int result = 1; // изначально считаем, что входное слово - палиндром

    // проверяем 1-ю букву с последней, 2-ю с предпоследней и т.д.
    for(i = 0; i < lengthWord / 2; i++)
        if(pcurrentWord[i] != pcurrentWord[lengthWord - i - 1])
        {
            // симметричные буквы не совпали, значит, текущее слово - НЕ палиндром!
            result = 0;
            break;
        }
    return result;
}
//---------------------------------------------------------------------------------------
// сортировка самых длинных слов-палиндромов по алфавиту (пузырьковая сортировка)
//---------------------------------------------------------------------------------------
void SortBubblePalindroms(char ppalindroms[][MAX_LENGHT_STRING], const int pcount)
{
    int i, j;
    char bufWord[MAX_LENGHT_STRING];
    for(i = 1; i < pcount; i++)
        for(j = 0; j < (pcount - i); j++)
            if(strcmp(ppalindroms[j], ppalindroms[j + 1]) > 0)
            {
                // в языке СИ присваивать строки напрямую "нельзя", только через копирование
                strcpy(bufWord, ppalindroms[j]);
                strcpy(ppalindroms[j], ppalindroms[j + 1]);
                strcpy(ppalindroms[j + 1], bufWord);
            }
}
//---------------------------------------------------------------------------------------
// печать на экран самых длинных слов-палиндромов
//---------------------------------------------------------------------------------------
void PrintPalindroms(const char ppalindroms[][MAX_LENGHT_STRING], const int pcount)
{
    int indexPalindrom;     // индекс печатаемого палиндрома
    if(pcount == 0)         // если входная строка не содержит ни одного палиндрома
        printf("\nВходная строка не содержит ни одного палиндрома! Какая-либо обработка невозможна!");
    else
        if(pcount == 1)     // если входная строка содержит ровно 1 палиндром
            printf("\nВходная строка содержит единственное слово-палиндром максимальной длины: \'%s\'", ppalindroms[pcount - 1]);
        else                // входная строка содержит больше одного палиндрома
        {
            printf("\nВходная строка содержит несколько слов-палиндромов максимальной длины (%d штук):\n", pcount);
            // выводим все самые длинные палиндромы списком (палиндромы предварительно уже отсортированы по алфавиту)
            for(indexPalindrom = 0; indexPalindrom < pcount; indexPalindrom++)
                printf("\t - %s\n", ppalindroms[indexPalindrom]);
        }
    printf("\n");
}
//---------------------------------------------------------------------------------------
// главная функция программы (точка входа)
//---------------------------------------------------------------------------------------
int main(void)
{
    char inputString[MAX_LENGHT_STRING];    // хранит входную строку
    char* currentWord;          // текущее слово входной строки
    char* delimeters = ", ";    // разделители слов входной строки
    int maxLenPalindrom = 0;    // размер наидлиннейшего палиндрома
    int countPalindroms = 0;    // кол-во самых длинных палиндромов
    // хранит все самые длинные палиндромы
    char palindroms[MAX_COUNT_PALINDROM][MAX_LENGHT_STRING];

    // настройка поддержки русского языка
    SetConsoleCP(1251);
    SetConsoleOutputCP(1251);

    // ввод с клавиатуры входной непустой строки
    printf("Введите непустую строку для обработки: ");
    gets(inputString);

    // начинаем вычленять слова из входной строки
    currentWord = strtok(inputString, delimeters);
    while(currentWord != NULL)
    {
        // если текущее слово является палиндромом, то
        if(IsPalindrom(currentWord) == 1)
        {
            // если текущий палиндром самый длинный из уже проверенных, то
            if(strlen(currentWord) > maxLenPalindrom)
            {
                // запоминаем новый самый длинный палиндром (он пока что единственный)
                countPalindroms = 1;
                strcpy(palindroms[countPalindroms - 1], currentWord);
                maxLenPalindrom = strlen(currentWord);
            }
            else    // если длина текущего палиндрома равна самому длинному палиндрому из уже найденных
                if(strlen(currentWord) == maxLenPalindrom)
                {
                    // увеличиваем счетчик таких самых длинных палиндромов и запоминаем его в массиве
                    countPalindroms++;
                    strcpy(palindroms[countPalindroms - 1], currentWord);
                }
        }
        currentWord = strtok(NULL, delimeters);     // пытаемся вычленить очередное слово из входной строки
    }

    // сортируем палиндромы максимальной длины по алфавиту (используем пузырьковую оптимальную сортировку)
    SortBubblePalindroms(palindroms, countPalindroms);
    // выводим палиндромы максимальной длины на экран пользователя
    PrintPalindroms(palindroms, countPalindroms);

    printf("\nДля завершения работы программы нажмите клавишу ENTER...");
    getch();    // задержка работы программы, чтобы можно было просмотреть результаты
    return 0;   // завершение работы программы и передача управления в ОС
}
//---------------------------------------------------------------------------------------

Результаты работы программы:

N Смысл Результат
1. Ввод входной строки, не содержащей ни одного слова-палиндрома.
2. Ввод входной строки, содержащей ровно одно слово-палиндром максимальной длины.
3. Ввод входной строки, содержащей несколько слов-палиндромов максимальной длины.

Лабораторная работа №9 (программирование алгоритмов с использованием массивов структур)

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

Для решения задачи следует применить указатель на массив структур и функции:

  • ввод элементов массив структур;

  • сортировка массива по первому полю элемента массива;

  • вывод элементов массива в табличном виде на экран;

  • решение задачи для каждого варианта.

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

  • ввод заранее выбранного количества структур;

  • ввод до появления структуры с заданным количеством признаков;

  • диалог с пользователем о необходимости продолжать ввод.

enlightened ВАЖНО!

  • Стоимость программы из любого варианта составляет $350$ рублей.

  • Стоимость алгоритма (в виде отчета в формате *.doc из любого варианта составляет $350$ рублей (заказывается опционально на ваше усмотрение, чтобы детально разобраться с решением лабораторной работы, например, не прибегая к консультации репетитора).

Варианты заданий:

Вариант Задание
1. Задан список абитуриентов университета: фамилия, будущая специальность, три оценки на экзаменах, средний балл аттестата. Удалить абитуриентов с заданной фамилией и добавить абитуриента после абитуриента с указанным номером.
2. Задан перечень книг в библиотеке: автор, название, издательство, год издания, тираж. Добавить в начало массива две книги, удалить все книги заданного автора.
3. Задан список сотрудников фирмы: фамилия и инициалы, должность, год рождения, заработная плата. Удалить сотрудников с заданной должностью, добавить элемент после элемента с указанной фамилией.
4. Задан список спортсменов: фамилия, вид спорта, разряд, количество набранных очков. Удалить из списка всех спортсменов с заданным видом спорта и добавить двух спортсменов в начало списка.
5. Задан список научно-исследовательских лабораторий: наименование, номер лаборатории, количество научных сотрудников, количество компьютеров, количество тем исследования, сумма выполненного объема научных исследований. Удалить все лаборатории с минимальным количеством тем и добавить новую лабораторию перед лабораторией заданного наименования.
6. Задан список автобусов: тип автобуса, завод-производитель, число мест, мощность двигателя, номер маршрута, название маршрута. Удалить из списка все автобусы заданного типа и добавить новый автобус перед вторым заданным номером маршрута.
7. Задан список автозаводов: наименование завода, номер завода, марка выпускаемого автомобиля, количество автомобилей, прибыль. Удалить из списка заводы, выпускающие автомобиль заданной марки, и добавить два новых автозавода в начало списка.
8. Задан список студентов: фамилия, специальность, группа, три экзаменационные оценки. Удалить из списка всех студентов-отличников и добавить одного студента после студента с заданной фамилией.
9. Задан список компьютеров: марка компьютера, фирма-производитель, тип процессора, год выпуска, стоимость. Удалить все компьютеры заданной фирмы-производителя и добавить в начало списка два компьютера новой марки.
10. Задан список поездов: номер поезда, начальный пункт, конечный пункт, время отправления, время в пути, число мест. Удалить из списка все поезда, отправляющиеся из заданного начального пункта. Добавить новый поезд перед поездом с заданным номером.
11. Задан список предприятий: наименование, руководитель, адрес, количество работников, годовая прибыль. Удалить из списка все предприятия заданного наименования и добавить предприятие перед предприятием с заданной фамилией руководителя.
12. Задан список автомобилей: марка, страна, мощность двигателя, количество мест, расход топлива на $100$ км. Добавить два автомобиля одной марки в начало списка и удалить автомобили заданной страны.
13. Задан список школ: номер, фамилия директора, район города, количество классов, количество учеников. Добавить школу перед школой с заданным номером и удалить школы заданного района.
14. Задан список часов: марка, завод-производитель, страна, год выпуска, цена. Удалить из списка часы последнего года выпуска и добавить часы после часов заданной марки и заданной страны.
15. Задан список стран: название, столица, численность населения, занимаемая площадь суши, протяженность границ. Удалить из списка страны с численностью меньше заданной и добавить в начало списка две страны.
16. Задан список картин: название, художник, год написания, страна, цена. Удалить из списка все картины заданного художника и добавить две картины перед картиной с заданным названием.
17. Задан список телевизоров: марка, фирма-производитель, страна-производитель, размер экрана, цена. Добавить два новых телевизора после первого телевизора с заданной фирмой-производителем и удалить телевизор заданной марки.
18. Задан список носителей информации: название носителя, тип, фирма-производитель, объем информации, цена. Удалить последний элемент с заданным типом носителя, добавить элемент перед элементом с указанным номером.
19. Задан список владельцев автомобилей: фамилия, номер прав, номер автомобиля, телефон номер техпаспорта. Удалить из списка элемент с заданным номером, добавить два элемента перед элементом с заданным номером автомобиля.
20. Задан список компакт-дисков: название, фирма-производитель, год выпуска, объем информации, цена. Удалить последний компакт-диск с заданным названием, добавить два элемента перед компакт-диском с заданным номером.
21. Задан список товаров: название, страна, фирма-производитель, год выпуска, количество, стоимость. Удалить все товары заданной страны, добавить два товара после первого товара с указанной фирмой-производителем.
22. Задан список больных: фамилия, домашний адрес, номер медицинской карты, диагноз, номер страхового полиза. Удалить больного с заданным номером медицинской карты, добавить двух больных в начало массива.
23. Задан список домов в районе: улица, номер дома, тип дома, количество квартир, суммарная площадь. Удалить все дома заданного типа и добавить дом перед домом, для которого задан адрес.
24. Задан список мобильных телефонов: тип, фирма-производитель, страна, масса, фамилия владельца. Удалить все телефоны для заданной фамилии владельца и добавить телефон после второго мобильного телефона заданного типа.
25. Задан список товаров на радиорынке: наименование, тип, фирма-производитель, количество, цена. Удалить все товары заданного наименования и добавить товар после товара с минимальным количеством.

Лабораторная работа $№9$ предполагает написание программы на языке Си. При заказе работы своего варианта вы получите качественно написанную и хорошо прокомментированную программу.

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

Образец выполнения (вариант №13)

Напомним условие задания к варианту $№13$:

Задан список школ: номер, фамилия директора, район города, количество классов, количество учеников. Добавить школу перед школой с заданным номером и удалить школы заданного района.

Реализация задачи на языке Си:

#include <stdio.h>      // для ввода, вывода (scanf, printf)
#include <Windows.h>    // для руссификации (SetConsoleCP, SetConsoleOutputCP)
#include <conio.h>      // для задержки программы (getch)

#define MAX_LENGHT_STRING 100   // максимальная длина строковых данных
#define MAX_COUNT_SCHOOL 20     // максимальное кол-во школ для обработки

//-------------------------------------------------------------------------
// структура, описывающая школу
//-------------------------------------------------------------------------
typedef struct
{
    int number;     // номер школы
    char surnameDirector[MAX_LENGHT_STRING];    // фамилия директора
    char regionCity[MAX_LENGHT_STRING];         // район города
    int countClasses;   // количество классов
    int countPupils;    // количество учеников
} TSchool;
//-------------------------------------------------------------------------
// ввод количества школ для обработки
//-------------------------------------------------------------------------
int InputCountSchools(void)
{
    int count;
    do
    {
        printf("Введите количество школ для обработки из отрезка [1 .. %d]: ", MAX_COUNT_SCHOOL);
        scanf("%d", &count);
    }
    while((count < 1) || (count > MAX_COUNT_SCHOOL));
    return count;
}
//-------------------------------------------------------------------------
// добавление новой школы перед школой с заданным номером
//-------------------------------------------------------------------------
void AddSchool(TSchool* pschools, int* pcount)
{
    int targetNumberSchool;
    int insert;
    int i;

    printf("\nВведите № школы, перед которой планируется добавить новую школу: ");
    scanf("%d", &targetNumberSchool);

    for(insert = 0; insert < *pcount; insert++)
        if((pschools + insert)->number == targetNumberSchool)
            break;
   
    if(insert >= *pcount)
    {
        printf("Школы с введенным номером не существует! Добавление новой школы невозможно!\n");
        return;
    }
    else
    {
        for(i = (*pcount - 1); i >= insert; i--)
        {
            pschools[i + 1].number = pschools[i].number;
            strcpy(pschools[i + 1].surnameDirector, pschools[i].surnameDirector);
            strcpy(pschools[i + 1].regionCity, pschools[i].regionCity);
            pschools[i + 1].countClasses = pschools[i].countClasses;
            pschools[i + 1].countPupils = pschools[i].countPupils;
        }
        printf("\nВведите номер добавляемой школы: ");
        scanf("%d", &pschools[insert].number);
        printf("Введите фамилию директора добавляемой школы: ");
        scanf("%s", pschools[insert].surnameDirector);
        printf("Введите район города добавляемой школы: ");
        scanf("%s", pschools[insert].regionCity);
        printf("Введите количество классов добавляемой школы: ");
        scanf("%d", &pschools[insert].countClasses);
        printf("Введите количество учеников добавляемой школы: ");
        scanf("%d", &pschools[insert].countPupils);
        printf("\nИнформация о новой школе успешно добавлена!\n");
        (*pcount)++;
        getch();
    }
}
//-------------------------------------------------------------------------
// заполнение информации о школах вводом с клавиатуры
//-------------------------------------------------------------------------
void FillSchools(TSchool* pschools, const int pcount)
{
    int i;
    printf("\nВам предстоит ввести с клавиатуры информации о %d школах.\n", pcount);
    for(i = 1; i <= pcount; i++, pschools++)
    {
        printf("\n\nВвод информации по %d-й школе.\n", i);
        printf("\tВведите номер школы: ");
        scanf("%d", &pschools->number);
        printf("\tВведите фамилию директора школы: ");
        scanf("%s", pschools->surnameDirector);
        printf("\tВведите района города, где располагается школа: ");
        scanf("%s", pschools->regionCity);
        printf("\tВведите количество классов школы: ");
        scanf("%d", &pschools->countClasses);
        printf("\tВведите количество учеников, обучающихся в школе: ");
        scanf("%d", &pschools->countPupils);
    }
}
//-------------------------------------------------------------------------
// вывод информации о школах на экран в табличном виде
//-------------------------------------------------------------------------
void PrintSchools(TSchool* pschools, const int pcount)
{
    int i;
    if(pcount == 0)
    {
        printf("\nНет ни одной школы! Печать информации о школах невозможна.\n");
        return;
    }
    printf("\nИнформация о %d школах имеет вид:\n", pcount);
    printf("-----------------------------------------------------------------------------------------\n");
    printf("| № школы | Фамилия директора | Район города | Количество классов | Количество учеников |\n");
    printf("-----------------------------------------------------------------------------------------\n");
    for(i = 1; i <= pcount; i++, pschools++)
        printf("| %-7d | %17s | %12s | %-18d | %-19d |\n",
            pschools->number, pschools->surnameDirector, pschools->regionCity,
            pschools->countClasses, pschools->countPupils);
    printf("-----------------------------------------------------------------------------------------\n\n");
}
//-------------------------------------------------------------------------
// удаление всех школ заданного региона
//-------------------------------------------------------------------------
void DeleteSchoolByRegion(TSchool* pschools, int* pcount)
{
    int i, j;
    int countDeletedSchool = 0;
    char deleteRegion[MAX_LENGHT_STRING];
    printf("\nВведите район города для удаления всех школ, принадлежащих этому району: ");
    scanf("%s", deleteRegion);
    for(i = (*pcount - 1); i >= 0; i--)
    {
        if(strcmp(pschools[i].regionCity, deleteRegion) == 0)
        {
            countDeletedSchool++;
            for(j = i + 1; j < *pcount; j++)
            {
                pschools[j - 1].number = pschools[j].number;
                strcpy(pschools[j - 1].surnameDirector, pschools[j].surnameDirector);
                strcpy(pschools[j - 1].regionCity, pschools[j].regionCity);
                pschools[j - 1].countClasses = pschools[j].countClasses;
                pschools[j - 1].countPupils = pschools[j].countPupils;
            }
        }
    }
    *pcount = *pcount - countDeletedSchool;
    printf("Все школы заданного района успешно удалены!\n");
}
//-------------------------------------------------------------------------
// главная функция программы (точка входа)
//-------------------------------------------------------------------------
int main(void)
{
    TSchool* schools;       // указатель на массив школ
    int countSchool;        // активное количество школ

    // настройка руссификации
    SetConsoleCP(1251);
    SetConsoleOutputCP(1251);

    // вводим кол-во школ и выделяем под школы необходимое количество памяти
    countSchool = InputCountSchools();
    schools = new TSchool[countSchool + 1];

    // заполняем информацию о школах вводом с клавиатуры и выводим на экран
    FillSchools(schools, countSchool);
    PrintSchools(schools, countSchool);

    // добавляем новую школу перед заданной и выводим на экран результат
    AddSchool(schools, &countSchool);
    PrintSchools(schools, countSchool);

    // удаляем все школы заданного региона и выводим на экран результат
    DeleteSchoolByRegion(schools, &countSchool);
    PrintSchools(schools, countSchool);

    // очищаем память из-под массива школ
    delete[] schools;

    printf("\nДля завершения работы программы нажмите клавишу ENTER...");
    getch();    // задержка работы программы, чтобы просмотреть результат
    return 0;   // завершение работы программы и передача управления в ОС
}
//-------------------------------------------------------------------------

Результаты работы программы:

Лабораторная работа №10 (программирование алгоритмов работы с текстовыми файлами)

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

Сформировать исходный текстовый файл из строк, распечатать его содержимое, создать второй текстовый файл в соответствии с заданием, распечатать содержимое второго файла.

Слова в строках файла отделяются друг от друга пробелом. Формирование файла, распечатки файла, решение задачи оформить в виде функций с аргументами.

Задачу решить созданием файла проекта.

enlightened ВАЖНО!

  • Стоимость программы из любого варианта составляет $200$ рублей.

  • Стоимость блок-схемы из любого варианта составляет $200$ рублей.

Варианты заданий:

Вариант Задание
1. Скопировать в файл $F2$ только те строки из $F1$, в которых встречается хотя бы одно слово из первой строки $F1$.
2. Скопировать в файл $F2$ только те строки из $F1$, в которых имеется заданное слово.
3. Скопировать в файл $F2$ только те строки из $F1$, которые начинаются и заканчиваются на одну и ту же букву, и подсчитать количество символов в $F2$.
4. Скопировать из файла $F1$ в файл $F2$ те строки, в которых встречается хотя бы одно слово из последней строки $F1$.
5. Скопировать из файла $F1$ в файл $F2$ те строки, в которых имеются слова-палиндромы.
6. Скопировать из файла $F1$ в файл $F2$ строки, оставив в каждой строке только слова максимальной длины.
7. Скопировать из файла $F1$ в файл $F2$ все строки, в которых встречаются слова-идентификаторы из заданного списка.
8. Скопировать из файла $F1$ в файл $F2$ все слова строки, содержащие цифры, и подсчитать количество строк, которые начинаются на заданную букву в файле $F2$.
9. Скопировать из файла $F1$ в файл $F2$ все строки, которые содержат только одно слово, и найти самое длинное слово в файле $F2$.
10. Скопировать из файла $F1$ в файл $F2$ все строки, которые не содержат заданного слова, и найти самое короткое слово в файле $F2$.
11. Скопировать из файла $F1$ в файл $F2$ все строки, кроме той строки, которая содержит самое короткое слово, и напечатать номер этой строки.
12. Скопировать из файла $F1$ в файл $F2$ все строки, кроме той строки, в которой содержится слово-палиндром максимальной длины.
13. Скопировать из файла $F1$ в файл $F2$ все строки, упорядочив слова в каждой строке по алфавиту.
14. Скопировать из файла $F1$ в файл $F2$ все строки, содержащие симметричные слова, упорядочив слова в этих строках по алфавиту.
15. Скопировать из файла $F1$ в файл $F2$ строки, в которых не встречаются слова-идентификаторы Си из заданного списка.
16. Скопировать из файла $F1$ в файл $F2$ строки, в которых встречается по два одинаковых слова.
17. Скопировать из файла $F1$ в файл $F2$ строки, в которых нет одинаковых слов.
18. Скопировать из файла $F1$ в файл $F2$ строки максимальной длины, упорядочив в них слова по алфавиту.
19. Скопировать из файла $F1$ в файл $F2$ все строки, содержащие не менее двух одинаковых слов, и определить номер слова, в котором больше всего цифр.
20. Скопировать из файла $F1$ в файл $F2$ все строки, в которых содержатся только слова, состоящие из чисел. Дописать в конце строк сумму чисел в строке.
21. Скопировать из файла $F1$ в файл $F2$ все строки, в которых не содержатся слова, состоящие из чисел. Дописать в конце строки ее длину.
22. Скопировать из файла $F1$ в файл $F2$ все строки, в которых содержится больше заданного числа слов. Дописать в конце строки сумму цифр в строке.
23. Скопировать из файла $F1$ в файл $F2$ все строки, в которых есть слова, совпадающие с первым словом строки. Дописать в конце строки количество слов в строке.
24. Скопировать из файла $F1$ в файл $F2$ все строки, в которых нет повторяющихся слов. Дописать в конце строки номер строки в файле.
25. Скопировать из файла $F1$ в файл $F2$ все строки, в которых есть слова, повторяющиеся заданное число раз. Дописать в конце строки количество символов в слове максимальной длины.

Лабораторная работа $№10$ предполагает написание программы на языке Си. При заказе работы своего варианта вы получите качественно написанную и хорошо прокомментированную программу.

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

Образец выполнения (вариант №5)

Напомним условие задания к варианту $№5$:

Скопировать из файла $F1$ в файл $F2$ те строки, в которых имеются слова-палиндромы.

Реализация задачи на языке Си:

#include <stdio.h>      // для ввода, вывода (gets, printf)
#include <Windows.h>    // для руссификации
#include <conio.h>      // для задержки программы (getch)
#include <string.h>     // для строковых функций (strlen, strcpy, strtok)

#define MAX_LEN_NAME_FILE 100   // максимальная длина имени текстовых файлов
#define MAX_LEN_STRING 1000     // максимальная длина строки текстовых файлов

//-------------------------------------------------------------------------------
// вывод содержимого заданного текстового файла на экран
// pnameFile - имя текстового файла, содержимое которого выводится на экран
//-------------------------------------------------------------------------------
void PrintTextFile(const char pnameFile[])
{
    FILE* f;
    char currentString[MAX_LEN_STRING];

    f = fopen(pnameFile, "r");
    printf("\nСодержимое файла '\%s\' имеет вид: \n", pnameFile);
    while(!feof(f))
    {
        fgets(currentString, MAX_LEN_STRING - 1, f);
        printf("\t%s", currentString);
    }

    fclose(f);
}
//-------------------------------------------------------------------------------
// проверка существования входного файла
// pnameFile - имя текстового входного файла
// 0 - такого файла не существует
// 1 - такой файл существует
//-------------------------------------------------------------------------------
int IsExistsFile(const char pnameFile[])
{
    FILE* f = fopen(pnameFile, "r");
    if(f == NULL)
        return 0;

    fclose(f);
    return 1;
}
//-------------------------------------------------------------------------------
// проверка слова на палиндромность
// pword - слово, которое проверяется на палиндромность
// 0 - входное слово НЕ палиндром
// 1 = входное слово палиндром
//-------------------------------------------------------------------------------
int IsWordPalindrom(const char pword[])
{
    int i;
    int lenWord = strlen(pword);

    for(i = 0; i < lenWord / 2; i++)
        if(pword[i] != pword[lenWord - 1 - i])
            return 0;
    return 1;
}
//-------------------------------------------------------------------------------
// копируем те строки, в которых имеются слова-палиндромы
// pinputFile - имя входного текстового файла
// poutputFile - имя выходного текстового файла
//-------------------------------------------------------------------------------
void CopyStringWithPalindrom(const char pinputFile[], const char poutputFile[])
{
    FILE* f1;
    FILE* f2;
    char currentString[MAX_LEN_STRING];
    char dublicate[MAX_LEN_STRING];
    char* word;

    f1 = fopen(pinputFile, "r");    // входной файл открываем в режиме "на чтение"
    f2 = fopen(poutputFile, "w");   // выходной файл открываем в режиме "на запись"

    while(!feof(f1))
    {
        fgets(currentString, MAX_LEN_STRING - 1, f1);
        strcpy(dublicate, currentString);
        word = strtok(dublicate, " \n");
        while(word != NULL)
        {
            if(IsWordPalindrom(word) == 1)
            {
                fprintf(f2, "%s", currentString);
                break;
            }
            word = strtok(NULL, " \n");
        }
    }

    // после обработки файлы нужно закрыть (разорвать с файлами связь)
    fclose(f1);
    fclose(f2);
}
//-------------------------------------------------------------------------------
// главная функция программы (точка входа)
//-------------------------------------------------------------------------------
int main(void)
{
    // имена входного и выходного текстовых файлов
    char inputNameFile[MAX_LEN_NAME_FILE];
    char outputNameFile[MAX_LEN_NAME_FILE];

    // настройка руссификации
    SetConsoleCP(1251);
    SetConsoleOutputCP(1251);

    // запрашиваем с клавиатуры имя входного текстового файла
    printf("Введите имя входного текстового файла: ");
    gets(inputNameFile);

    // убеждаемся, что входной файл существует
    if(IsExistsFile(inputNameFile) == 0)
        printf("\nВозникла непредвиденная ошибка при чтении данных из файла! Возможно, такого файла не существует!\n");
    else
    {
        // выводим содержимое входного текстового файла на экран
        PrintTextFile(inputNameFile);

        // запрашиваем с клавиатуры имя выходного текстового файла
        printf("\n\nВведите имя выходного текстового файла: ");
        gets(outputNameFile);

        // копируем из входного файла только те строки, содержащие слова-палиндромы
        CopyStringWithPalindrom(inputNameFile, outputNameFile);
        // выводим содержимое результирующего файла на экран
        PrintTextFile(outputNameFile);

        // удаляем временный результирующий файл с жесткого диска
        remove(outputNameFile);
    }

    printf("\n\nДля завершения работы программы нажмите клавишу ENTER...");
    getch();    // задержка работы программы, чтобы можно было просмотреть результат
    return 0;   // завершение работы программы и передача управления в ОС
}
//-------------------------------------------------------------------------------

Результаты работы программы (обратите внимание, что слово, состоящее из одной буквы, является по умолчанию словом-палиндромом):

Лабораторная работа №11 (программирование алгоритмов работы с бинарными файлами)

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

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

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

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

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

  • ввод заранее выбранного количества структур;

  • ввод до появления структуры с заданным количеством признаков;

  • диалог с пользователем о необходимости продолжать ввод.

После создания бинарного файла следует выполнить корректировку созданного файла в соответствии с вариантом задания $9$. Задачу решить созданием файла проекта.

enlightened ВАЖНО!

  • Стоимость программы из любого варианта составляет $350$ рублей.

  • Стоимость блок-схемы из любого варианта составляет $350$ рублей.

Образец выполнения (вариант №13)

Напомним условие задания к варианту $№13$:

Задан список школ: номер, фамилия директора, район города, количество классов, количество учеников. Добавить школу перед школой с заданным номером и удалить школы заданного района.

Реализация задачи на языке Си:

#include <stdio.h>      // для ввода, вывода (scanf, printf)
#include <Windows.h>    // для руссификации (SetConsoleCP, SetConsoleOutputCP)
#include <conio.h>      // для задержки программы (getch)

#define MAX_LENGHT_STRING 100   // максимальная длина строковых данных
#define MAX_COUNT_SCHOOL 20     // максимальное кол-во школ для обработки

//-------------------------------------------------------------------------
// структура, описывающая школу
//-------------------------------------------------------------------------
typedef struct
{
    int number;     // номер школы
    char surnameDirector[MAX_LENGHT_STRING];    // фамилия директора
    char regionCity[MAX_LENGHT_STRING];         // район города
    int countClasses;   // количество классов
    int countPupils;    // количество учеников
} TSchool;
//-------------------------------------------------------------------------
// ввод количества школ для обработки
//-------------------------------------------------------------------------
int InputCountSchools(void)
{
    int count;
    do
    {
        printf("Введите количество школ для обработки из отрезка [1 .. %d]: ", MAX_COUNT_SCHOOL);
        scanf("%d", &count);
    }
    while((count < 1) || (count > MAX_COUNT_SCHOOL));
    return count;
}
//-------------------------------------------------------------------------
// создание одной новой школы
//-------------------------------------------------------------------------
TSchool CreateSchool(void)
{
    TSchool add;
    printf("\nВведите номер добавляемой школы: ");
    scanf("%d", &add.number);
    printf("Введите фамилию директора добавляемой школы: ");
    scanf("%s", add.surnameDirector);
    printf("Введите район города добавляемой школы: ");
    scanf("%s", add.regionCity);
    printf("Введите количество классов добавляемой школы: ");
    scanf("%d", &add.countClasses);
    printf("Введите количество учеников добавляемой школы: ");
    scanf("%d", &add.countPupils);
    return add;
}
//-------------------------------------------------------------------------
// добавление новой школы перед школой с заданным номером
// pnameBinaryFile - имя бинарного файла с данными о школах
// pcount - количество школ, хранящихся в бинарном файле
// pnumberSchool - номер школы, перед которой планируется добавить новую школу
//-------------------------------------------------------------------------
void AddSchool(const char pnameBinaryFile[], int* pcount, int pnumberSchool)
{
    int insert;
    int i;
    FILE* f;
    TSchool tmp;

    // открываем существующий бинарный файл в режиме чтения-записи
    f = fopen(pnameBinaryFile, "rb+");
    for(insert = 1; insert <= *pcount; insert++)
    {
        fread(&tmp, sizeof(TSchool), 1, f);
        if(tmp.number == pnumberSchool)
            break;
    }

    if(insert > *pcount)
    {
        printf("Школы с введенным номером не существует! Добавление новой школы невозможно!\n");
        fclose(f);
        return;
    }
    else
    {
        for(i = (*pcount - 1); i >= (insert - 1); i--)
        {
            fseek(f, sizeof(TSchool) * i, SEEK_SET);
            fread(&tmp, sizeof(TSchool), 1, f);
            fseek(f, sizeof(TSchool) * (i + 1), SEEK_SET);
            fwrite(&tmp, sizeof(TSchool), 1, f);
        }

        tmp = CreateSchool();
        fseek(f, sizeof(TSchool) * (insert - 1), SEEK_SET);
        fwrite(&tmp, sizeof(TSchool), 1, f);
        (*pcount)++;
        printf("Новая школа успешно добавлена перед школой №%d!\n", pnumberSchool);
    }
    fclose(f);
}
//-------------------------------------------------------------------------
// создание бинарного файла с данными о школах
// pnameBinaryFile - имя бинарного файла с данными о школах
// pcount - кол-во школ, хранящихся в бинарном файле
//-------------------------------------------------------------------------
void CreateBinaryFile(const char pnameBinaryFile[], const int pcount)
{
    int i;
    FILE* f;

    f = fopen(pnameBinaryFile, "wb");
    if(f == NULL)
    {
        printf("\nВозникла непредвиденная ошибка при работе с бинарным файлом! Программа закрывается...");
        getch();
        exit(0);
    }
    printf("\nВам предстоит ввести с клавиатуры информации о %d школах.\n", pcount);
    for(i = 1; i <= pcount; i++)
    {
        TSchool add = CreateSchool();
        fwrite(&add, sizeof(TSchool), 1, f);
    }

    printf("Информация о школах успешно записана в бинарный файл '\%s\'!\n", pnameBinaryFile);
    fclose(f);
}
//-------------------------------------------------------------------------
// вывод информации о школах из бинарного файла на экран в табличном виде
// pnameBinaryFile - имя бинарного файла с данными о школах
// pcount - кол-во школ, хранящихся в бинарном файле
//-------------------------------------------------------------------------
void PrintSchools(const char pnameBinaryFile[], const int pcount)
{
    FILE* f;
    int i;
    if(pcount == 0)
    {
        printf("\nНет ни одной школы! Печать информации о школах невозможна.\n");
        return;
    }

    f = fopen(pnameBinaryFile, "rb");
    printf("\nИнформация о %d школах имеет вид:\n", pcount);
    printf("-----------------------------------------------------------------------------------------\n");
    printf("| № школы | Фамилия директора | Район города | Количество классов | Количество учеников |\n");
    printf("-----------------------------------------------------------------------------------------\n");
    for(i = 1; i <= pcount; i++)
    {
        TSchool tmp;
        fread(&tmp, sizeof(TSchool), 1, f);
        printf("| %-7d | %17s | %12s | %-18d | %-19d |\n",
            tmp.number, tmp.surnameDirector, tmp.regionCity, tmp.countClasses, tmp.countPupils);
    }
    printf("-----------------------------------------------------------------------------------------\n\n");
   
    fclose(f);
}
//-------------------------------------------------------------------------
// удаление всех школ заданного региона
// pnameBinaryFile - имя бинарного файла с данными о школах
// pcount - кол-во школ, хранящихся в бинарном файле
// pdeletedRegion - название региона, школы которого следует удалить из файла
//-------------------------------------------------------------------------
void DeleteSchoolByRegion(const char pnameBinaryFile[], int* pcount, const char pdeletedRegion[])
{
    FILE* f;
    int i, j;
    int countDeletedSchool = 0;
    TSchool tmp;

    f = fopen(pnameBinaryFile, "rb+");
    for(i = (*pcount - 1); i >= 0; i--)
    {
        fseek(f, sizeof(TSchool) * i, SEEK_SET);
        fread(&tmp, sizeof(TSchool), 1, f);
        if(strcmp(tmp.regionCity, pdeletedRegion) == 0)
        {
            countDeletedSchool++;
            for(j = i + 1; j < *pcount; j++)
            {
                fseek(f, sizeof(TSchool) * j, SEEK_SET);
                fread(&tmp, sizeof(TSchool), 1, f);

                fseek(f, sizeof(TSchool) * (j - 1), SEEK_SET);
                fwrite(&tmp, sizeof(TSchool), 1, f);
            }
        }
    }
    *pcount = *pcount - countDeletedSchool;
    printf("Все школы заданного района успешно удалены!\n");
    fclose(f);
}
//-------------------------------------------------------------------------
// главная функция программы (точка входа)
//-------------------------------------------------------------------------
int main(void)
{
    int countSchool;        // активное количество школ
    // имя бинарного файла с данными
    char nameBinaryFile[MAX_LENGHT_STRING];
    // номер школы, перед которой планируется добавить новую школу
    int numberSchool;
    // название региона для удаления всех школ
    char deletedRegion[MAX_LENGHT_STRING];

    // настройка руссификации
    SetConsoleCP(1251);
    SetConsoleOutputCP(1251);

    // запрашиваем вводом с клавиатуры имя бинарного файла
    printf("Введите имя бинарного файла для хранения данных о школах: ");
    gets(nameBinaryFile);

    // вводим кол-во школ
    countSchool = InputCountSchools();

    // заполняем информацию о школах вводом с клавиатуры и записываем в "бинарник"
    CreateBinaryFile(nameBinaryFile, countSchool);
    PrintSchools(nameBinaryFile, countSchool);

    // добавляем новую школу перед заданной и выводим на экран результат
    printf("\nВведите № школы, перед которой планируется добавить новую школу: ");
    scanf("%d", &numberSchool);
    AddSchool(nameBinaryFile, &countSchool, numberSchool);
    PrintSchools(nameBinaryFile, countSchool);

    // удаляем все школы заданного региона и выводим на экран результат
    printf("\nВведите район города для удаления всех школ, принадлежащих этому району: ");
    scanf("%s", deletedRegion);
    DeleteSchoolByRegion(nameBinaryFile, &countSchool, deletedRegion);
    PrintSchools(nameBinaryFile, countSchool);

    // удаляем бинарный файл с жесткого диска
    remove(nameBinaryFile);

    printf("\nДля завершения работы программы нажмите клавишу ENTER...");
    getch();    // задержка работы программы, чтобы просмотреть результат
    return 0;   // завершение работы программы и передача управления в ОС
}
//-------------------------------------------------------------------------

Результаты работы программы:

О качестве программного кода

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

У каждого из нас за плечами колоссальное количество успешно реализованных студенческих проектов. И мы прекрасно понимаем, что вузовские программы, а особенно лабораторные работы, должны соответствовать требованиям, описанным в методическом пособии.

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

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

Закодируем студенческие работы на любом из следующих языков программирования: C, C++, C#, Pascal, Delphi

Зачастую разные вузы используют одни и те же методические обучающие пособия. Поэтому, если вы не студент МГТУ им.Баумана, но вам требуется выполнить такие же или похожие задания, но не на языке Си, а, например, на языке Pascal, то мы абсолютно без каких-либо проблем напишем соответствующий код с нуля.

В нашем штате есть СИ-ориентированный программист Валентин Смирнов. Владеет на профессиональном уровне $3$-мя Си-подобными языками: C, C++, C#. Поэтому сообщите нам, под какой язык программирования следует провести адаптацию нужных вам лабораторных работ.

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

Скидка 50% при заказе всех вариантов лабораторных работ

enlightened Своим потенциальным клиентам мы предлагаем сумасшедший бонус! При одновременном заказе всех вариантов какой-либо лабораторной работы предоставляется ценовая скидка в размере $50\%$ от первоначальной стоимости.

Пример. Студенты, учащиеся в одном вузе, испытывают колоссальные проблемы с лабораторной работой $№3$. Поэтому они принимают коллегиальное решение заказать сразу все варианты этой работы. В этом случае им предоставляется скидка в размере $50\%$. Значит, стоимость каждой программы уже составляет не $200$ рублей, а всего $100$ рублей.

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

Для оформления подобного заказа мы предлагаем вам, студентам, объединяться в группу.

Также хочется отметить особый случай, с которым мы периодически сталкиваемся. Иногда студенты определенной группы решают заказать все варианты всех лабораторных работ! В такой ситуации стоимость обговаривается в индивидуальном порядке, но, скидка может достигать $70\%$.

А какими способами можно оплатить заказанные работы?

Своим потенциальным клиентам мы предлагаем следующие варианты оплаты:

  • На карточку Сбербанка России (рекомендуемый способ).

  • WebMoney.

  • Яндекс.Деньги.

  • На номер мобильного телефона (нерекомендуемый способ).

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

Окажем вам полную информационную поддержку, по заказанным у нас работам

Заказав у нас работы, вы получаете полную информационную поддержку. Что включает подобная поддержка?

  1. Ответим на любые тематические вопросы, связанные с программой/блок-схемой, которую вы заказали.

  2. Поможем запустить программу на вашем ПК. Или диагностируем проблему, с которой вы столкнулись, предложив рациональные пути решения.

  3. Исправим код программы под новые требования. Как правило, стоимость этой доработки составляет $10\%$ от первоначальной стоимости купленной программы, т е доработка производится не бесплатно.


Данный материал (программы, текст, оформление) подготовлен при участии:

Александр Георгиевич Валентин Иванович

► Основатель данного сайта.
► Эксперт ОГЭ и ЕГЭ по информатике/математике.
► Профессиональный реализатор студенческих работ.
► Программист на таких языках как: Pascal, C, C#.
► Разработчик БД и СУРБД (MS SQL Server).
► Методист, технический писатель.
► В прошлом школьный учитель и вузовский преподаватель.

Профессиональный программист на языках: C, C++, C#, Java.
► Профессиональный реализатор студенческих работ.
► Алгоритмист, в том числе алгоритмах дискретной математики (графы, комбинаторика, автоматы и т.п.).
► Программист алгоритмов высшей математики.
► Технический писатель.
► В прошлом вузовский преподаватель.

 

 
 
 
 
 
Авторизация на сайте
 
 
 
Обнаружили
ошибку на сайте?
Занятия по информатике