Задачи Урок 13.1

Задачи Урок 13.1:

1) Выведите на экран таблицу умножения используя только циклы вида repeat/until.
Начинаться вывод таблицы должен как-то так:

1x1 = 1
1x2 = 2
......

var a, b : integer;
begin
  a := 1;
  repeat
    b := 1;
    repeat
      write(a, '*', b, '=', a*b, ' ');
      b := b + 1;
    until b > 9;
    a := a + 1;
    writeln();
  until a > 9;
end.

2) Выведите на экран таблицу умножения используя только циклы вида while.

var a, b : integer;
begin
  a := 1;
  while a <= 9 do
  begin
    b := 1;
    while b <= 9 do
    begin
      write(a, '*', b, '=', a*b, ' ');
      b := b + 1;
    end;
    a := a + 1;
    writeln();
  end;
end.

3) Выведите на экран таблицу умножения используя один цикл while и один repeat-until.

var a, b : integer;
begin
  a := 1;
  while a <= 9 do
  begin
    b := 1;
    repeat
      write(a, '*', b, '=', a*b, ' ');
      b := b + 1;
    until b > 9;
    a := a + 1;
    writeln();
  end;
end.

4) Пользователь вводит числа до тех пор пока не введёт число меньшее 1. В ответ на каждое введённое им число выводите на экран все нечетные числа от 1 до это числа, при этом делящиеся на 5. Если же пользователь ввел число меньшее 1, то завершите программу.

var i, n : integer;
begin
  repeat 
    write('введите число:');
    readln(n);
    
    if (n < 1) then
      writeln('пока!')
    else
    begin
      for i := 1 to n do
      begin
         if (i mod 2 = 1) and (i mod 5 = 0) then 
           write(i, ' ');
      end;
      writeln();
    end;
  until n < 1;
  
  readln();
end.

5) Пользователь вводит первое целое число-ограничитель m. А затем начинает вводить целые числа по одному, пока не введёт число большее числа-ограничителя. Если очередное целое число больше 1, то в ответ на каждое такое число программа должна выводить все целые числа от единицы до этого числа.
Примечание: это задача на вложенные циклы, в качестве внешнего надо использовать while, а в качестве внутреннего можно использовать или for или while.

var m, n, i : integer;
begin
  writeln('введите число-ограничитель');
  readln(m);
  while n <= m do
  begin
    writeln('введите число');
    readln(n);
    
    if n > 1 then
    begin
      i := 1;
      while i <= n do
      begin
        write(i, ' ');
        i := i + 1;
      end;
      writeln();
    end;
  end;
  
  writeln('пока!');
end.

6) Пользователь вводит целое положительное число, если оно не соответствует критериям (то есть не является положительным), выведите сообщение об ошибке, в противном случае выведите на экран все числа от 1 до введённого пользователем.

var a, i : integer;
begin
  writeln('введите целое положительное число');
  readln(a);
  
  if a < 0 then
    writeln('ошибка!')
  else
  begin
    for i := 1 to a do
      write(i, ' ');
  end;
end.

7) Пользователь вводит целое положительное число, если оно не соответствует критериям (то есть не является положительным), выведете сообщение об ошибке, в противном случае выведете на экран все четные числа от 1 до введённого пользователем.

var a, i : integer;
begin
  writeln('введите целое положительное число');
  readln(a);
  
  if a < 0 then
    writeln('ошибка!')
  else
  begin
    for i := 1 to a do
    begin
      if  i mod 2 = 0 then
        write(i, ' ');
    end;
  end;
end.

8)Выведете на экран числа от 1 до 5 два раза с помощью вложенных циклов. Так чтобы в консоли было:

1 2 3 4 5
1 2 3 4 5

var i, j : integer;
begin
  for i := 1 to 2 do 
  begin
    for j := 1 to 5 do 
      write(j, ' '); 
    writeln();
  end;
end. 

9) Есть исходный код:

