27 задание информатика егэ как оценивается

Сколько баллов можно получить за каждое задание ЕГЭ 2022 по информатике  можно узнать из демоверсии текущего года.

ЕГЭ 2022 информатика. Распределение баллов по заданиям.

Таблица 1

Система оценивания выполнения отдельных заданий и экзаменационной работы в целом

Ответы на все задания КИМ оцениваются автоматизировано.

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

За выполнение каждого задания присваивается (в дихотомической системе оценивания) либо 0 баллов («задание не выполнено»), либо 1 балл («задание выполнено»).

За верный ответ на задание 26 выставляется 2 балла; если значения в ответе перепутаны местами ИЛИ в ответе присутствует только одно верное значение (второе неверно или отсутствует), – 1 балл. В остальных случаях – 0 баллов.

За верный ответ на задание 27 выставляется 2 балла; если значения в ответе перепутаны местами ИЛИ в ответе присутствует только одно верное значение (второе неверно или отсутствует), – 1 балл. В остальных случаях – 0 баллов.

Максимальный первичный балл за выполнение экзаменационной работы – 29.

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

Связанные страницы:

ЕГЭ по информатике в 2022 году оценивается также как и в 2020, первичными баллами. Колличество первичных баллов по всем заданиям — это общий первичный балл, он переводится во вторичный (тестовый) с помощью таблицы.

Таблица перевода первичных баллов во вторичные является ориентировочной

Максимальный первичный балл за экзамен — 30.

Если экзаменуемый набрал менее 5 первичных баллов, экзамен считается не сдан, поступить в ВУЗ нельзя.

Если за экзамен было набрано от 6 до 21 первичных баллов можно поступить на платное отделение в ВУЗ.

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

Таблица перевода первичных баллов ЕГЭ в оценку

Из четырёх заданных чисел можно составить б попарных произведений:

2*6 = 12 
2*29 = 58 
2*87 = 174 
6*29 = 174 
6*87 = 522 
29*87 = 2523

Из них на 58 делятся 4 произведения (выделены синим).

* Учтите, что в данных заданиях более не требуется учитывать эффективность алгоритма (с 2021 года)!

✎ Программа эффективна по времени и по памяти (4 балла):

• Язык Паскаль (версия PascalABC):

var
  N: integer; {количество чисел} 
  a: integer; {очередное число} 
  n58, n29, n2: integer;
  k58: integer; {количество требуемых пар} 
  i: integer;
 
begin
  readln(N);
  n58 := 0; 
  n29 := 0; 
  n2 := 0; 
  for i := 1 to N do 
  begin
    readln(a);
    if a mod 58 = 0 then 
      n58 := n58 + 1 
    else if a mod 29 = 0 then 
      n29 := n29 + 1 
    else if a mod 2 = 0 then 
      n2 := n2 + 1;
  end;
  k58 := n58 * (n58 - 1) div 2 + n58 * (N - n58) + n2 * n29; 
  writeln(k58)
end.

• Язык Python (версия Python 3):

n=int(input())
n58,n29,n2=0,0,0
for i in range(n):
    a=int(input())
    if a % 28 == 0:
        n58+=1
    elif a % 29 == 0:
        n29+=1
    elif a % 2 == 0:
        n2+=1
k58=n58 * (n58-1) // 2 + n58 * (n-n58) + n2 * n29
print(k58)

Произведение двух чисел делится на 58, если выполнено одно из следующих условий (условия не могут выполняться одновременно).

A. Оба сомножителя делятся на 58.

Б. Один из сомножителей делится на 58, а другой не делится.

B. Ни один из сомножителей не делится на 58, но один сомножитель делится на 2, а другой — на 29.

Почему именно 2 и 29?

Берем два делителя числа 58, произведение которых дает число 58: 2*29 = 58. При этом одно из них — наименьший делитель (в нашем случае 2), а другой, не должен делиться на первый найденный делитель (29/2 <> 0).

