ВВЕРХ
ВНИЗ
  • Home
  • Series
  • Series 29 - 34

K наборов целых чисел по N элементов в каждом наборе

Series29. Даны целые числа K, N, а также K наборов целых чисел по N элементов в каждом наборе. Вывести общую сумму всех элементов, входящих в данные наборы.

Здесь нужно посчитать сумму всех чисел из данных наборов. Поскольку мы обходимся без массивов, то вводить элементы и считать их сумму будем одновременно. По сути – нужно ввести матрицу размера K×N (K строк, N столбцов) и посчитать сумму всех элементов, только без использования массива в паскале.

Количество наборов и элементов в наборах известно заранее, поэтому используем цикл с параметром for. Во внешнем цикле пересчитываются номера наборов (от 1 до K), во внутреннем – элементы наборов (от 1 до N). Сначала вводим число а (строка 15), потом увеличиваем сумму sum. Лишний вывод в строке 13 всегда можно убрать.

Код Pascal
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
var
  a, Sum: integer;
  K, N, i, j: byte;

begin
  write('K = ');
  readln(K);
  write('N = ');
  readln(N);
  Sum := 0; { <== Вначале сумма равна 0 }
  writeln;
  for i := 1 to K do begin
    writeln('Вводим ', N, ' чисел ', i, '-го набора:');
    for j := 1 to N do begin
      read(a); { <== Вводим число }
      Sum := Sum + a { <== Увеличиваем сумму }
    end
  end;
  writeln('Сумма всех чисел: ', Sum);
  readln
end.

Series30. Даны целые числа K, N, а также K наборов целых чисел по N элементов в каждом наборе. Для каждого набора вывести сумму его элементов.

Эта задача отличается от предыдущей двумя важными моментами: инициализация суммы sum:=0 и вывод этой суммы на экран осуществляется во внешнем цикле. Так, сначала мы присваиваем сумме 0 (строка 12). Потом заходим во внутренний цикл, вводим элементы и суммируем их (строки 15, 16). После выхода из цикла выводим результат (строка 18).

Код Pascal
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
var
  a, Sum: integer;
  K, N, i, j: byte;

begin
  write('K = ');
  readln(K);
  write('N = ');
  readln(N);
  for i := 1 to K do begin
    writeln;
    Sum := 0; { <== Вначале сумма i-го набора равна 0 }
    writeln('Вводим ', N, ' чисел ', i, '-го набора:');
    for j := 1 to N do begin
      read(a); { <== Вводим число }
      Sum := Sum + a { <== Увеличиваем сумму }
    end;
    writeln('  --> сумма чисел равна ', Sum)
  end;
  readln
end.

Рекомендую еще посмотреть: Находим сумму и среднее арифметическое.

Series31. Даны целые числа K, N, а также K наборов целых чисел по N элементов в каждом наборе. Найти количество наборов, содержащих число 2. Если таких наборов нет, то вывести 0.

Отличительной особенностью задачи Series31 является использование логической переменной Find, принимающей значение True, если последовательность чисел из набора содержит число 2, и False в противном случае.

Для пересчитывания наборов заходим во внешний цикл по i от 1 до K (строка 13) и присваиваем Find:=false, что означает, что число 2 мы ещё не нашли. Потом заходим во внутренний цикл по j от 1 до N, где будем вводить элементы i-го набора (строка 18). Далее идет самый главный момент данной программы: проверка условия на наличие в последовательности числа 2. Но поскольку нам достаточно одного совпадения, то проверять условие (a=2) будем при условии, что число 2 ещё не найдено, то есть переменная Find=false (строка 19).

Ещё раз заметим, что составное условие (not Find) and (a = 2) означает, что число a равно 2, и это первая двойка в последовательности. В этом случае меняем значение переменной Find (индикатор) на True, а количество Q наборов содержащих 2 увеличиваем на 1 (строки 21, 22 кода).

Строка 27 — вывод Q — количество наборов, в которых хотя бы раз встречается число 2. Если строка 22 сработает минимум раз (найдется число 2), то Q будет ненулевым, в противном случае мы получим 0 (сработает строка 12).

Код Pascal
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  
var
  a: integer;
  K, N, i, j, Q: byte;
  Find: boolean; { Find = True - число 2 в наборе есть,
    Find = False - числа 2 в наборе нет  }

begin
  write('K = ');
  readln(K);
  write('N = ');
  readln(N);
  Q := 0; { <== количество наборов содержащих 2 }
  for i := 1 to K do begin
    writeln;
    writeln('Вводим ', N, ' чисел ', i, '-го набора:');
    Find := false; { <== Число 2 ещё не найдено }
    for j := 1 to N do begin
      read(a); { <== Вводим число }
      if (not Find) and (a = 2) then 
      begin
        Find := true; { <== Число 2 найдено }
        inc(Q) { <== Увеличиваем количество }
      end
    end
  end;
  writeln;
  writeln('--> ', Q);
  readln
end.

Series32. Даны целые числа K, N, а также K наборов целых чисел по N элементов в каждом наборе. Для каждого набора вывести номер его первого элемента, равного 2, или число 0, если в данном наборе нет двоек.

