Математика ЕГЭ
Русский язык ЕГЭ
Математика 5-7
Математика ОГЭ
Информатика
Физика
Обществознание
Кликните, чтобы открыть меню

(Старый формат ЕГЭ) 25. Программирование - массивы

1. Вспоминай формулы по каждой теме
2. Решай новые задачи каждый день
3. Вдумчиво разбирай решения

Среднее значение, сумма всех элементов

Задание 1 #12733

Дан целочисленный массив из \(N = 40\) элементов. Элементы массива могут принимать значения от -5000 до 15000. Опишите на одном из языков программирования алгоритм, который находит и выводит сумму элементов массива, кратных 3.

Например, для исходного массива из 6 элементов

23

45

3

4

9

101

программа должна вывести 57.

(Под условие подходят элементы 45, 3, 9. Их сумма равна 45 + 3 + 9 = 57).

Исходные данные объявлены так, как показано ниже на примерах для некоторых языков программирования. Запрещается использовать переменные, не описанные ниже, но разрешается не использовать некоторые из переменных. Индексация элементов в массиве начинается с 0.

\[\begin{array}{|l|l|l|} \hline \text{Бейсик} & Python & \text{Алгоритмический язык} \\ \hline CONST \; N \; AS \; INTEGER \; = \; 40 &\# \; \text{допускается также} &\text{алг} \\ DIM \; A \; (0 \; TO \; N-1) \; AS \; LONG \; &\# \; \text{использовать три} &\text{нач} \\ DIM \; I \; AS \; LONG & \# \; \text{ целочисленные переменные i,t,k} & \quad \text{цел} \; N = 40 \\ \quad \quad \; \; T \; AS \; LONG& a \; = [] &\quad \text{целтаб} \; a[0:N-1] \\ \quad \quad \; \; K \; AS \; LONG& n \; = \; 40&\quad \text{цел} \; i, \; t, \; k \\ FOR \; I \; = \; 0 \; TO \; N-1 &for \; i \; in \; range(0, \; n):&\quad \text{нц для} \; i \; \text{от} 0 \; \text{до} \; N-1 \\ \quad \quad \; \; INPUT \; A(I)& \quad a.append \; (int(input()))&\quad \quad \text{ввод} \; a[i] \\ NEXT \; I& ...&\quad \text{кц }\\ ... & &... \\ END & & \text{кон} \\ \hline \end{array}\]

\[\begin{array}{|l|l|} \hline \text{Паскаль} & C++ \\ \hline const &\#include \; <iostream> \\ \quad N = 40 & using \; namespace \; std; \\ var & const \; int \; N = 40; \\ \quad a: \; array \; [0..N-1] \; of \; longint; & int \; main() \{ \\ \quad i, \; t, \; k: \; longint; &long \; a[N]; \\ begin & long \; i, \; t, \; k; \\ \quad for \; i \; := 0 \; to \; N-1 \; do &for \; (i = 0; \; i < N; \; i++) \; cin >> a[i]; \\ \quad \quad readln (a[i]); & ... \\ ... &return \; 0; \\ end. & \} \\ \hline \end{array}\]

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

В цикле \(for\) от 0 до \(N\) будем перебирать все элементы массива.

В переменной \(t\) будем хранить сумму элементов, кратных 3. Так как изначально таких элементов нет, обнулим в первой строке \(t\). В цикле мы будем проверять, кратен ли элемент 3 (если остаток от деления числа на 3 равен 0, то кратен, иначе - нет). Если кратен, то увеличим \(t\) на значение этого элемента. Тогда к концу цикла в \(t\) будет храниться сумма всех элементов, кратных 3. Вне цикла выведем \(t\) в соответствии с условием.

Пример на C++:

\(t = 0; \)

\(for \; (i = 0; \; i < N; \; i++)\)

\(\quad if \; (a[i] \; \% \; 3 \; == 0) \; t \; += a[i]; \; \)

\(cout << t; \)

Ответ: См.решение

Задание 2 #12734

Дан целочисленный массив из \(N = 30\) элементов. Элементы массива могут принимать значения от 0 до 15000. Опишите на одном из языков программирования алгоритм, который находит среднее арифметическое нечетных элементов, а затем заменяет на 0 те элементы массива, которые отличаются от среднего арифметического более, чем в 2 раза. Среднее арифметическое в данной задаче - целое число. В качестве результата необходимо вывести измененный массив, каждый элемент выводится с новой строки.

Например, для исходного массива из 6 элементов

40

5

66

109

82

9

программа должна вывести

40

0

66

0

82

0

(Среднее арифметическое нечетных элементов равно 41)

Исходные данные объявлены так, как показано ниже на примерах для некоторых языков программирования. Запрещается использовать переменные, не описанные ниже, но разрешается не использовать некоторые из описанных переменных. Индексация элементов в массиве начинается с 0.

\[\begin{array}{|l|l|l|} \hline \text{Бейсик} & Python & \text{Алгоритмический язык} \\ \hline CONST \; N \; AS \; INTEGER \; = \; 30 & \# \; \text{ допускается также} &\text{алг} \\ DIM \; A \; (0 \; TO \; N-1) \; AS \; LONG \; & \# \; \text{использовать три} &\text{нач} \\ DIM \; I \; AS \; LONG& \# \; \text{ целочисленные переменные i,t,k} & \quad \text{цел} \; N = 30 \\ \quad \quad \; \; T \; AS \; LONG& a \; = [] &\quad \text{целтаб} \; a[1:N] \\ \quad \quad \; \; K \; AS \; LONG& n \; = \; 30&\quad \text{цел} \; i, \; t, \; k \\ FOR \; I \; = \; 0 \; TO \; N-1 &for \; i \; in \; range(0, \; n):&\quad \text{нц для} \; i \; \text{от} \; 0 \; \text{до} \; N-1 \\ \quad \quad \; \; INPUT \; A(I)& \quad a.append \; (int(input()))&\quad \quad \text{ввод} \; a[i] \\ NEXT \; I& ...&\quad \text{кц } \\ ... & &... \\ END & & \text{кон} \\ \hline \end{array}\]

\[\begin{array}{|l|l|} \hline \text{Паскаль} & C++ \\ \hline const &\#include \; <iostream> \\ \quad N = 30 & using \; namespace \; std; \\ var & const \; int \; N = 30; \\ \quad a: \; array \; [0..N-1] \; of \; longint; & int \; main() \{ \\ \quad i, \; t, \; k: \; longint; &long \; a[N]; \\ begin & long \; i, \; t, \; k; \\ \quad for \; i \; := 0 \; to \; N-1 \; do &for \; (i = 0; \; i < N; \; i++) \; cin >> a[i]; \\ \quad \quad readln (a[i]); & ... \\ ... &return \; 0; \\ end. & \} \\ \hline \end{array}\]

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

Так как нам нужно перебрать все элементы массива (с индексами от 0 до \(N\)), используем цикл \(for\).

Среднее арифметическое нечетных элементов равно сумме элементов, разделенной на их количество. Тогда мы будем отдельно считать сумму нечетных элементов и отдельно их количество. Сумму будем записывать в переменную \(t\), количество - в переменную \(k\). Обе эти переменные изначально (вне цикла) приравняем к нулю. В цикле будем проверять четность элемента, и если элемент нечетен, то увеличивать \(t\) на значение элемента и увеличивать \(k\) на 1 (потому что нечетных элементов стало на один больше).

Программа должна заменить на 0 те элементы массива, которые отличаются от среднего арифметического более, чем в два раза, то есть если \(2 \; * \; a[i] > t/k\), если \(a[i] >= t/k\) (мы делим t на k целочисленно) или \(a[i] > 2*t/k\), если \(a[i] < t/k\). Если одно из этих условий выполняется, заменим элемент на 0 (выполняем это в цикле \(for\) от 0 до \(N\) после того, как посчитаем \(t\) и \(k\)).

После этого выведем исправленный массив в строку в цикле \(for\) от 0 до \(N\).

Пример на C++:

\(t = 0, \; k = 0; \)

\(for \; (i = 0; \; i < N; \; i++) \{\)

\(\quad if \; (a[i] \; \% 2 \; != 0) \; \{\)

\(\quad \quad t \; += a[i]; \)

\(\quad \quad k++; \)

\(\quad \}\)

\(\}\)

\(for \; (i = 0; \; i < N; \; i++) \)

\(\quad if \; ((2 \; * \; a[i] < t/k) \; \&\& \; (a[i] >= t/k))\; || \; ((a[i] > 2*t/k) \; \&\& \; (a[i] < t/k)) \; a[i] = 0; \)

\(for \; (i = 0; \; i < N; \; i++) \)

\(\quad cout << a[i] << endl;\)

Ответ: См.решение

Задание 3 #12735

Дан целочисленный массив из \(N = 40\) элементов. Элементы массива могут принимать значения от 3 до 12001. Опишите на одном из языков программирования алгоритм, который находит и выводит сумму четных элементов массива, чьи индексы нечетные.

Например, для исходного массива из 6 элементов

23

44

3

3

9

102

программа должна вывести 146.

(Под условие подходят элементы 44 и 102. Их сумма равна 44 + 102 = 146).

Исходные данные объявлены так, как показано ниже на примерах для некоторых языков программирования. Запрещается использовать переменные, не описанные ниже, но разрешается не использовать некоторые из описанных переменных. Индексация элементов в массиве начинается с 0.

\[\begin{array}{|l|l|l|} \hline \text{Бейсик} &\text{Python} & \text{Алгоритмический язык} \\ \hline CONST \; N \; AS \; INTEGER \; = \; 40 &\# \; \text{допускается также} &\text{алг} \\ DIM \; A \; (0 \; TO \; N-1) \; AS \; LONG \; &\# \; \text{ использовать три} &\text{нач} \\ DIM \; I \; AS \; LONG& \# \; \text{ целочисленные переменные i,t,k} & \quad \text{цел} \; N = 40 \\ \quad \quad \; \; T \; AS \; LONG& a \; = [] &\quad \text{целтаб} \; a[0:N-1] \\ \quad \quad \; \; K \; AS \; LONG& n \; = \; 40&\quad \text{цел} \; i, \; t, \; k \\ FOR \; I \; = \; 0 \; TO \; N-1 &for \; i \; in \; range(0, \; n):&\quad \text{нц для} \; i \; \text{от} \; 0 \; \text{до}\; N-1 \\ \quad \quad \; \; INPUT \; A(I)& \quad a.append \; (int(input()))&\quad \quad \text{ввод} \; a[i] \\ NEXT \; I& ...&\quad \text{кц } \\ ... & &... \\ END & & \text{кон} \\ \hline \end{array}\]

\[\begin{array}{|l|l|} \hline \text{Паскаль} & C++ \\ \hline const &\#include \; <iostream> \\ \quad N = 40 & using \; namespace \; std; \\ var & const \; int \; N = 40; \\ \quad a: \; array \; [1..N] \; of \; longint; & int \; main() \{ \\ \quad i, \; t, \; k: \; longint; &long \; a[N]; \\ begin & long \; i, \; t, \; k; \\ \quad for \; i \; := 0 \; to \; N-1 \; do &for \; (i = 0; \; i < N; \; i++) \; cin >> a[i]; \\ \quad \quad readln \; (a[i]); & ... \\ ... &return \; 0; \\ end. & \} \\ \hline \end{array}\]

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

В переменной \(t\) будем хранить сумму четных элементов массива, чьи индексы нечетные. Приравняем \(t\) вне цикла к нулю.

В цикле \(for\) от 0 до \(N\) будем перебирать элементы. Для каждого элемента мы будем проверять его четность и четность его индекса. Если \(i \; \% 2 \; != 0\) и \(a[i] \% 2 \; == \; 0\), увеличим \(t\) на значение элемента.

Вне цикла выведем \(t\).

\(t = 0;\)

\(for \; (i = 0; \; i < N; \; i++) \)

\(\quad if \; ((a[i] \% 2 \; == \; 0) \; \&\& \; (i \; \% 2 \; != 0)) \; t \; += a[i]; \)

\(cout << t; \)

Ответ: См.решение

Задание 4 #12736

Дан целочисленный массив из \(N = 60\) элементов. Элементы массива могут принимать значения от 0 до 13001. Опишите на одном из языков программирования алгоритм, который ищет среднее значение всех элементов массива и увеличивает элемент на среднее значение, если он меньше среднего значения. В данной задаче среднее значение - целое число. В качестве результата необходимо вывести измененный массив, каждый элемент выводится с новой строки.

Например, для исходного массива из 6 элементов

24

37

7

3

2

10

программа должна вывести

24

37

20

16

15

23

(среднее значение равно 13).

Исходные данные объявлены так, как показано ниже на примерах для некоторых языков программирования. Запрещается использовать переменные, не описанные ниже, но разрешается не использовать некоторые из описанных переменных. Индексация элементов в массиве начинается с 0.

\[\begin{array}{|l|l|l|} \hline \text{Бейсик} & Python & \text{Алгоритмический язык} \\ \hline CONST \; N \; AS \; INTEGER \; = \; 60 & \# \; \text{допускается также} &\text{алг} \\ DIM \; A \; (0 \; TO \; N-1) \; AS \; LONG \; &\# \; \text{использовать три} &\text{нач} \\ DIM \; I \; AS \; LONG &\# \; \text{целочисленные переменные i,t,k} & \quad \text{цел} \; N = 60 \\ \quad \quad \; \; T \; AS \; LONG& a \; = [] &\quad \text{целтаб} \; a[0:N-1] \\ \quad \quad \; \; K \; AS \; LONG& n \; = \; 60&\quad \text{цел} \; i, \; t, \; k \\ FOR \; I \; = \; 1 \; TO \; N &for \; i \; in \; range(0, \; n):&\quad \text{нц для} \; i \; \text{от} \;0 \; \text{до} \; N-1 \\ \quad \quad \; \; INPUT \; A(I)& \quad a.append \; (int(input()))&\quad \quad \text{ввод} \; a[i] \\ NEXT \; I& ...&\quad \text{кц} \\ ... & &... \\ END & & \text{кон} \\ \hline \end{array}\]

\[\begin{array}{|l|l|} \hline \ \text{Паскаль} & C++ \\ \hline const &\#include \; <iostream> \\ \quad N = 60 & using \; namespace \; std; \\ var & const \; int \; N = 60; \\ \quad a: \; array \; [0..N-1] \; of \; longint; & int \; main() \{ \\ \quad i, \; t, \; k: \; longint; &long \; a[N]; \\ begin & long \; i, \; t, \; k; \\ \quad for \; i \; := 0 \; to \; N-1 \; do &for \; (i = 0; \; i < N; \; i++) \; cin >> a[i]; \\ \quad \quad readln \; (a[i]); & ... \\ ... &return \; 0; \\ end. & \} \\ \hline \end{array}\]

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

Будем перебирать элементы в цикле \(for\) от 0 до \(N\).

Среднее значение элементов - это сумма всех элементов, разделенная на их количество, то есть на \(N\). Тогда посчитаем сумму элементов и получим среднее значение, разделив сумму на \(N\).

В переменной \(t\) будем хранить сумму элементов массива. Вне цикла приравняем \(t\) к нулю.

Значит, в цикле во время перебора элементов будем увеличивать \(t\) на значение элемента.

После того, как мы получили значение \(t\) (то есть сумму элементов массива), запустим новый цикл \(for\) от 0 до \(N\). Если элемент окажется меньше среднего значения, то есть \(a[i] < t/N\), увеличим \(a[i]\) на \(t\): \(a[i] += t\) или \(a[i] = a[i] + t\).

Выведем измененный массив.

Пример на \(C++\):

\(t = 0;\)

\(for \; (i = 0;\; i < N; \; i++)\)

\(\quad t \; += a[i];\)

\(for \; (i = 0;\; i < N; \; i++)\)

\(\quad if \; (a[i] < t/N) \; a[i] \; += t; \)

\(for \; (i = 0;\; i < N; \; i++)\)

\(\quad cout << a[i] << endl; \)

Ответ: См.решение

Задание 5 #12737

Дан целочисленный массив из \(N = 60\) элементов. Элементы массива могут принимать значения от 1 до 13001. Опишите на одном из языков программирования алгоритм, который находит и выводит сумму четырехзначных элементов массива, которые начинаются с цифры 2.

Например, для исходного массива из 6 элементов

2456

4

5342

945

2483

67

программа выведет 4939.

Исходные данные объявлены так, как показано ниже на примерах для некоторых языков программирования. Запрещается использовать переменные, не описанные ниже, но разрешается не использовать некоторые из описанных переменных. Индексация элементов в массиве начинается с 0.

\[\begin{array}{|l|l|l|} \hline \text{Бейсик} & Python & \text{Алгоритмический язык} \\ \hline CONST \; N \; AS \; INTEGER \; = \; 60 & \# \; \text{допускается также} &\text{алг} \\ DIM \; A \; (0 \; TO \; N-1) \; AS \; LONG \; &\# \; \text{ использовать три} & \text{нач} \\ DIM \; I \; AS \; LONG&\# \; \text{ целочисленные переменные i,t,k} & \quad \text{цел} \; N = 60 \\ \quad \quad \; \; T \; AS \; LONG& a \; = [] &\quad \text{целтаб} \; a[0:N-1] \\ \quad \quad \; \; K \; AS \; LONG& n \; = \; 60&\quad \text{цел} \; i, \; t, \; k \\ FOR \; I \; = \; 0 \; TO \; N-1 &for \; i \; in \; range(0, \; n):&\quad \text{нц для} \; i \; \text{от} \; 0 \; \text{до} \; N-1 \\ \quad \quad \; \; INPUT \; A(I)& \quad a.append \; (int(input()))&\quad \quad \text{ввод} \; a[i] \\ NEXT \; I& ...&\quad \text{кц} \\ ... & &... \\ END & & \text{кон} \\ \hline \end{array}\]

\[\begin{array}{|l|l|} \hline \ \text{Паскаль} & C++ \\ \hline const &\#include \; <iostream> \\ \quad N = 60 & using \; namespace \; std; \\ var & const \; int \; N = 60; \\ \quad a: \; array \; [0..N-1] \; of \; longint; & int \; main() \{ \\ \quad i, \; t, \; k: \; longint; &long \; a[N]; \\ begin & long \; i, \; t, \; k; \\ \quad for \; i \; := 0 \; to \; N-1 \; do &for \; (i = 0; \; i < N; \; i++) \; cin >> a[i]; \\ \quad \quad readln \; (a[i]); & ... \\ ... &return \; 0; \\ end. & \} \\ \hline \end{array}\]

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

Для начала опишем алгоритм, по которому будем находить первую цифру четырехзначного числа. Пусть у нас есть число 4567. Если мы разделим его целочисленно на 1000, то получим 4. Так мы будем искать первую цифру для любого четырехзначного числа - делить целочисленно на 1000 (если бы мы работали и с отрицательными числами, то нужно было бы взять остаток от деления на 10, чтобы у первой цифры не было знака).

Чтобы проверить, что цифр в числе ровно 4, можно снова целочисленно разделить число на 1000. Если полученный результат будет больше 0 (значит, что в числе больше 3 цифр) и меньше 10 (значит, в числе меньше 5 цифр), то в числе ровно 4 цифры. Но, так как нам необходимо, чтобы первая цифра была равна 2, то есть чтобы \(a[i] / 1000 == 2\), то условия \(a[i] / 1000 >= 1\) и \(a[i] / 1000 <= 9\) будут излишними и выполняться в любом случае.

В переменной \(t\) будем хранить сумму четырехзначных элементов массива, чья первая цифра равна 2. Перед циклом приравняем \(t\) к нулю.

В цикле \(for\) от 0 до \(N\) будем перебирать элементы массива. Для каждого элемента мы будем проверять, что \(a[i] \; / \; 1000 == 2\) (условие, что первая цифра числа равна 2, и, следовательно, условие, что цифр в числе всего 4). Если это так, то прибавим к \(t\) значение этого элемента.

После цикла выведем \(t\) - нужную нам сумму.

Пример на С++:

\(t = 0;\)

\(for \; (i = 0; \; i < N; \; i++)\)

\(\quad if \; (a[i] \; / \; 1000 == 2) \; t \; += a[i];\)

\(cout << t;\)

Ответ: См.решение

Задание 6 #12738

Дан целочисленный массив из \(N = 160\) элементов. Элементы массива могут принимать значения от 4 до 12001. Опишите на одном из языков программирования алгоритм, который находит сумму первых цифр элементов массива, кратных 4, и заменяет каждый такой элемент на найденную сумму. В качестве результата необходимо вывести измененный массив, каждый элемент выводится с новой строки.

Например, для исходного массива из 6 элементов

3456

4

235

22

44

374

программа выведет

11

11

235

22

11

374

(сумма равна 3 (первая цифра числа 3456) + 4 (первая цифра числа 4) + 4 (первая цифра числа 44) = 11)

Исходные данные объявлены так, как показано ниже на примерах для некоторых языков программирования. Запрещается использовать переменные, не описанные ниже, но разрешается не использовать некоторые из описанных переменных. Индексация элементов в массиве начинается с 0.

\[\begin{array}{|l|l|l|} \hline \text{Бейсик} & Python & \text{Алгоритмический язык} \\ \hline CONST \; N \; AS \; INTEGER \; = \; 160 & \# \; \text{ допускается также} &\text{алг} \\ DIM \; A \; (0 \; TO \; N-1) \; AS \; LONG \; &\# \; \text{ использовать три} & \text{нач} \\ DIM \; I \; AS \; LONG& \# \; \text{ целочисленные переменные i,t,k} & \quad \text{цел} \; N = 160 \\ \quad \quad \; \; T \; AS \; LONG& a \; = [] &\quad \text{целтаб} \; a[0:N-1] \\ \quad \quad \; \; K \; AS \; LONG& n \; = \; 160&\quad \text{цел} \; i, \; t, \; k \\ FOR \; I \; = \; 0 \; TO \; N-1 &for \; i \; in \; range(0, \; n):&\quad \text{нц для} \; i \; \text{от} \; 0 \; \text{до} \; N-1 \\ \quad \quad \; \; INPUT \; A(I)& \quad a.append \; (int(input()))&\quad \quad \text{ввод} \; a[i] \\ NEXT \; I& ...&\quad \text{кц } \\ ... & &... \\ END & & \text{кон} \\ \hline \end{array}\]

\[\begin{array}{|l|l|} \hline \ \text{Паскаль} & C++ \\ \hline const &\#include \; <iostream> \\ \quad N = 160 & using \; namespace \; std; \\ var & const \; int \; N = 160; \\ \quad a: \; array \; [0..N-1] \; of \; longint; & int \; main() \{ \\ \quad i, \; t, \; k: \; longint; &long \; a[N]; \\ begin & long \; i, \; t, \; k; \\ \quad for \; i \; := 0 \; to \; N-1 \; do &for \; (i = 0; \; i < N; \; i++) \; cin >> a[i]; \\ \quad \quad readln \; (a[i]); & ... \\ ... &return \; 0; \\ end. & \} \\ \hline \end{array}\]

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

Будем перебирать элементы в цикле \(for\) от 0 до \(N\). Внутри цикла мы будем проверять элемент на кратность 4. Если элемент кратен 4, то мы прибавим первую цифру элемента к сумме первых цифр элементов, кратных 4. Эта сумма будет храниться в переменной \(t\), которую перед циклом приравняем к нулю.

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

Пусть у нас есть число 456. Если мы целочисленно разделим его на 10, то получим 45, то есть цифр в числе стало на одну меньше. Если мы разделим новое число еще раз на 10, то получим 4. И, наконец, если разделить еще раз целочисленно на 10, то получим уже 0, так как в числе осталась только одна цифра. Таким образом, мы видим, что с каждым целочисленным делением на 10 ’отбрасывается" последняя цифра. Тогда можно делить число на 10 до тех пор, пока оно будет больше или равно 10. Когда число станет меньше 10, то в нем будет только одна цифра, которая и нужна. Так можно найти первую цифру числа.

Так как нам заранее неизвестно количество цифр в числе, мы будем использовать цикл \(while\) (внутри цикла \(for\)). Пока рассматриваемое нами число больше или равно 10 (это условие выполнения), мы будем выполнять то, что написано в теле цикла. Как только число станет меньше 10, мы выйдем из цикла (если число стало меньше 10, то в нем осталась только одна цифра, которая и нужна). В теле цикла мы целочисленно делим число на 10. Так как в результате программы нужно вывести измененный массив, то, чтобы не менять заранее его элементы, перед циклом \(while\) будем копировать элемент в переменную \(k\) (которую тоже в самом начале приравняем к нулю) и совершать действия в цикле уже с ней. Когда программа выйдет из цикла \(while\), прибавим к \(t\) значение переменной \(k\).

После этого в следующем цикле заменим все элементы, кратные 4, на \(t\).

В цикле \(for\) выведем измененный массив.

Пример на C++:

\(t = 0, k = 0;\)

\(for \; (i = 0; \; i < N; \; i++)\{\)

\(if \; (a[i]\; \% 4 \; == \; 0)\{\)

\(\quad \quad k = a[i]; \)

\(\quad \quad while \; (k \; >= 10) \)

\(\quad \quad \quad k \; /= 10; \)

\(\quad \quad t \; += k; \)

\(for \; (i = 0; \; i < N; \; i++)\)

\(\quad if \; (a[i] \; \% \; 4 == 0) \; a[i] = t;\)

\(for \; (i = 0; \; i < N; \; i++)\)

\(\quad cout << a[i] << endl;\)

Ответ: См.решение

Задание 7 #12739

Дан целочисленный массив из \(N = 335\) элементов. Элементы массива могут принимать значения от 0 до 12001. Элемент массива называется отличным, если это число, у которого цифры расположены в порядке возрастания слева направо (например, 1234). Если число состоит из одной цифры, то оно тоже является отличным элементом. Элемент массива называется отвратительным, если это число, у которого произведение цифр больше 273. Опишите на одном из языков программирования алгоритм, который находит сумму отличных элементов и заменяет на нее все отвратительные элементы. В качестве результата необходимо вывести измененный массив, каждый элемент выводится с новой строки.

Например, для исходного массива из 6 элементов

5849

123

32

3958538

567

1

программа выведет

691

123

32

691

567

1

(Отличные элементы - это 123, 567 и 1, их сумма равна 691. Отвратительные элементы - это 5849 и 3958538, их заменили на 691.)

Исходные данные объявлены так, как показано ниже на примерах для некоторых языков программирования. Запрещается использовать переменные, не описанные ниже, но разрешается не использовать некоторые из описанных переменных. Индексация элементов в массиве начинается с 0.

\[\begin{array}{|l|l|l|} \hline \text{Бейсик} & Python & \text{Алгоритмический язык} \\ \hline CONST \; N \; AS \; INTEGER \; = \; 335 & \# \; \text{ допускается также} & \text{алг} \\ DIM \; A \; (0 \; TO \; N-1) \; AS \; LONG \; &\# \; \text{использовать четыре} &\text{нач} \\ DIM \; I \; AS \; LONG& \# \; \text{целочисленные переменные i,t,k ,p} & \quad \text{цел} \; N = 335 \\ \quad \quad \; \; T \; AS \; LONG& a \; = [] &\quad \text{целтаб} \; a[0:N-1] \\ \quad \quad \; \; K \; AS \; LONG& n \; = \; 335&\quad \text{цел} \; i, \; t, \; k, \; p \\ \quad \quad \; \; P \; AS \; LONG & & \\ FOR \; I \; = \; 0 \; TO \; N-1 &for \; i \; in \; range(0, \; n):&\quad \text{нц для} \; i \; \text{от} \; 0 \; \underline{\text{до}} \; N-1 \\ \quad \quad \; \; INPUT \; A(I)& \quad a.append \; (int(input()))&\quad \quad \text{ввод}\; a[i] \\ NEXT \; I& ...&\quad \text{кц} \\ ... & &... \\ END & & \text{кон} \\ \hline \end{array}\]

\[\begin{array}{|l|l|} \hline \ \text{Паскаль} & C++ \\ \hline const &\#include \; <iostream> \\ \quad N = 335 & using \; namespace \; std; \\ var & const \; int \; N = 335; \\ \quad a: \; array \; [0..N-1] \; of \; longint; & int \; main() \{ \\ \quad i, \; t, \; k, \; p: \; longint; &long \; a[N]; \\ begin & long \; i, \; t, \; k, \; p; \\ \quad for \; i \; := 0 \; to \; N-1 \; do &for \; (i = 0; \; i < N; \; i++) \; cin >> a[i]; \\ \quad \quad readln \; (a[i]); & ... \\ ... &return \; 0; \\ end. & \} \\ \hline \end{array}\]

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

В переменной \(t\) будем хранить сумму отличных элементов, поэтому изначально приравняем \(t\) к нулю. В цикле \(for\) от 0 до \(N\) будем перебирать элементы массива. Если элемент оказался отличным, будем увеличивать \(t\) на его значение.

Опишем алгоритм, по которому будем определять, является ли элемент отличным. Для начала поймем, как получить цифры, из которых состоит число. Пусть у нас есть число 763. Его последнюю цифру можно найти, взяв остаток от деления на 10. Попробуем так же найти и предпоследнюю цифру. Если мы целочисленно разделим 763 на 10, то получим 76, и цифра 6 тогда будет последней. Ее мы уже умеем находить как остаток от деления всего числа на 10, в данном случае как остаток от деления 76 на 10. Аналогично получим и цифру 7, целочисленно разделив 76 на 10 и взяв остаток от деления на 10. То есть, чтобы перебрать все цифры числа, нужно взять его остаток от деления на 10 (это будет последней цифрой), а потом целочисленно разделить число на 10, чтобы ’отбросить" уже рассмотренную последнюю цифру и перейти к следующей. Такую операцию мы будем проделывать до момента, пока не переберем все цифры, то есть пока число больше или равно 1.

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

В общем случае мы не знаем, сколько цифр содержится в числе. Тогда будем использовать цикл \(while\), который будет выполняться до тех пор, пока рассматриваемое число больше или равно 1. Как только число станет меньше 1, мы выйдем из цикла (если число стало меньше 1, то мы рассмотрели все его цифры и дальше работать с ним нет смысла). Чтобы не менять элемент, перед \(while\) будем копировать элемент в переменную \(p\). Мы будем хранить предыдущий остаток от деления числа на 10 (это цифра, которая находится справа от рассматриваемой сейчас), чтобы сравнивать ’текущую" цифру и предыдущую. Предыдущий остаток от деления на 10 мы будем хранить в переменной \(k\), которую будем обновлять в конце цикла (изначально \(k\) будет равна 11, ведь при таком значении \(k\) всегда больше последней цифры числа). Будем проверять, что \(k > p \% 10\), то есть что предыдущая цифра строго больше той, которую сейчас рассматриваем. Если в какой-то момент это условие не выполнится, мы выходим из цикла, потому что элемент уже нельзя будет назвать отличным. В таком случае мы приравняем \(k\) к -1. Так после выполнения цикла мы поймем, что элемент не является отличным, потому что в иных условиях \(k\) как остаток от деления на 10 неотрицательна и меньше 10, но больше или равна 0. Тогда сразу после цикла \(while\) проверим, равна ли \(k\) минус единице. Если не равна (значит, элемент отличный), то увеличим \(t\) на \(a[i]\).

После того, как мы переберем все элементы массива и узнаем сумму отличных элементов, запустим еще один цикл \(for\) от 0 до \(N\), в котором будем проверять, является ли элемент отвратительным. Если является, то заменим его на \(t\) - на сумму отличных элементов - в соответствии с условием.

Как проверить, является ли элемент отвратительным? Мы уже умеем получать все цифры числа. Будем перемножать цифры в цикле \(while\) и записывать результат в переменную \(k\), которую перед циклом приравняем к единице (так как \(k\) мы будем домножать на цифру, изначальное значение \(k\) не должно влиять на результат, поэтому \(k = 1\)). Если \(k\) окажется больше 273, то заменим элемент на \(t\).

После проверки всех элементов выведем в цикле \(for\) от 0 до \(N\) измененный массив.

Пример на \(C++\):

\(t = 0, \; k = 11, \; p = 0; \)

\(for \; (i = 0; \; i < N; \; i++) \{\)

\(\quad p = a[i]; \) //копируем \(a[i]\) в \(p\).

\(\quad while \; (p >= 1) \{\) //тут будем проверять, что все цифры идут в порядке возрастания слева направо

\(\quad \quad if \; (p \; \% \; 10 >= k) \{\) //если предыдущая цифра меньше или равна текущей (т.е. цифры расположены не в порядке возрастания слева направо)

\(\quad \quad \quad k = -1;\) //то приравниваем \(k\) к -1

\(\quad \quad \quad break; \) //и выходим из цикла

\(\quad \quad \}\)

\(\quad \quad k = p \; \% \; 10; \) //приравниваем \(k\) к последней цифре числа, чтобы сравнивать с ней следующую цифру в следующей итерации

\(\quad \quad p \; /= 10; \) //отбрасываем последнюю цифру

\(\}\)

\(\quad \quad if \; (k \; != -1) \; t += a[i]; \) //если k не равна -1, то элемент отличный и увеличиваем сумму на его значение

\(\}\)

\( p = 0; \)

//проверим, отвратительный ли элемент

\(for \; (i = 0; \; i < N; \; i++) \{\)

\(\quad p = a[i]; \) //снова скопируем элемент в \(p\)

\(\quad k = 1; \) //обновляем каждый раз \(k\)

\(\quad while \; (p >= 1) \{\)

\(\quad \quad k \; *= p \% 10; \) //в \(k\) храним произведение цифр

\(\quad \quad p /= 10;\) //убираем последнюю цифру

\(\}\)

\(\quad \; if \; (k > 273) \; a[i] = t; \)

\(\quad \}\)

\(for \; (i = 0; \; i < N; \; i++)\)

\(\quad cout << a[i] << endl; \)

Ответ: См.решение