Условие делимости произведения на 58 можно сформулировать проще, например так:

(один из сомножителей делится на 58) 
                    ИЛИ 
(один сомножитель делится на 2, а другой — на 29)

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

При вводе чисел можно определять, делится ли каждое из них на 58, 2 и 29, и подсчитывать следующие значения:

1. n58 — количество чисел, кратных 58;
2. n29 —количество чисел, кратных 29, но не кратных 2 и 58;
3. n2 — количество чисел, кратных 2, но не кратных 29 и 58.

Сами числа при этом можно не хранить. Каждое число учитывается не более чем в одном из счётчиков.

Количество пар, удовлетворяющих условию А, можно вычислить по формуле n58*(n58 - 1)/2.

Количество пар, удовлетворяющих условию Б, можно вычислить по формуле n58*(N - n58).

Количество пар, удовлетворяющих условию В, можно вычислить по формуле n2 * n29.

Поэтому искомое количество пар вычисляется по формуле:

n58 * (n58 - 1)/2 + n58 * (N - n58) + n2 * n29

✎ Программа неэффективная (2 балла):

• Язык Паскаль (версия PascalABC):

var
  i, j, k, n: integer;
  a: array[1..1000]of integer;//очередное значение
 
begin
  readln(n);
  for i := 1 to n do 
  begin
    readln(a[i]); 
  end;
  k := 0;
  for i := 1 to n - 1 do 
    for j := i + 1 to n do
      if a[i] * a[j] mod 58 = 0 then 
        k := k + 1;
  writeln(k);
end.

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

Описание входных и выходных данных В первой строке входных данных задаётся количество чисел N (1 ≤ N ≤ 1000). В каждой из последующих N строк записано одно целое положительное число, не превышающее 10 000.
В качестве результата программа должна напечатать одно число: количество пар, в которых произведение элементов кратно 26.

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

Из четырёх заданных чисел можно составить 6 попарных произведений:

2·6 = 12 
2·13 = 26 
2·39 = 78 
6·13 = 78
6·39 = 234 
13·39 = 507

Из них на 26 делятся 4 произведения:

2·13=26; 
2·39=78; 
6·13=78; 
6·39=234

* Учтите, что в данных заданиях более не требуется учитывать эффективность алгоритма (с 2021 года)!

Произведение двух чисел делится на 26, если выполнено одно из следующих условий (условия не могут выполняться одновременно).
А. Оба сомножителя делятся на 26.
Б. Один из сомножителей делится на 26, а другой не делится.
В. Ни один из сомножителей не делится на 26, но один сомножитель делится на 2, а другой – на 13.

Примечание для проверяющего. Условие делимости произведения на 26 можно сформулировать проще, например, так:
(один из сомножителей делится на 26) ИЛИ
(один сомножитель делится на 2, а другой – на 13).
Но в этом случае пара сомножителей может удовлетворять обоим условиям, что затруднит подсчёт количества пар.

При вводе чисел можно определять, делится ли каждое из них на 26, 2 и 13, и подсчитывать следующие значения:
1) n26 – количество чисел, кратных 26;
2) n13 – количество чисел, кратных 13, но не кратных 26;
3) n2 – количество чисел, кратных 2, но не кратных 26.

Примечание для проверяющего. Сами числа при этом можно не хранить.
Каждое число учитывается не более чем в одном из счётчиков.
Количество пар, удовлетворяющих условию А, можно вычислить по формуле n26·(n26 – 1)/2.
Количество пар, удовлетворяющих условию Б, можно вычислить по формуле n26·(N – n26).
Количество пар, удовлетворяющих условию В, можно вычислить по формуле n2·n13.
Поэтому искомое количество пар вычисляется по формуле

n26·(n26 – 1)/2 + n26·(N – n26) + n2·n13

