Про­из­ве­де­ние двух чисел де­лит­ся на 10, если один из со­мно­жи­те­лей де­лит­ся на 10 (вто­рой может быть любым), либо если ни один из со­мно­жи­те­лей не де­лит­ся на 10, но один из со­мно­жи­те­лей де­лит­ся на 2, а дру­гой  — на 5.

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

- крат­ные 10 (класс 10);

- крат­ные 2, но не крат­ные 5 (класс 2);

- крат­ные 5, но не крат­ные 2 (класс 5);

- не крат­ные ни 2, ни 5 (класс 0).

Числа, крат­ные 10, можно сразу от­бро­сить: они не могут участ­во­вать в ито­го­вом про­из­ве­де­нии. Про­из­ве­де­ние двух чисел не будет де­лить­ся на 10, если оба числа при­над­ле­жат од­но­му клас­су, либо если числа при­над­ле­жат

раз­ным клас­сам, но не клас­сам 2 и 5. При этом для по­лу­че­ния мак­си­маль­но­го зна­че­ния сле­ду­ет брать мак­си­маль­но воз­мож­ное число из каж­до­го клас­са. Пусть a2  — мак­си­маль­ное число в клас­се 2, b2  — вто­рое по ве­ли­чи­не число в клас­се 2, ана­ло­гич­ным об­ра­зом обо­зна­чим два наи­боль­ших числа в клас­сах 5 и 0. Тогда кон­троль­ным зна­че­ни­ем будет наи­боль­шее из сле­ду­ю­щих про­из­ве­де­ний: a2*b2, a5*b5, a0*b0, a0*a2, a0*a5.

Про­грам­ма чи­та­ет все вход­ные дан­ные один раз, не за­по­ми­ная все дан­ные в мас­си­ве, для каж­до­го вход­но­го числа опре­де­ля­ет его класс, от­бра­сы­ва­ет числа клас­са 10 и хра­нит два наи­боль­ших числа для каж­до­го из осталь­ных клас­сов. После ввода всей по­сле­до­ва­тель­но­сти про­грам­ма вы­чис­ля­ет 5 пе­ре­чис­лен­ных выше про­из­ве­де­ний, вы­би­ра­ет из них наи­боль­шее и срав­ни­ва­ет его с введённым кон­троль­ным зна­че­ни­ем.

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

При­мер пра­виль­ной и эф­фек­тив­ной про­грам­мы на языке Си

При­мер пра­виль­ной и эф­фек­тив­ной про­грам­мы на языке Бей­сик

При­мер пра­виль­ной и эф­фек­тив­ной про­грам­мы на Ал­го­рит­ми­че­ском языке

При­мер ре­ше­ния за­да­чи А на языке Пас­каль.

var
  a: array[1..10000] of integer; {ис­ход­ные дан­ные}
  N: integer; {ко­ли­че­ство эле­мен­тов по­сле­до­ва­тель­но­сти}
  R: integer; {при­ни­ма­е­мое кон­троль­ное зна­че­ние}
  max: integer; {вы­чис­ля­е­мое кон­троль­ное зна­че­ние}
  i, j: integer;
begin
  readln(N);
  max := 0;
  for i := 1 to N do read(a[i]);
  for i := 1 to N-1 do
    for j := i+1 to N do
      if (a[i]*a[j] > max) and (a[i]*a[j] mod 10 <> 0) then max := a[i] * a[j];
  readln(R);
  writeln('По­лу­че­но чисел: ', N);
  writeln('При­ня­тое кон­троль­ное зна­че­ние: ', R);
  if max>0 then writeln('Вы­чис­лен­ное кон­троль­ное зна­че­ние: ', max);
  if (R>0) and (R=max) then writeln('Кон­троль прой­ден')
  else writeln('Кон­троль не прой­ден');
end.

Про­из­ве­де­ние двух чисел де­лит­ся на 15, если один из со­мно­жи­те­лей де­лит­ся на 15 (вто­рой может быть любым), либо если ни один из со­мно­жи­те­лей не де­лит­ся на 15, но один из со­мно­жи­те­лей де­лит­ся на 3, а дру­гой  — на 5.

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

- крат­ные 15 (класс 15);

- крат­ные 3, но не крат­ные 5 (класс 3);

- крат­ные 5, но не крат­ные 3 (класс 5);

- не крат­ные ни 3, ни 5 (класс 0).

Числа, крат­ные 15, можно сразу от­бро­сить: они не могут участ­во­вать в ито­го­вом про­из­ве­де­нии. Про­из­ве­де­ние двух чисел не будет де­лить­ся на 15, если оба числа при­над­ле­жат од­но­му клас­су, либо если числа при­над­ле­жат

раз­ным клас­сам, но не клас­сам 3 и 5. При этом для по­лу­че­ния мак­си­маль­но­го зна­че­ния сле­ду­ет брать мак­си­маль­но воз­мож­ное число из каж­до­го клас­са. Пусть a3  — мак­си­маль­ное число в клас­се 3, b3  — вто­рое по ве­ли­чи­не число в клас­се 3, ана­ло­гич­ным об­ра­зом обо­зна­чим два наи­боль­ших числа в клас­сах 5 и 0. Тогда кон­троль­ным зна­че­ни­ем будет наи­боль­шее из сле­ду­ю­щих про­из­ве­де­ний: a3*b3, a5*b5, a0*b0, a0*a3, a0*a5.

Про­грам­ма чи­та­ет все вход­ные дан­ные один раз, не за­по­ми­ная все дан­ные в мас­си­ве, для каж­до­го вход­но­го числа опре­де­ля­ет его класс, от­бра­сы­ва­ет числа клас­са 15 и хра­нит два наи­боль­ших числа для каж­до­го из осталь­ных клас­сов. После ввода всей по­сле­до­ва­тель­но­сти про­грам­ма вы­чис­ля­ет 5 пе­ре­чис­лен­ных выше про­из­ве­де­ний, вы­би­ра­ет из них наи­боль­шее и срав­ни­ва­ет его с введённым кон­троль­ным зна­че­ни­ем.

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

При­мер пра­виль­ной и эф­фек­тив­ной про­грам­мы на языке С++

При­мер пра­виль­ной и эф­фек­тив­ной про­грам­мы на языке Бей­сик

При­мер пра­виль­ной и эф­фек­тив­ной про­грам­мы на Ал­го­рит­ми­че­ском языке

При­ведём ре­ше­ние Ильи Му­ра­то­ва, Python.

n = int(input())

max31 = max32 = max51 = max52 = max01 = max02 = 0

for i in range(n):

k = int(input())

if k % 15 != 0:

    if k % 3 == 0:

        if max31 < k:

            max32 = max31

            max31 = k

        elif max32 < k:

            max32 = k

    elif k % 5 == 0:

        if max51 < k:

            max52 = max51

            max51 = k

        elif max52 < k:

            max52 = k

else:

    if max01 < k:

        max02 = max01

        max01 = k

    elif max02 < k:

        max02 = k

R = int(input())

t = max([max31 * max32, max51 * max52, max01 * max02, max31 * max01, max51 * max01])

print "По­лу­че­но чисел: ", n

print "При­ня­тое кон­троль­ное зна­че­ние: ", R

print "Вы­чис­лен­ное кон­троль­ное зна­че­ние: ", t

if R == t:

print "Кон­троль прой­ден"

else:

print "Кон­троль не прой­ден"