Подготовка к ЕГЭ сына - школьника (по информатике)

 Для четырёх чисел (Рассмотрим самый сложный случай, потому что все остальное делается по аналогии. Авторы-составители ЕГЭ проверяют этим заданием умение создавать алгоритмы с условными операторами):

/////////////////////////////////////////////////////////////////////////////////////////////////// Вариант 1

program minmax_for_four_numbers;

Function MyMin(x, y:double):double;
begin
if x>y then MyMin := y
else
MyMin := x;
end;

Function MyMax(x, y:double):double;
begin
if x>y then MyMax := x
else
MyMax := y;
end;

var a,b,c,d : double;
begin
  writeln('Последовательно введите четыре числа, которые необходимо сравнить');
  readLn(a,b,c,d);
  writeLn('Min: ', MyMin(MyMin(a,b),MyMin(c,d)));
  writeLn('Max: ', MyMax (MyMax (a,b),MyMax(c,d)));
end.

/////////////////////////////////////////////////////////////////////////////////////////////////// Вариант 2

var min_num, max_num, ent_num : double;
begin
  writeln('Последовательно введите четыре числа, которые необходимо сравнить');

  readLn(ent_num);
  min_num := ent_num;
  max_num := ent_num;

  readLn(ent_num);
  if ent_num < min_num then min_num := ent_num;
  if ent_num > max_num then max_num := ent_num;

  readLn(ent_num);
  if ent_num < min_num then min_num := ent_num;
  if ent_num > max_num then max_num := ent_num;

  readLn(ent_num);
  if ent_num < min_num then min_num := ent_num;
  if ent_num > max_num then max_num := ent_num;

  writeln('Max = ', max_num);
  writeln('Mix = ', min_num);
end.

/////////////////////////////////////////////////////////////////////////////////////////////////// Вариант 3
program min_max_of_four_numbers_without_arrays_or_cycles;
var
summary, first_number, second_number, third_number, forth_number:real;
begin
writeln('Последовательно введите четыре числа, которые необходимо сравнить');
readln(first_number, second_number, third_number, forth_number);
if (first_number > second_number) and (first_number > third_number) and (first_number > forth_number) then
if (second_number < third_number) and (second_number < forth_number) then
begin
writeln('Max = ', first_number);
writeln('Min = ', second_number);
end
else if (third_number < second_number) and (third_number < forth_number) then
begin
writeln('Max = ', first_number);
writeln('Min = ', third_number);
end
else
begin
writeln('Max = ', first_number);
writeln('Min = ', forth_number);
end;
if (second_number > first_number) and (second_number > third_number) and (second_number > forth_number) then
if (first_number < third_number) and (first_number < forth_number) then
begin
writeln('Max = ', second_number);
writeln('Min = ', first_number);
end
else if (third_number < first_number) and (third_number < forth_number) then
begin
writeln('Max = ', second_number);
writeln('Min = ', third_number);
end
else
begin
writeln('Max = ', second_number);
writeln('Min = ', forth_number);
end;
if (third_number > first_number) and (third_number > second_number) and (third_number > forth_number) then
if (first_number < second_number) and (first_number < forth_number) then
begin
writeln('Max = ', third_number);
writeln('Min = ', first_number);
end
else if (second_number < first_number) and (second_number < forth_number) then
begin
writeln('Max = ', third_number);
writeln('Min = ', second_number);
end
else
begin
writeln('Max = ', third_number);
writeln('Min = ', forth_number);
end;
if (forth_number > first_number) and (forth_number > second_number) and (forth_number > third_number) then
if (first_number < second_number) and (first_number < third_number) then
begin
writeln('Max = ', forth_number);
writeln('Min = ', first_number);
end
else if (second_number < first_number) and (second_number < third_number) then
begin
writeln('Max = ', forth_number);
writeln('Min = ', second_number);
end
else
begin
writeln('Max = ', forth_number);
writeln('Min = ', third_number);
end;
end.

 program finding_of_solutions_of_a_quadratic_equation;