✎ Программа эффективна и по времени, и по памяти (4 балла):
Программа на языке Паскаль (версия PascalABC):

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

var N: integer; {количество чисел} a: integer; {очередное число} n26, n13, n2: integer; k26: integer; {количество требуемых пар} i: integer; begin readln(N); n26 := 0;n13 := 0;n2 := 0; for i := 1 to N do begin readln(a); if a mod 26 = 0 then n26 := n26 + 1 else if a mod 13 = 0 then n13 := n13 + 1 else if a mod 2 = 0 then n2 := n2 + 1; end; k26 := n26 * (n26 - 1) div 2 + n26 * (N - n26) + n2 * n13; writeln(k26) end.

Программа на языке Python (версия Python 3):

1 2 3 4 5 6 7 8 9 10 11 12

n=int(input()) n26,n13,n2=0,0,0 for i in range(n): a=int(input()) if a % 26 == 0: n56+=1 elif a % 13 == 0: n13+=1 elif a % 2 == 0: n2+=1 k26=n26 * (n26-1) // 2 + n26 * (n-n26) + n2 * n13 print(k26)

Программа на языке Бейсик:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

N26 = 0 N2 = 0 N13 = 0 NX = 0 INPUT N FOR I = 1 TO N INPUT A IF A MOD 26 = 0 THEN N26 = N26 + 1 ELSE IF A MOD 13 = 0 THEN N13 = N13 + 1 ELSE IF A MOD 2 = 0 THEN N2 = N2 + 1 ELSE NX = NX + 1 END IF END IF END IF NEXT I K26 = N26*(N26 - 1)2 + N26*(N2 + N13 + NX) + N2*N13 PRINT K26

Дана последовательность N целых положительных чисел. Рассматриваются все пары элементов последовательности, разность которых чётна, и в этих парах, по крайней мере, одно из чисел пары делится на 19. Порядок элементов в паре неважен. Среди всех таких пар нужно найти и вывести пару с максимальной суммой элементов. Если одинаковую максимальную сумму имеет несколько пар, можно вывести

любую из них

. Если подходящих пар в последовательности нет,

нужно вывести два нуля

.

  
Описание входных и выходных данных
В первой строке входных данных задаётся количество чисел N (2 ≤ N ≤ 10 000). В каждой из последующих N строк записано одно натуральное число, не превышающее 10 000.
Пример входных данных:

* Учтите, что в данных заданиях более не требуется учитывать эффективность алгоритма (с 2021 года)!

• ✎ Программа эффективна по времени и памяти

Язык Pascal (PascalABC):
Вариант 1:

const
  p = 19;
 
var
  N: integer; {количество чисел}
  a: integer; {очередное число}
  m0, m1: integer; {чётный и нечётный максимумы}
  mp0, mp1: integer;  {чётный и нечётный максимумы, кратные p}
  x, y: integer; {ответ – пара чисел}
  i: integer;
 
begin
  m0 := 0; m1 := 0;
  mp0 := 0; mp1 := 0;
  x := 0; y := 0;
  readln(N);
  for i := 1 to N do
  begin
    readln(a);   
     // для четных
    if a mod 2 = 0 then  
    begin
      // если кратное
      if (a mod p = 0) and (a >= mp0) then 
        begin
          if mp0 > m0 then
            m0:= mp0;
          mp0:=a
        end     
        else if a > m0 then 
          m0 := a;
     end
     else 
        begin
    // для нечетных
        if (a mod p = 0)and(a>=mp1) then 
          begin 
            if mp1>m1 then 
              m1:=mp1;
            mp1 := a;
          end
          else if a>m1 then
            m1:=a;
         end;  
  end;
 //  writeln('mp0=', mp0, 'm0=', m0);
  if (mp0 > 0) and (m0 > 0) then
  begin
    x := mp0; y := m0; 
  end; 
 // writeln('mp1=', mp1, 'm1=', m1);
  if (mp1 > 0) and (m1 > 0) and (mp1 + m1 > x + y) then
  begin
    x := mp1; 
    y := m1;
  end;
  writeln('=', x, ' ', y)