var
  i,m:integer;
begin
  i:=1;
  m:=1;
  repeat
    repeat
      write('# ');
      m:=m+1;
    until(m=13);
    i:=i+1;
    writeln();
  until(i=9);
  readln();
end.

-- в нем сделана попытка вывести квадрат символов # размерами 13 на 9.
Но цикл оказывается бесконечным, разберитесь почему (напишите текстовое описание причины) и исправьте ошибку в коде, ответьте на вопросы:
1) На каком витке внешнего и внутреннего цикла (укажите номера витков) программа впервые начинает выводить не то, что ожидалось
2) Какой из двух циклов - внешний или внутренний оказывается бесконечным и почему (состояние переменных)

1) - Внешний цикл: на 2 итерации (i = 2)
- Внутренний цикл: на 2 итерации внешнего цикла(внутренний цикл пропускается)
2) Бесконечным циклом становится внешний цикл, потому что внутренний цикл перестает выполняться. Переменная m не срабатывается и условие until(m = 13) сразу выполняется.

10) M раз выведите на экран числа от 1 до N с помощью вложенных циклов. Так чтобы в консоли было:
1 ... N }M раз
1 ... N

var i, j, n, m : integer;
begin
  writeln('введите число n');
  readln(n);
  writeln('введите число m');
  readln(m);
  
  for i := 1 to m do
  begin
    for j := 1 to n do
      write(j, ' ');
    writeln();
  end;
end.

11) Модифицируйте предыдущую задачу так, чтобы в каждой чётной (той, у которой номер чётный) строке выводилось N символов, а в каждой нечетной N/2 символов (сделайте проверку того, что N/2 больше нуля)

var i, j, n, m : integer;
begin
  writeln('введите число n');
  readln(n);
  writeln('введите число m');
  readln(m);
  
  for i := 1 to m do
  begin
    if i mod 2 = 0 then
    begin
      for j := 1 to n do
        write(j, ' ');
    end
    else 
    begin
      if n div 2 > 0 then
      begin
        for j := 1 to n div 2 do
          write(j, ' ');
      end;
    end;
    writeln();
  end;
end.

12) Пользователь вводит числа до тех пор пока им не будет передан ноль. В ответ на каждое число программа должна сообщать чётное оно или нет.

var n : integer;
begin
  writeln('введите число');
  readln(n);
  while n <> 0 do
  begin
    if n mod 2 = 0 then
      writeln('четное')
    else
      writeln('нечетное');
    readln(n);
  end;
  writeln('пока!');
end.

13) Пользователь вводит четное целое число (если нечетное сообщите об ошибке). Делите это число в цикле на 2 до тех пор пока оно делится, выводя каждый промежуточный результат, например для 12 в консоли получим:

6
3

А для 8:

4
2
1

var n : integer;
begin
  writeln('введите четное целое число');
  readln(n);
  
  if n mod 2 = 1 then
    writeln('ошибка!')
  else
  begin
    while n mod 2 = 0 do
    begin
      n := n div 2;
      writeln(n);
    end;
  end;
  writeln('пока!');
end.

14) Пользователь вводит два целых числа M и N, если M четное, делайте то же, что и в предыдущей задаче, а если нечётное, то умножайте M в цикле на 3 до тех пор пока результат не станет больше N (и выводите каждый из промежуточных результатов умножения на экран), например для:

M := 3;
N := 15;

Получим:

9
27

var m, n : integer;
begin
  writeln('введите целое число');
  readln(m);
  writeln('введите целое число');
  readln(n);
  
  if m mod 2 = 0 then
    while m mod 2 = 0 do
    begin
      m := m div 2;
      writeln(m);
    end
  else
    while m <= n do
    begin
      m := m * 3;
      writeln(m);
    end;
  writeln('пока!');
end.

15) С помощью вложенных циклов выведите на экран таблицу деления чисел от 1 до 9.