var
a, b, c:real;
begin
writeln('Введите коэффициенты квадратного уравнения последовательно, от старшего к свободному члену: ');
readln(a, b, c);
if (a = 0) and (b <> 0) and (c <> 0) then
writeln('Единственный корень = ', -c/b);
if (a = 0) and (b = 0) and (c <> 0) then
writeln('Действительных корней нет');
if (a = 0) and (b = 0) and (c = 0) then
writeln('Корни уравнения - все действительные числа');
if (a <> 0) and (b = 0) and (c = 0) then
writeln('Единственный корень чётной степени = 0');
if (a <> 0) and (b <> 0) and (c = 0) then
begin
writeln('Первый корень = 0');
writeln('Второй корень = ', -b/a);
end;
if (a <> 0) and (b <> 0) and (c <> 0) then
begin
if (b*b-4*a*c) < 0 then
writeln('Действительных корней нет');
if (b*b-4*a*c) = 0 then
writeln('Единственный корень = ', -b/(2*a));
if (b*b-4*a*c) > 0 then
begin
writeln('Первый корень = ', (-b-sqrt(b*b-4*a*c))/(2*a));
writeln('Второй корень = ', (-b+sqrt(b*b-4*a*c))/(2*a));
end;
end;
end.

 Перевод числа из десятичной системы счисления в любую другую с основанием меньше 10:

program averse_transform_of_a_number_in_the_number_system_with_basis_less_then_ten;

var

output_number:string;

input_number, basis_of_the_number_system_end:integer;

begin

writeln('Введите последовательно число в десятичной системе и счисления и основание системы счисления, в которую его надо перевести ');

readln(input_number, basis_of_the_number_system_end);

output_number:=' ';

while input_number <> 0 do

begin

output_number:= (input_number mod basis_of_the_number_system_end) + output_number;

input_number := input_number div basis_of_the_number_system_end;

end;

writeln('Искомое число = ', output_number);

end.

Перевод из двоичной в восьмеричную без умножения на основание системы счисления (используется свойство триад). Аналогично возможен перевод из двоичной в шестнадцатеричную (используется свойство тетрад и массив должен быть расширен до 1112 элементов):
 
program from_binary_into_octal;
var
octo:string;
a:array[0..111]of string;
input_number, mod_number:integer;
begin
writeln('Введите число в двоичной системе счисления ');
readln(input_number);
a[0]:='0';
a[1]:='1';
a[10]:='2';
a[11]:='3';
a[100]:='4';
a[101]:='5';
a[110]:='6';
a[111]:='7';
octo := '';
while input_number <> 0 do
begin
mod_number := input_number mod 1000;
input_number := input_number div 1000;
octo := a[mod_number] + octo;
end;
writeln('Число в восьмеричной системе счисления = ', octo);
end.

 Сумма последовательности введённых чисел:

program finding_of_summary_of_the_math_sequence;

var

i, amount_of_numbers, summary, input_number:integer;

begin

summary := 0;

readln(amount_of_numbers);

for i := 1 to amount_of_numbers do

begin

writeln('Введите число последовательности');

readln(input_number);

summary := input_number + summary;

end;

writeln('Сумма последовательности введённых чисел = ', summary);

end.

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

program finding_of_summary_of_the_array;

const

N=9;

var

a:array[0..N] of integer;

i, summary, input_number:integer;

begin

summary := 0;

for i := 0 to N do

begin

writeln('Введите значение элемента массива');

readln (a[i]);

summary := summary + a[i];

end;

writeln('Сумма элементов массива = ', summary);

end.

 Проверка числа на простоту:
 
program finding_of_the_least_prime_divider_of_the_number;
var
identificator:boolean;
i, input_number:integer;
begin
identificator := false;
writeln('Введите число, которое надо проверить на простоту ');
readln(input_number);
for i := 2 to round(sqrt(input_number)) do
if input_number mod i = 0 then
identificator := true;
if identificator = false then
writeln('Простое')
else
writeln('Составное')
end.
 

Подсчёт количества делителей данного числа:
 
program finding_of_the_amount_of_dividers_of_the_number;
var
i, amount_of_dividers_of_the_number, input_number:integer;
begin
writeln('Введите число, у которого необходимо подсчитать количество делителей ');
readln(input_number);
amount_of_dividers_of_the_number := 0;
for i := 2 to input_number do
if input_number mod i = 0 then
amount_of_dividers_of_the_number := amount_of_dividers_of_the_number + 1;
writeln('Количество делителей = ', amount_of_dividers_of_the_number);
end.

Заполнение двумерного массива числами, введенными с клавиатуры:
program filling_of_the_two_dimensional_array;
const
N=4;
var
i, j:integer;
a:array[0..N, 0..N]of integer;
begin
for i:=0 to N do
begin
for j:=0 to N do
readln(a[i, j]);
end;
for i :=0 to N do
begin
for j :=0 to N do
write(a[i,j]:5);
writeln;
end;
end.
 

Заполнение двумерного массива случайными числами в диапазоне:
 