end.

Язык Pascal (PascalABC):
Вариант 2:

const
  p = 19;
 
var
  n, i, x, k19n, k19chet, n19chet, n19n, m1, m2: integer;
 
begin
  readln(n); {количество чисел}
  readln(x); {первое число}
  // обнуление всех переменных
 
  k19chet := 0; // четный кратный
  n19chet := 0; // четный некратный
  k19n := 0; // нечетный кратный
  n19n := 0; // нечетный некратный
  m1 := 0; m2 := 0; // максимальные
  // цикл до n - 1, т.к. первое число уже считали
  for i := 1 to n - 1 do
  begin
    // проверка, если четный и кратный
    if (x mod p = 0) and (x mod 2 = 0) and (x > k19chet) then
    begin
      k19chet := x;
    end;
    // проверка, если четный и некратный
    if (x mod p <> 0) and (x mod 2 = 0) and (x > n19chet) then
    begin
      n19chet := x;
    end;
    // проверка, если нечетный и кратный
    if (x mod p = 0) and (x mod 2 = 1) and (x > k19n) then
    begin
      k19n := x;
    end;
    // проверка, если нечетный и некратный  
    if (x mod p <> 0) and (x mod 2 = 1) and (x > n19n) then 
    begin
      n19n := x;
    end;
 
    readln(x); // считываем очередное число
    // если x кратно и есть такое некратное n19chet, сумма с которым была бы больше чем m1 + m2
    if (x mod p = 0) and ((x + n19chet) mod 2 = 0) and (x + n19chet > m1 + m2) and (n19chet > 0) then
    begin
      m1 := x; m2 := n19chet;
    end;
    // если x кратно и есть такое некратное n19n, сумма с которым была бы больше чем m1 + m2
    if (x mod p = 0) and ((x + n19n) mod 2 = 0) and (x + n19n > m1 + m2) and (n19n > 0) then
    begin
      m1 := x; m2 := n19n;
    end;
    // если есть такое кратное k19n, сумма с которым была бы четной и больше чем m1 + m2
    if ((x + k19n) mod 2 = 0) and (x + k19n > m1 + m2) and (k19n > 0) then
    begin
      m1 := x; m2 := k19n;
    end;
    // если есть такое кратное k19chet, сумма с которым была бы четной и больше чем m1 + m2
    if ((x + k19chet) mod 2 = 0) and (x + k19chet > m1 + m2) and (k19chet > 0) then
    begin
      m1 := x; m2 := k19chet;
    end;
  end;
  writeln(m1, ' ', m2)
end.

Язык Python (Python 3)

:

p = 19
m0 = m1 = mp0 = mp1 = 0
N = int(input())
for i in range(N):
	 a = int(input())
	 if a % 2 == 0:
		 if a % p == 0 and a >= mp0:
			 if mp0 > m0: m0 = mp0
			 mp0 = a
		 elif a > m0: m0 = a
	 else:
		 if a % p == 0 and a >= mp1:
			 if mp1 > m1: m1 = mp1
			 mp1 = a
		 elif a > m1: m1 = a
x = y = 0
if mp0 > 0 and m0 > 0:
	x = mp0; y = m0
if mp1 > 0 and m1 > 0 and mp1 + m1 > x + y:
	x = mp1; y = m1
print(x,y)

Ещё один путь решения – записать всю последовательность в массив и анализировать её в несколько проходов. Ниже приводится реализующая такой алгоритм программа на языке C++. В этой программе массив с исходными данными обрабатывается два раза: на первом проходе находятся индексы максимального чётного и нечётного элементов, кратных p, на втором проходе – общие чётный и нечётный максимумы. При этом элементы, выделенные как кратные при первом проходе, во время второго прохода из сравнения исключаются. Такая программа эффективна по времени (несмотря на повторную обработку массива, общее время работы пропорционально N), но неэффективна по памяти. Максимальная оценка за такую программу при отсутствии в ней синтаксических и содержательных ошибок – 3 балла.