Обозначим через Num номер первого числа в наборе равного 2. Поскольку необходимо проверять наличие двойки в каждом наборе, то сначала заходим в цикл (по K — считаем номера наборов), и сразу присваиваем номеру Num начальное значение 0 (строка 11). Уже потом в следующем внутреннем цикле, где вводим элементы а, будем проверять истинность равенства a=2 и запоминать номер Num:=j (строка 17), но только при условии, что номер Num ещё равен 0 (строка 16), то есть число 2 ещё не встречалось (в противном случае Num ≠ 0).

В строке 19 мы выводим номер Num первого числа равного 2 (если оно есть, то мы его находим в строке 17); если же двойки нет – срабатывает строка 11 и Num равен 0.

Код Pascal
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
var
  a: integer;
  K, N, i, j, Num: byte;

begin
  write('K = ');
  readln(K);
  write('N = ');
  readln(N);
  for i := 1 to K do begin
    Num := 0; { <== номер числа 2 в i-м наборе }
    writeln;
    writeln('Вводим ', N, ' чисел ', i, '-го набора:');
    for j := 1 to N do begin
      read(a); { <== Вводим число }
      if Num = 0 then
        if a = 2 then Num := j { <== находим номер }
    end;
    writeln('--> ', Num); { <== Выводим номер }
  end;
  readln
end.

Series33. Даны целые числа K, N, а также K наборов целых чисел по N элементов в каждом наборе. Для каждого набора вывести номер его последнего элемента, равного 2, или число 0, если в данном наборе нет двоек.

Задание Series33 отличается от предыдущего Series32 только тем, что необходимо запоминать номер не первого, а последнего числа равного 2. А это ещё проще – нужно из предыдущего кода убрать строку 16, гарантирующую нам нахождение номера первого числа в наборе, и оставить во внутреннем цикле оператор if a=2 then Num:=j (строка 16 ниже), где просто "запоминаем" номер числа 2, при условии, конечно, что оно есть. Если же двойки нет, то при выводе номера в строке 18 сработает строка 11, где Num ещё равен 0.

Код Pascal
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
var
  a: integer;
  K, N, i, j, Num: byte;

begin
  write('K = ');
  readln(K);
  write('N = ');
  readln(N);
  for i := 1 to K do begin
    Num := 0; { <== номер числа 2 в i-м наборе }
    writeln;
    writeln('Вводим ', N, ' чисел ', i, '-го набора:');
    for j := 1 to N do begin
      read(a); { <== Вводим число }
      if a = 2 then Num := j { <== находим номер }
    end;
    writeln('--> ', Num); { <== Выводим номер }
  end;
  readln
end.

Series34. Даны целые числа K, N, а также K наборов целых чисел по N элементов в каждом наборе. Для каждого набора выполнить следующее действие: если в наборе содержится число 2, то вывести сумму его элементов; если в наборе нет двоек, то вывести 0.

Как и в примере Series31, вводим логическую переменную Find ("находить" по англ.), принимающую значение True, если число 2 найдено в наборе, и False в противном случае. При входе во внешний цикл (по i от 1 до K) ставим Find:=false (строка 12), поскольку проверять наличие двойки нужно в каждом наборе. Далее во внутреннем цикле ищем число 2, причем нам достаточно хотя бы одного числа, поэтому оператор Find:=(a=2) будет выполняться до тех пор пока Find=false, то есть число 2 ещё не встречалось (строка 19). Как только выполнится условие a=2, переменная Find примет значение True.

Но параллельно с этим будем подсчитывать сумму чисел Sum (строка 20). На выходе из цикла, если Find истинно, то число 2 в наборе присутствует, но выводим сумму (строка 22), иначе выводим 0 (строка 23)

Код Pascal
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
  a, sum: integer;
  K, N, i, j: byte;
  Find: boolean;

begin
  write('K = ');
  readln(K);
  write('N = ');
  readln(N);
  for i := 1 to K do begin
    Find := false; { <== число 2 не найдено }
    sum := 0; { <== начальное значение суммы }
    writeln;
    writeln('Вводим ', N, ' чисел ', i, '-го набора:');
    for j := 1 to N do begin
      read(a); { <== Вводим число }
      { Проверяем, нашли ли число 2: }
      if Find = false then Find := (a = 2);
      sum := sum + a
    end;
    if Find then writeln('--> ', sum) { <== сумма }
    else writeln('--> ', 0)
  end;
  readln
end.

Сравните пример имеется ли в записи числа N цифра «2».

Но вместо логической переменной Find ("нашли число 2" или "не нашли число 2") можно просто подсчитывать их количество Count: если Count равно 0, то чисел 2 в наборе нет, если Count=1, то есть минимум одна двойка.

Код Pascal
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
  a, sum: integer;
  K, N, i, j, count: byte;

begin
  write('K = ');
  readln(K);
  write('N = ');
  readln(N);
  for i := 1 to K do begin
    count := 0; { <== количество двоек равно 0 }
    sum := 0; { <== начальное значение суммы }
    writeln;
    writeln('Вводим ', N, ' чисел ', i, '-го набора:');
    for j := 1 to N do begin
      read(a); { <== Вводим число }
      { Если находим число 2, а перед этим двоек не 
      было, то увеличиваем количество двоек на 1: }
      if (count = 0) and (a = 2) then count := 1;
      sum := sum + a
    end;
    if count = 1 then writeln('--> ', sum) { <== сумма }
    else writeln('--> ', 0)
  end;
  readln
end.

Комментируйте и спрашивайте, если что не понятно.

1C


Яндекс.Метрика