Арифметическая и геометрическая прогрессии. Последовательность Фибоначчи

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

var
  A: array[1..20] of word; { <== Массив размера 20 }
  N, i: byte;

begin
  write('N = '); 
  readln(N); { <-- Вводим количество элементов массива }
  { ФОРМИРУЕМ ЭЛЕМЕНТЫ МАССИВА: }
  a[1] := 1; { <-- Минимальное нечетное число }
  { Далее учитываем, что каждое следующее нечетное число 
  (начиная со второго) на 2 больше предыдущего: }
  for i := 2 to N do 
    a[i] := a[i - 1] + 2; { <-- Вычисляем i-й нечетный элемент }
  { ВЫВОДИМ ЭЛЕМЕНТЫ МАССИВА: }
  writeln(' Массив из первых ', N, ' нечетных чисел: ');
  for i := 1 to N do
    write(' ', a[i]);
  readln
end.

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

var
  A: array[1..15] of word;
  N, i: byte;

begin
  write('N = ');
  readln(N); { <-- Вводим количество элементов массива }
  { ФОРМИРОВАНИЕ ЭЛЕМЕНТОВ: }
  a[1] := 2; { <-- Первый элемент массива (2 в 1-й степени) } 
  { Поскольку в нашем массиве будут храниться последовательные степени
  двойки, то каждый следующий элемент будет в 2 раза больше предыдущего: }
  for i := 2 to N do
     a[i] := a[i - 1] * 2; { <-- i-я степень числа 2 }
  { ВЫВОД ЭЛЕМЕНТОВ МАССИВА: }
  writeln('Первые ', N, ' степеней двойки: ');
  for i := 1 to N do
    write(' ', a[i]);
  readln
end.

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
  M: array[1..100] of integer;
  A, D: integer;
  N, i: byte;

begin
  { ВВОДИМ ДАННЫЕ: }
  write('N = ');
  readln(N); { <-- количество членов арифметической прогрессии }
  write('A = ');
  readln(A); { <-- первый член }
  write('D = ');
  readln(D); { <-- разница арифметической прогрессии }  
  { ФОРМИРОВАНИЕ ЭЛЕМЕНТОВ МАССИВА: }
  m[1] := A; { <-- Инициализируем первый член арифметической прогрессии }
  { Каждый член арифметической прогрессии (начиная со второго) на D
  больше предыдущего. Выводим все остальные элементы массива: }
  for i := 2 to N do
    m[i] := m[i - 1] + D; { <-- Вычисляем i-й элемент массива (прогрессии) }
  { ВЫВОД ЭЛЕМЕНТОВ МАССИВА: }
  writeln('Первые ', N, ' членов арифметической прогрессии');
  writeln('с первым членом ', A, ' и разницей ', D, ':');
  for i := 1 to N do
    write(m[i], ' '); { <-- Выводим элементы через пробел }
  readln
end.

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
  M: array[120] of integer;
  A, D: integer;
  N, i: byte;

begin
  { ВВОД ДАННЫХ: }
  write('Количество членов геомертической прогрессии (1..20): ');
  readln(N);
  write('Первый член геометрической прогрессии: ');
  readln(A);
  write('Знаменатель геометрической прогрессии: ');
  readln(D);
  { ФОРМИРОВАНИЕ ЭЛЕМЕНТОВ МАССИВА: }
  m[1] := A; { <-- Первый член геометрической прогрессии }
  { Каждый член геометрической прогрессии, начиная 
  со второго, в D раз больше предыдущего: }
  for i := 2 to N do
     m[i] := m[i - 1] * D; { <-- Вычисляем i-й член прогрессии }
  { ВЫВОД ЭЛЕМЕНТОВ МАССИВА: }
  writeln;
  writeln(N, ' первых членов геометрической прогрессии:');
  for i := 1 to N do
    write(m[i], ' '); { <-- Вывод N членов прогрессии }
  readln
end.

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

var
  F: Array[1..20] of integer;
  N, K: byte;

begin
  writeln('Введите N: ');
  readln(N);
  { ФОРМИРОВАНИЕ: }
  F[1] := 1; F[2] := 1; { <-- Первые 2 члена последовательности }
  for K := 3 to N do begin
    { Вычисляем элементы последовательности 
    Фибоначчи с помощью рекурентного соотношения: }
    F[K] := F[K - 1] + F[K - 2]
  end;
  { ВЫВОД НА ЭКРАН: }
  writeln(N, ' первых членов последовательности Фибоначчи:');
  for K := 1 to N do
    writeln('F[', K, '] = ', F[K]);
  readln
end.

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  

var
  M: array[1..10] of integer;
  A, B, S: integer;
  N, i: byte;

begin
  write('N = '); 
  readln(N);
  writeln('Введите начальные значения A и B:');
  readln(A, B);
  { ФОРМИРОВАНИЕ: }
  m[1] := A; m[2] := B; { <-- Первые два элемента массива }
  S := m[1]; { <-- Сумма стоящих перед вторым элементом равна 1-му элементу }
  for i := 3 to N do
  begin
    { Чтобы найти каждый следующий член данной последовательности, необходимо 
    к предыдущему элементу прибавить сумму стоящих перед ним элементов: }
    m[i] := m[i - 1] + S; { <-- i-й элемент массива }
    S := m[i] { <-- Запоминаем сумму всех элементов }
  end;
  writeln;
  { ВЫВОД ЭЛЕМЕНТОВ: }
  writeln('Результат:');
  for i := 1 to N do
    write(' ', m[i]);
  readln
end.