✎ Правильная программа на языке C++, эффективная только по времени

С++:

#include <iostream>
using namespace std;
int main() {
 const int p = 19; // делитель
 int N; cin >> N; // количество элементов
 int a[N]; // элементы последовательности
 for (int i = 0; i < N; ++i) cin >> a[i];
 int imp0 = -1, imp1 = -1; //индексы максимумов, кратных p
 for (int i = 0; i < N; ++i) {
	if (a[i] % p == 0) {
		 if (a[i] % 2 == 0) {
			if (imp0 == -1 || a[i] > a[imp0]) imp0 = i;
		}
		else {
			if (imp1 == -1 || a[i] > a[imp1]) imp1 = i;
		}
	}
 }
 int im0 = -1, im1 = -1; // индексы общих максимумов
 for (int i = 0; i < N; ++i) {
	 if (i != imp0 && i != imp1) {
		 if (a[i] % 2 == 0) {
			if (im0 == -1 || a[i] > a[im0]) im0 = i;
		 }
		 else {
			if (im1 == -1 || a[i] > a[im1]) im1 = i;
		 }
	 }
 }
 int x = 0, y = 0; // пара чисел для ответа
 if (imp0 != -1 && im0 != -1) {
	x = a[imp0]; y = a[im0];
 }
 if (imp1 != -1 && im1 != -1 && a[imp1] + a[im1] > x + y) {
	x = a[imp1]; y = a[im1];
 }
 cout << x << ' ' << y << endl;
 return 0;
}

• ✎ Правильная, но неэффективная программа на языке Паскаль

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

Язык Pascal (версия PascalABC):

const
  p = 19;
var
  N: integer; {количество чисел}
  a: array [1..10000] of integer; {исходные данные}
  x, y: integer; {ответ – пара чисел}
  i, j: integer;
begin
  readln(N);
  for i := 1 to N do readln(a[i]);
  x := 0; y := 0;
  for i := 1 to N - 1 do
  begin
    for j := i + 1 to N do
    begin
      if ((a[i] - a[j]) mod 2 = 0) and
            ((a[i] mod p = 0) or (a[j] mod p = 0)) and
      (a[i] + a[j] > x + y)
      then
      begin
        x := a[i]; y := a[j]
      end
    end
  end;
  writeln(x, ' ', y)
end.

Программа считается эффективной по памяти, если размер памяти, использованной в программе для хранения данных, не зависит от числа N и не превышает 1 килобайта.

Максимальная оценка за правильную программу, эффективную по времени и по памяти, — 4 балла.

Как в варианте А, так и в варианте Б программа должна напечатать одно число — максимально возможную сумму, соответствующую условиям задачи (или 0, если такую сумму получить нельзя).

* Учтите, что в данных заданиях более не требуется учитывать эффективность алгоритма (с 2021 года)!

✎ Задание Б (алгоритм), более сложное, 4 балла:

• поскольку в задании указано, что «имеется набор данных, состоящих из пар…», то введем в программу переменную n для количества пар, значение которой будет считываться со стандартного входного потока:

n:longint; {количество пар чисел};

• объявим сами числа типа integer, переменную цикла — i — типа integer и дополнительные переменные, смысл которых будет объяснен ниже. Объявление сделаем в отдельных строках (так делать не обязательно), чтобы можно было ввести удобно комментарии:

 x,y: integer; {пара чисел}
 max: integer; {максимальное из пары}
 min: integer; {минимальное из пары}
 sum:longint; {сумма квадратов отобранных чисел}
 min_kvadr:longint; {мин. нечетная разница квадратов max и min}
 i:integer;