var i, j : integer;
begin
  for j := 1 to 9 do
  begin
    for i := 1 to 9 do
    begin
      write(i*j, ':', i, '=', j, ' ');
    end;
    writeln();
  end;
end.

16) Пользователь вводит целое положительное число N большее или равное 8, если оно не соответствует этим критериям (то есть не является положительным и большим или равным 8), выведете сообщение об ошибке, в противном случае выведите на экран все числа последовательности, не большие N.
Например, для N=20 получим результат:

8 10 3 12 14 3 16 18 3 20

-- то есть всё начинается с восьмерки, затем число увеличивается на 2, затем выводится тройка и ещё пара увеличенных на 2 чисел и т.д. пока не дойдем до N.
ПРИМЕЧАНИЕ: эту задачу можно решить, как вложенными циклами, так и вообще одним циклом (что более изящно).
Решите указанными двумя способами.

1) способ с 1 циклом:

var n, i : integer;
begin
  writeln('введите положительное число > 8');
  readln(n);
   
  if n < 8 then
    writeln('ошибка!')
  else
  begin
    i := 8;
    while i <= n do
    begin
      write(i, ' ');
      if i + 2 <= n then
        write(i + 2, ' ');
      write(3, ' ');
      i := i + 4;
    end;
    writeln();
  end;
  writeln('пока!');
end.

2) способ с вложенными циклами:

var n, i, j: integer;
begin
  writeln('Введите целое положительное число > 8');
  readln(n);

  if n < 8 then
  begin
    writeln('ошибка!');
  end
  else
  begin
    i := 8; 
    while i <= n do
    begin
      j := 0;
      while (j < 2) and (i + j * 2 <= n) do
      begin
        write(i + j * 2, ' ');
        j := j + 1;
      end;
      if i + 4 <= n then
        write(3, ' ');
      i := i + 4;
    end;
    writeln();
  end;
  writeln('пока!');
end.

17) Пользователь вводит целое положительное число N большее или равное 8, если оно не соответствует этим критериям (то есть не является положительным и большим или равным 8), выведите сообщение об ошибке. Также пользователь вводит второе число M, которое отвечает за длину возрастающего фрагмента, например для M=4, выведите все числа до N таким образом:
8 10 12 14 3 16 18 20 22 3...3.... и т.д.
4 числа 4 числа

Если же число M было зафиксировано как = 2 то получаем:
8 10 3 14 16 3 ....3..... и т.д.
2 числа 2 числа

var n, m, i, c : integer;
begin
  writeln('введите целое положительное число > 8');
  readln(n);
  writeln('введите длину фрагмента');
  readln(m);
  
  if (n < 8) or (m <= 0) then
  begin
    writeln('ошибка!');
  end
  else
  begin
    i := 8; 
    while i <= n do
    begin
      c := 0; 
      while (c < m) and (i <= n) do
      begin
        write(i, ' ');
        i := i + 2;
        c := c + 1;
      end;
      if i <= n then
        write(3, ' ');
    end;
    writeln();
  end;
  writeln('пока!');
end.

18) Модифицируйте решение предыдущей задачи, так, чтобы длина возрастающего фрагмента каждый раз увеличивалась на единицу (начиная с двух):
8, 10 3 10 12 14 3 16 18 20 22 3 .... 3.... и т.д.
2 числа 3 числа 4 числа

ПРИМЕЧАНИЕ: эту задачу можно решить, как вложенными циклами, так и вообще одним циклом (что более изящно), при этом решение одним циклом можно сделать, как используя делимость нацело (для определения момента вывода тройки), так и не используя.
Решите всеми тремя способами.

1) c вложенными циклами:

var n, i, f, c : integer;
begin
  writeln('введите целое положительное число > 8');
  readln(n);
  
  if n < 8 then
  begin
    writeln('ошибка!');
  end
  else
  begin
    i := 8;
    f := 2;
    while i <= n do
    begin
      c := 0;
      while (c < f) and (i <= n) do
      begin
        write(i, ' ');
        i := i + 2;
        c := c + 1;
      end;
      if i <= n then
        write(3, ' ');
      f := f + 1;
    end;
    writeln();
  end;
  writelN('пока!');
