Once a month Newsletter

* We will keep your email in safe place and will never misuse it. Unsubscribe in one click.

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

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

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

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

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

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.

**type** word;: Представляет 16-битовое целое число без знака.Диапазон значений: 0 .. 65 535 **type** byte;: Представляет 8-битовое целое число без знака.Диапазон значений: 0..255 Array2. Дано целое число N(> 0). Сформировать и вывести целочисленный массив размера N, содержащий степени двойки от первой до N-й: 2, 4, 8, 16, … .

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

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.

**type** word;: Представляет 16-битовое целое число без знака.Диапазон значений: 0 .. 65 535 **type** byte;: Представляет 8-битовое целое число без знака.Диапазон значений: 0..255 Array3. Дано целое число N(> 1), а также первый член A и разность D арифметической прогрессии. Сформировать и вывести массив размера N, содержащий N первых членов данной прогрессии:

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

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

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

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

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

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

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.

**type** integer;: Представляет 32-битовое целое число со знаком.Диапазон значений: -2 147 483 648 .. 2 147 483 647 **type** integer;: Представляет 32-битовое целое число со знаком.Диапазон значений: -2 147 483 648 .. 2 147 483 647 **type** byte;: Представляет 8-битовое целое число без знака.Диапазон значений: 0..255 Array4. Дано целое число N (> 1), а также первый член A и знаменатель D геометрической прогрессии. Сформировать и вывести массив размера N, содержащий N первых членов данной прогрессии:

A, A·D, A·D², A·D³, ...

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

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

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

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

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

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.

**type** integer;: Представляет 32-битовое целое число со знаком.Диапазон значений: -2 147 483 648 .. 2 147 483 647 **type** integer;: Представляет 32-битовое целое число со знаком.Диапазон значений: -2 147 483 648 .. 2 147 483 647 **type** byte;: Представляет 8-битовое целое число без знака.Диапазон значений: 0..255 Array5. Дано целое число N (> 2). Сформировать и вывести целочисленный массив размера N, содержащий N первых элементов последовательности чисел Фибоначчи F_k:

F₁ = 1, F₂ = 1, F_k = F_k−2 + F_k−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 ...

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

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.

**type** integer;: Представляет 32-битовое целое число со знаком.Диапазон значений: -2 147 483 648 .. 2 147 483 647 **type** byte;: Представляет 8-битовое целое число без знака.Диапазон значений: 0..255 Сравните Array5 с задачами For33, While24, Proc36. Кроме того, на странице Последовательность Фибоначчи (которую позже я перепишу) вы можете онлайн посчитать до 78 первых членов Фибоначчи.

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

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

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

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.

**type** integer;: Представляет 32-битовое целое число со знаком.Диапазон значений: -2 147 483 648 .. 2 147 483 647 **type** integer;: Представляет 32-битовое целое число со знаком.Диапазон значений: -2 147 483 648 .. 2 147 483 647 **type** byte;: Представляет 8-битовое целое число без знака.Диапазон значений: 0..255 Не забывайте комментировать и спрашивать. За найденные ошибки буду признателен.