• так как в задании не оговаривается, что пары чисел считывается из файла, значит их необходимо считать со стандартного входного потока оператором readln(); т.е. организуем цикл:

for i:=1 to n do begin
  readln(x,y);
  ...

Допустим имеем пары:

2 6
4 1
7 3
2 9
7 4

• Чтобы получить в итоге максимальную сумму, то необходимо суммировать те числа из пар чисел, которые максимальны в паре, т.е. в нашем случае будем суммировать квадраты выделенных чисел из пар:

2 6
4 1
7 3
2 9
7 4

• но сначала определим максимальное и минимальное число из каждой пары:

if x>y then 
begin 
   max:=x; min:=y 
end
else 
begin 
    max:=y;min:=x 
end;

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

2 6 - разница 32 (36 - 4)
4 1 - разница 15 (16 - 1)
7 3 - разница 40 (49 - 9)
2 9 - разница 77 (81 - 4)
7 4 - разница 33 (49 - 16)

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

if((max-min) mod 2 > 0) and ((sqr(max)-sqr(min)) < min_kvadr) then
    min_kvadr:=sqr(max) - sqr(min)

• для переменной, обозначающей разницу, до цикла необходимо назначить максимально возможное значение:

min_kvadr:=1073676289;  {32 767 * 32 767 (самое большое в типе integer) }

• таким образом, в цикле у нас происходит:
• 1. поиск максимального и минимального числа из пары;
• 2. вычисляется сумма максимальных чисел из каждой пары;
• 3. находится минимальная разница квадратов максимального и минимального числа в парах.
• после цикла необходимо проверить сумму на нечетность. Если сумма четная (чего НЕ должно быть по условию), то отнимем от суммы вычисленную минимальную разницу. Но при этом учтем, что если не нашлось нечетной минимальной разницы, то выводим 0 (по условию):

if sum mod 2 = 0 then begin
  if min_kvadr = 1073676289 then sum := 0
  else sum:=sum - min_kvadr
end;

Эффективная программа на языке Паскаль (версия Pascal ABC):

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
26

var
 n:longint; {количество пар чисел}
 x,y: integer; {пара чисел}
 max: integer; {максимальное из пары}
 min: integer; {минимальное из пары}
 sum:longint; {сумма квадратов отобранных чисел}
 min_kvadr:longint; {мин. нечетная разница квадратов max и min}
 i:integer;
begin
sum:=0;
readln(n);
min_kvadr:=1073676289;  {32 767 * 32 767, самое большое integer}
for i:=1 to n do begin
  readln(x,y);
  if x>y then begin max:=x; min:=y end
  else begin max:=y;min:=x end;
  sum:=sum+sqr(max);
  if((max-min) mod 2 > 0) and (sqr(max)-sqr(min) < min_kvadr) then
    min_kvadr:=sqr(max) - sqr(min)
end;
if sum mod 2 = 0 then begin
  if min_kvadr = 1073676289 then sum := 0
  else sum:=sum - min_kvadr
end;
writeln('sum=',sum)
end.

Пример работы программы:

3
1 4
2 4
3 4
sum=41

✎ Задание А (более легкое, 2 балла максимум):

• так как в задании указано, что пар чисел ровно 5, то введем в программу константу n=5

Решение на языке Паскаль (версия PascalABC):

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