end.

2) с использованием 1 цикла (с делимостью):

var n, i, t, f : integer;
begin
  writeln('введите целое положительное число > 8');
  readln(n);
  
  if n < 8 then
  begin
    writeln('ошибка!');
  end
  else
  begin
    i := 8;
    f := 2;
    t := 0;
    while i <= n do
    begin
      write(i, ' ');
      i := i + 2;
      t := t + 1;
      
      if t mod f = 0 then
      begin
        if i <= n then
          write(3, ' ');
        t := 0;
        f := f + 1;
      end;
    end;
      writeln();
    end;
  writeln('пока!');
end.

3) c использованием 1 цикла (без делимости):

var n, i, t, f : integer;
begin
  writeln('введите целое положительное число > 8');
  readln(n);
  
  if n < 8 then
  begin
    writeln('ошибка!');
  end
  else
  begin
    i := 8;
    f := 2;
    t := 0;
    while i <= n do
    begin
      write(i, ' ');
      i := i + 2;
      t := t + 1;
      
      if t = f then
      begin
        if i <= n then
          write(3, ' ');
        t := 0;
        f := f + 1;
      end;
    end;
      writeln();
    end;
  writeln('пока!');
end.

19) Пользователь передает целое положительное число N, выведете на экран последовательность из единиц в количестве N "ёлочкой", например для N=18:

1
1 1
1 1 1
1 1 1 1
1 1 1 1 1
1 1 1

ПРИМЕЧАНИЕ: эту задачу можно решить, как вложенными циклами, так и вообще одним циклом (что более изящно). Решите указанными двумя способами.

1) С вложенными циклами:

var n, i, j, c : integer;
begin
  writeln('введите целое положительное число');
  readln(n);
  
  if n <= 0 then
  begin
    writeln('ошибка!');
  end
  else
  begin
    c := 1;
    i := 0;
    while i < n do
    begin
      for j := 1 to c do
      begin
        if i < n then
        begin
          write('1');
          i := i + 1;
        end;
      end;
      writeln();
      c := c + 1;
    end;
  end;
  writeln('пока!');
end.

2) с 1 циклом:

var n, i, j, c : integer;
begin
  writeln('введите целое положительное число');
  readln(n);
  
  if n <= 0 then
  begin
    writeln('ошибка!');
  end
  else
  begin
    c := 1;
    j := 0;
    i := 0;
    while i < n do
    begin
      write('1');
      i := i + 1;
      j := j + 1;
      if c = j then
      begin
        writeln();
        c := c + 1;
        j := 0;
      end;
    end;
  end;
  writeln('пока!');
end.

20) Пользователь передает целое положительное число N, выведете на экран последовательность от 1 до N "ёлочкой", например для N=18:

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

ПРИМЕЧАНИЕ: эту задачу можно решить, как вложенными циклами, так и вообще одним циклом (что более изящно).
Решите указанными двумя способами.

1) с вложенными циклами:

var n, i, j, r : integer;
begin
  writeln('Введите целое положительное число');
  readln(n);
  
  if n <= 0 then
  begin
    writeln('ошибка!');
  end
  else
  begin
    i := 1; //первое число
    j := 1; //длина первой строки
    while i <= n do
    begin
      r := 0; //счетчик чисел в текущей строке
      while (r < j) and (i <= n) do
      begin
        write(i, ' ');
        i := i + 1;
        r := r + 1;
      end;
      writeln();
      j := j + 1;
    end;
    writeln('пока!');
  end;
end.

2) с 1 циклом:

var n, i, j, r : integer;
begin
  writeln('Введите целое положительное число');
  readln(n);
  
  if n <= 0 then
  begin
    writeln('ошибка!');
  end
  else
  begin
    i := 1;
    j := 1;
    r := 0;
    while i <= n do
    begin
      write(i, ' ');
      i := i + 1;
      r := r + 1;
      
      if r = j then
      begin
        writeln();
        j := j + 1;
        r := 0;
      end;
    end;
    writeln();
  end;
  writeln('пока!');
end.

21) Модифицируйте предыдущий вывод "ёлочкой" так, чтобы в каждой нечетной (относительно исходного варианта, где мы выводим все числа) строке выводились только четные числа, а в каждой четной только нечетные, например для N=17:

3
4 6
7 9
12 14
17

var n, i, j, r, f: integer;
begin
  writeln('введите целое положительное число');
  readln(n);
  
  if n <= 0 then
  begin
    writeln('ошибка!');
  end
  else
  begin
    i := 1; //первое число
    j := 1; //длина первой строки
    f := 1; //номер текущей строки

    while i <= n do
    begin
      r := 0; //счетчик чисел в текущей строке
      while (r < j) and (i <= n) do
      begin
        if f mod 2 = 1 then
        begin
          if i mod 2 = 1 then
          begin
            write(i, ' ');
            r := r + 1;
          end;
        end
        else
        begin
          if i mod 2 = 0 then
          begin
            write(i, ' ');
            r := r + 1;
          end;
        end;
        i := i + 1; 
      end;
      writeln(); 
      j := j + 1;
      f := f + 1; 
    end;
  end;
  writeln('пока!');
end.

22) Пользователь передает целые положительные число N и M, выведете на экран последовательность от 1 до N, так чтобы ширина "ёлочки" увеличивалась до M чисел, то уменьшалась до 1. Например, для M=3 и N=19 получим:
1
2 3
4 5 6 - максимум 3 числа
7 8
9
10 11
12 13 14 - снова 3 числа
15 16
17
18 19.....

var n, m, i, j, d, r : integer;
begin
  writeln('Введите целое положительное число');
  readln(n);
  writeln('Введите целое положительное число');
  readln(m);
  
  if (n <= 0) or (m <= 0) then
  begin
    writeln('ошибка!');
  end
  else
  begin
    i := 1; //первое число
    j := 1; //начальная длина строки
    d := 1; //направление изменения ширины
    while i <= n do
    begin
      r := 0; //счетчик чисел в текущей строке
      while (r < j) and (i <= n) do
      begin
        write(i, ' ');
        i := i + 1;
        r := r + 1;
      end;
      writeln();
      if d = 1 then
      begin
        if j < m then
          j := j + 1
        else
          d := - 1;
      end
      else
      begin
        if j > 1 then
          j := j - 1
        else
          d := 1;
      end;
    end;
    writeln('пока!');
  end;
end.

23) Пользователь передает целое положительное число N, выведете на экран последовательность от 1 до N, так чтобы ширина "ёлочки" росла волнами.
Например, для N=49 получим:
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
33 34 35 36
37 38 39 40 41
42 43 44 45
46 47 48
49

var n, i, j, d, r, m : integer;
begin
  writeln('Введите целое положительное число');
  readln(n);
  
  if n <= 0 then
  begin
    writeln('ошибка!');
  end
  else
  begin
    i := 1; //первое число
    j := 1; //начальная длина строки
    d := 1; //направление изменения ширины
    m := 1; //макс. ширина текущей волны
    while i <= n do
    begin
      r := 0; //счетчик чисел в текущей строке
      while (r < j) and (i <= n) do
      begin
        write(i, ' ');
        i := i + 1;
        r := r + 1;
      end;
      writeln();
      if d = 1 then
      begin
        if j < m then
          j := j + 1
        else 
        begin
          d := -1;
        end;
      end
      else
      begin
        if j > 1 then
          j := j - 1
        else
        begin
          d := 1;
          m := m + 1;
        end;
      end;
    end;
    writeln('пока!');
  end;
end.