ВВЕРХ
ВНИЗ
  • Home
  • Array
  • Array 1 - 6

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

Array1. Дано целое число N(> 0). Сформировать и вывести целочисленный массив размера N, содержащий N первых положительных нечетных чисел:  1, 3, 5, … .

Можно было бы воспользоваться простой формулой для i-го нечетного числа: ai=2·i-1. Но умножение в этом случае разумно было бы заменить сложением: поскольку все нечетные соседние числа отличаются на 2, то чтобы найти каждое последующее нечетное число, будем прибавлять к предыдущему 2.

Вообще, где только можно, умножение следует заменять на сложение, поскольку для компъютера "легче" суммировать, чем умножать. В маленьких программах это не заметно, а в ресурсоёмких, например, в анимации или построении графиков, не всегда надо решать задачу "в лоб", а искать алгоритмы.

Вот какой код получился (используем цикл с параметром for):

Код Pascal
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.

Array2. Дано целое число N(> 0). Сформировать и вывести целочисленный массив размера N, содержащий степени двойки от первой до N-й:  2, 4, 8, 16, … .

Пусть an содержит n-ю степень двойки. Тогда a1=2, а для всех остальных (n>1) an=2·an-1. Как и выше, будем использовать цикл с параметром for:

Код Pascal
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.

Array3. Дано целое число N(> 1), а также первый член A и разность D арифметической прогрессии. Сформировать и вывести массив размера N, содержащий N первых членов данной прогрессии:

A,   A + D,   A + 2·D,   A + 3·D, … .

Арифметическая прогрессия — один из простейших типов последовательностей, изучается в школьной программе. Дадим определение:

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

Как видно из определения, в задании Array1 тоже рассматривалась арифметическая прогрессия (последовательность нечетных чисел) с первым членом 1 и разницей 2. Пусть a1 — первый член, d — разница арифметической прогрессии. Чтобы получить её n-й член, можно воспользоваться известной ещё со школьной скамьи формулой:

Формула n-го члена арифметической прогрессии в Pascal

Но как было сказано выше (в задании Array1), всегда, по возможности, умножение будем заменять на сложение.

Код 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
  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.

Array4. Дано целое число N (> 1), а также первый член A и знаменатель D геометрической прогрессии. Сформировать и вывести массив размера N, содержащий N первых членов данной прогрессии:

A,    A·D,    A·D2,    A·D3, ...

Другой тип прогрессии — геометрическая.

Геометрическая прогрессияэто последовательность чисел, каждый член которой, начиная со второго, равен предыдущему, умноженному на одно и то же число, называемое знаменателем.

Если b1 — первый член геометрической прогрессии, q — знаменатель, то её n-й член можно посчитать за формулой:

Формула n-го члена геометрической прогрессии в Pascal

Естественно, что было бы не правильно каждый раз возводить в степень знаменатель q — нужно его просто умножать на предыдущее значение последовательности, поскольку для каждого n>1 справедливо равенство: bn=q·bn-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
  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.

Array5. Дано целое число N (> 2). Сформировать и вывести целочисленный массив размера N, содержащий N первых элементов последовательности чисел Фибоначчи Fk:

F1 = 1,    F2 = 1,    Fk = Fk−2 + Fk−1,    K = 3, 4, … .

Дадим определение:

Последовательность Фибоначчиэто ряд чисел, каждый член которой, начиная с третьего, равен сумме двух предыдущих.

Последовательность Фибоначчи — одна из самых изученных. Казалось бы, такое простое определение! Но долгое время не удавалось найти формулу для общего члена этой последовательности. Теперь это выражение широко известно:

Формула n-го члена последовательности Фибоначчи в Pascal

Как правило, первые два члена последовательности равны 1 и 1. Чтобы получить каждое последующее число, необходимо сложить два предыдущих. Ряд Фибоначчи начинается так:

1  1  2  3  5  8  13  21  34  55  89  144  233  377  610  987  1597  2584  4181  6765  10946  17711  28657  46368  75025  121393  196418  317811  514229  832040  1346269  2178309  3524578  5702887  9227465  14930352  24157817  39088169  63245986  102334155 ...

Как видите, он очень быстро растет и следующий код здесь не подходит. Для определения больших чисел необходима длинная арифметика. Как напишу об этом статью, то вставлю сюда ссылку.

Код Pascal
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.

Сравните Array5 с задачами  For33,   While24,   Proc36.  Кроме того, на странице Последовательность Фибоначчи (которую позже я перепишу) вы можете онлайн посчитать до 78 первых членов Фибоначчи.

Array6. Даны целые числа N (> 2), A и B. Сформировать и вывести целочисленный массив размера N, первый элемент которого равен A, второй равен B, а каждый последующий элемент равен сумме всех предыдущих.

Попробуем непостредственно по ословию задания выписать несколько членов последовательности:

1) A — первое число;

2) B — второе число;

3) A+B — третье число;

4) 2·(A+B) — четвертое число;

5) 4·(A+B) — пятое число;

6) 8·(A+B) — шестое число;

7) 16·(A+B) — седьмое число;

8) 32·(A+B) — восьмое число.

Мы видим, что начиная с 3-го числа, члены нашей последовательности кратны A+B с коэффициентами 1, 2, 4, 8, 16, 32, ..., являющиеся, как не трудно заметить, степенями двойки. То есть, каждое последующее число, начиная с 4-го, вдвое больше предыдущего (геометрическая прогрессия). Но мы не будем использовать это свойство, а решим задачу по определению. Все комментарии в коде:

Код 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  
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.

Не забывайте комментировать и спрашивать. За найденные ошибки буду признателен.


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