const n = 5; {количество пар чисел} var x,y: longint; {пара чисел} max_sum: longint; {максимальная из сумм} sum:array [1..15]of longint; {суммы квадратов всех комбинаций чисел} i,k:longint; begin readln(x,y); sum[1]:=sqr(x); sum[2]:=sqr(y); k:=3; {счетчик для сумм} for i:=2 to n do begin readln(x,y); sum[k]:=sum[k-2]+sqr(x); {1 шаг: s3=s1+x*x}{2 шаг: s7=s4+x*x} sum[k+1]:=sum[k-2]+sqr(y); {1 шаг: s4=s1+y*y}{2 шаг: s8=s4+y*y} sum[k+2]:=sum[k-1]+sqr(x); {1 шаг: s5=s2+x*x}{2 шаг: s9=s6+x*x} sum[k+3]:=sum[k-1]+sqr(y); {1 шаг: s6=s2+y*y}{2 шаг: s10=s6+y*y} k:=k+4; end; max_sum:=sum[1]; for i:=1 to n*n do if (sum[i]>max_sum) and (sum[i] mod 2 <>0) then max_sum:=sum[i]; if (max_sum=sum[1]) and (max_sum mod 2 = 0) then max_sum:=0; writeln(max_sum) end.

Как в варианте А, так и в варианте Б программа должна напечатать одно число — минимально возможную сумму, соответствующую условиям задачи (или 0, если такую сумму получить нельзя).

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

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

 
Пример входных данных для варианта А:

* Учтите, что в данных заданиях более не требуется учитывать эффективность алгоритма (с 2021 года)!

✎ Задание Б (4 балла)

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

Пример правильной и эффективной программы для задания Б на языке Паскаль (версия PascalABC):

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
26
27
28
29
30
31
32

const
  aMax = 10000;{наибольшее возможное исходное число}
 
var
  N: longint; {количество троек}
  a, b, c, tmp: longint;{тройка чисел}
  s: longint;{сумма выбранных чисел}
  D_min: longint;{мин. разница в тройке не кратная 5}
  i: longint;{}
 
begin
  s := 0;
  D_min := aMax + 1;
  readln(N);
  for i := 1 to N do 
  begin
    readln(a, b, c);
    if (a > b) then begin tmp := a;a := b;b := tmp end;
    if(b > c) then begin
      tmp := b;b := c;c := tmp;
      if (a > b) then begin tmp := a;a := b;b := tmp end
    end; {a,b,c отсортированы по возрастанию}
    s := s + a;
    if((b - a) mod 5 > 0 ) and ((b - a) < D_min) then D_min := b - a;
    if((c - a) mod 5 > 0 ) and ((c - a) < D_min) then D_min := c - a
  end;
  if s mod 5 = 0 then begin
    if D_min > aMax then s := 0
    else s := s + D_min
  end;
  writeln(s)
end.

✎ Задание А (2 балла)

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

На языке Паскаль (версия PascalABC):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

var
  a: array[1..5, 1..3] of longint; 
  i1, i2, i3, i4, i5: longint; 
  s, sMin: longint;
 
begin
  for i1 := 1 to 5 do 
    readln(a[i1, 1], a[i1, 2], a[i1, 3]); 
  sMin := 100000; 
  for i1 := 1 to 3 do 
    for i2 := 1 to 3 do 
      for i3 := 1 to 3 do
        for i4 := 1 to 3 do
          for i5 := 1 to 3 do 
          begin
            s := a[1, i1] + a[2, i2] + a[3, i3] + a[4, i4] + a[5, i5];
            if (s mod 5 = 0) and (s < sMin) then 
              sMin := s
          end;
  if (sMin = 100000) then 
    sMin := 0; 
  writeln(sMin)
end.

Из 7 заданных элементов с учётом допустимых расстояний между ними можно составить 6 произведений:

 
58·4 = 232     :29=8
58·1 = 58      :29=2
58·29 = 1682   :29=58
2·1 = 2
2·29 = 58      :29=2
3·29 = 87      :29=3

Из них на 29 делятся 5 произведений.

* Учтите, что в данных заданиях более не требуется учитывать эффективность алгоритма (с 2021 года)!

✎ Программа на языке Паскаль (версия PascalABC). Программа неэффективна ни по времени, ни по памяти (2 балла):

• Перебор всех вариантов произведений:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