program filling_of_the_two_dimensional_array_with_random_numbers;
const
N=4;
var
i, j:integer;
a:array[0..N, 0..N]of integer;
begin
for i:=0 to N do
begin
for j:=0 to N do
a[i, j]:=random(1, 99);
end;
for i :=0 to N do
begin
for j :=0 to N do
write(a[i,j]:5);
writeln;
end;
end.
 

Создание матрицы (Как в популярном фильме. Просто и красиво. Увеличивая диапазон случайных чисел, получаем большее символьное разнообразие)
 
program the_creation_of_matrix;
var
i,j:integer;
a:array [0..34, 0..10000] of integer;
b:array [0..34, 0..10000] of char;
begin
for i:=0 to 34 do
begin
for j:=0 to 10000 do
a[i, j]:=random(1, 100);
end;
for i:=0 to 34 do
begin
for j:=0 to 10000 do
b[i, j] := Chr(a[i,j] + Ord('0'));
end;
for i :=0 to 34 do
begin
for j :=0 to 10000 do
write(b[i, j]:2);
writeln;
end;
end.

Поиск максимального значения в массиве. Аналогично делается поиск минимального значения, только меняется знак на противоположный при проверке условия:
 
program finding_of_the_max_in_the_array;
const
N=9;
var
a:array[0..N]of integer;
max, i:integer;
begin
for i:=0 to N do
begin
writeln('Введите значение элемента массива ');
readln(a[i]);
end;
max:=a[0];
for i:=1 to N do
if a[i] > max then
max:=a[i];
writeln('Max = ', max);
end.
 
 Подсчет количества элементов массива, равных данному числу:
 
program finding_of_the_amount_of_equal_numbers;
const
N=9;
var
a:array[0..N]of integer;
input_number, i, amount_of_equal_numbers:integer;
begin
amount_of_equal_numbers := 0;
writeln('Введите число, которое надо сравнить с элементами массива ');
readln(input_number);
for i := 0 to N do
begin
writeln('Введите значение элемента массива ');
readln(a[i]);
end;
for i := 0 to N do
if a[i] = input_number then
amount_of_equal_numbers := amount_of_equal_numbers + 1;
writeln('Количество равных этому числу элементов массива = ', amount_of_equal_numbers);
end.
 

Нахождение индекса элемента массива с данным значением:
 
program finding_of_the_idex_of_the_equal_element_of_the_array;
const
N=9;
var
input_number, i, index:integer;
a:array[0..N]of integer;
begin
writeln('Введите значение элемента массива, индекс которого надо вывести');
readln(input_number);
for i:=0 to N do
begin
writeln('Введите значение элемента массива ');
readln(a[i]);
end;
index := -1;
for i:=0 to N do
if a[i] = input_number then
begin
index := i;
break;
end;
if index = -1 then
writeln('Такого элемента нет')
else
writeln(index);
end.
 

Вставка и удаление элементов в массиве (со сдвигом вправо):
 
program input_of_an_element_into_the_array;
const
N=10;
var
a:array[1..N]of integer;
i, index, meaning:integer;
begin
for i:=1 to N do
a[i] := random(1,99);
writeln(a);
writeln('Индекс элемента, вместо которого надо добавить новое значение?');
readln(index);
writeln('Какое значение будет добавлено?');
readln(meaning);
for i:=N downto (index+1) do
a[i] := a[i-1];
a[index] := meaning;
writeln(a);
end.
 

Перестановка элементов данного массива в обратном порядке:
 
program reverse_of_the_array;
const
N=10;
var
a:array[1..N]of integer;
i, temporary:integer;
begin
for i:=1 to N do
a[i]:=random(1, 99);
writeln(a);
for i:=1 to N div 2 do
begin
temporary := a[i];
a[i] := a [N-i+1];
a[N-i+1] := temporary;
end;
writeln(a);
end.

 program finding_of_two_min_those_may_repeat;
const
N=9;
var
a:array[0..N]of integer;
i, first_min, second_min:integer;
begin
for i := 0 to N do
a[i] := random(1,99);
if a[0]<a[1] then
begin
first_min := a[0];
second_min := a[1];
end
else
begin
first_min := a[1];
second_min := a[0];
end;
for i:=2 to N do
begin
if (first_min > a[i]) and (second_min > a[i]) then
begin
second_min := first_min;
first_min := a[i];
end;
if (first_min > a[i]) and (second_min < a[i]) then
begin
first_min := second_min;
second_min := a[i];
end;
if (first_min < a[i]) and (second_min > a[i]) then
second_min := a[i];
end;
writeln(a);
writeln('Первый минимум = ', first_min, ' Второй минимум = ', second_min);
end.