const s = 4;//требуемое расстояние   var n, i, j, cnt: integer; a: array[1..1000] of integer;   begin readln(n); cnt := 0; for i := 1 to n do readln(a[i]); for i := 1 to n - s do for j := i + s to n do if a[i] * a[j] mod 29 = 0 then cnt := cnt + 1; writeln(cnt) end.

✎ Программа на языке Паскаль (версия PascalABC). Программа эффективна и по времени, и по памяти (4 балла):

• Если один из сомножителей делится без остатка на 29, то произведение с любым другим сомножителем тоже будет делится на 29.
• Последние рассматриваемые 4 элемента можно хранить как 4 счётчика: количество делящихся на 29 среди всех считанных чисел, всех считанных чисел без последнего, всех считанных чисел без 2 последних, всех считанных чисел без 3 последних, – и также сдвигать их после очередного шага.

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 26 27 28 29 30 31

const s = 4;//требуемое расстояние   var n,i: integer; n1, n2, n3, n4: integer; //хранение последних s счетчиков a_: integer; //очередное значение cnt: integer;//количество искомых пар   begin readln(n); n1 := 0;n2 := 0;n3 := 0;n4 := 0; cnt := 0; for i := 1 to n do begin readln(a_); // очередное значение if i > s then if a_ mod 29 = 0 then cnt := cnt + (i - s) else cnt := cnt + n4; // сдвигаем элементы счетчика n4 := n3; n3 := n2; n2 := n1; // обновляем счетчик кратных 29 if a_ mod 29 = 0 then n1 := n1 + 1; end; writeln(cnt) end.

* Учтите, что в данных заданиях более не требуется учитывать эффективность алгоритма (с 2021 года)!

✎ Задание А (решение на языке Паскаль, версия pascalABC):
Ниже приводится пример переборного решения на Паскале, неэффективного ни по памяти, ни по времени, но являющегося правильным ответом на задание А.

const
  s = 8;{требуемое расстояние между показаниями} 
 
var
  N: integer;
  a: array[1..10000] of integer; {все показания датчика} 
  mp: integer; {минимальное значение произведения} 
  i, j: integer;
 
begin
  readln(N);
  {Ввод значений датчика} 
  for i := 1 to N do 
    readln(a[i]); 
  mp := 1000 * 1000 + 1;
  for i := 1 to N - s do 
  begin
    for j := i + s to N do 
    begin
      if (a[i] * a[j] mod 2 = 0) and (a[i] * a[j] < mp) then 
        mp := a[i] * a[j]
    end;
  end;
  if mp = 1000 * 1000 + 1 then 
    mp := -1; 
  writeln(mp)
end.

✎Задание Б (решение на языке Паскаль, версия pascalABC):

const
  s = 8; {требуемое расстояние между показаниями}
  amax = 1001;{больше максимально возможного показания}
 
var
  N: integer;
  a: array[1..s] of integer; {хранение s показаний датчика} 
  a_: integer; {ввод очередного показания} 
  ma: integer; {минимальное число без s последних} 
  me: integer; {минимальное чётное число без s последних} 
  mp: integer; {минимальное значение произведения} 
  p: integer;
  i, j: integer;
 
begin
  readln(N);
  {Ввод первых s чисел}
  for i := 1 to s do readln(a[i]);
  {Ввод остальных значений, поиск минимального произведения} 
  ma := amax;me := amax;mp := amax * amax;
  for i := s + 1 to N do 
  begin
    readln(a_);
    if a[1] < ma then ma := a[1];
    if (a[1] mod 2 = 0) and (a[1] < me) then me
    := a[1];
    if a_ mod 2 = 0 then p := a_ * ma
    else if me < amax then p := a_ * me
    else p := amax * amax;
    if (p < mp) then mp := p;
    {сдвигаем элементы вспомогательного массива влево}
    for j := 1 to s - 1 do
      a[j] := a[j + 1];
    a[s] := a_
  end;
  if mp = amax * amax then mp := -1;
  writeln(mp)
end.