Как сделать отрицательные числа в массиве

Добавил пользователь Дмитрий К.
Обновлено: 04.10.2024

Я хотел бы знать, как создать массив, подобный следующему, с for loop (обратите внимание, что принятый ответ включает 0, хотя он не был частью моих требований. Наверное, мне стоит поразмышлять над этим и перестать игнорировать комментарии людей).

Моя попытка не может напечатать отрицательные числа в массиве.

Мне также не нужны отрицательные числа индексов в массиве.

В этой программе я разбираю входные данные на целые числа и, похоже, не могу взять отрицательные числа и перепробовал кучу регулярных выражений. Я могу получить положительные целые числа без проблем, удалив &&^-, это просто отрицательные целые числа, с которыми у меня проблемы. Пример.

Если вы нажимаете на массив, вам не нужно указывать индекс:

Если вам нужно пропустить 0:

Попробуйте вот так:

Индексы в массиве всегда начинаются с 0 и не могут быть отрицательными, поэтому, если вам нужны отрицательные значения при положительных индексах, необходимо выполнить некоторые вычисления или преобразование значений.

Тема программирование одномерных массивов, так же достаточно обширна с точки зрения количества и выбора задач. Эту тему можно разделить на несколько блоков, которые тесно связаны между собой. В своей работе я приведу в качестве примера только три, на мой взгляд самых основных блока из этой темы:
1. Заполнение и обработка элементов массива.
2. Нахождение суммы и произведения элементов массива.
3. Нахождение наибольшего и наименьшего элемента в массиве

Заполнение и обработка элементов массива


В задачах этого уровня предлагается конкретный способ заполнения (с клавиатуры, случайными числами, или при помощи прогрессии). Такая программа чаще всего представляет последовательное соединение двух или трех циклов:
заполнение=>вывод,
заполнение =>обработка=>вывод,
заполнение=>(обработка + вывод).
Усложнение задания идет за счет усложнения алгоритмической части.
К первой группе заданий я отношу задачи, когда требуется заполнить массив одним из предложенных способов обработать все элементы массива и вывести их на экран в строку или столбик.
Задание А. Заполнить массив целыми положительными и отрицательными числами из интервала [-10, 10] и вывести его в строчку. Поменять знаки элементов массива на противоположные и повторно вывести массив на экран в строчку.
Program n1;
Uses Crt;
var a:array[1..10] of integer;
i:integer;
begin
ClrScr;
For i:=1 to 10 do begin
a[i]:=Random(20)-10;
write (a[i]:10);
end;
Writeln;
For i:=1 to 10 do begin
a[i]:=-a[i];
write(a[i]:10);
end;
end.
Во второй группе задач в цикл обработки добавляется условие. Требуется составить программу обрабатывающую не все элементы массива подряд, а согласно поставленного условия.
Задание В Заполнить массив из 10 элементов с клавиатуры целыми положительными и отрицательными числами и вывести на экран в строчку только отрицательные числа.
Program n2;
Uses Crt;
var a:array[1..10] of integer;
i:integer;
begin
ClrScr;
For i:=1 to 10 do begin
Write('ВВеди ',i,'-е число');
Readln(a[i]);
end;
For i:=1 to 10 do
if (a[i]

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

Задание С. Дан массив из 10 целых, положительных не повторяющихся чисел. Проверить образуют ли его элементы арифметическую прогрессию. Если образуют, то вывести разность прогрессии.
Program n3;
Uses Crt;
var a:array[1..10] of integer;
i,r,f:integer;
begin
ClrScr;
For i:=1 to 10 do begin
Write('ВВеди ',i,'-е число');
Readln(a[i]);
end;
r:= a[2]-a[1];
f:=1;
For i:=1 to 9 do if (a[i+1]-a[i]<>r) then f:=0;
If (f=0) then Writeln('Не арифметическая прогрессия');
If (f=1) then Begin
Writeln('Арифметическая прогрессия');
Writeln('Разность = ',r:8);
End;
end.




В подобных задачах условие, как правило, находится как внутри цикла обработки, так и после него. Переменную f которая хранит 1 если это арифметическая прогрессия и 0 если это не арифметическая прогрессия можно сделать типа Boolean. Но это потребует от ученика дополнительных знаний, но программа получится красивее. Изменение сложности алгоритма также можно просмотреть на блок-схемах:


Нахождение суммы и произведения элементов массива

Следующим шагом при рассмотрении темы одномерные массивы идет изучение алгоритмов нахождения суммы и произведения элементов массива.
К задачам первой группы можно отнести задачи на нахождение суммы всех элементов массива. Задача может состоять как из одного, так и из двух циклов. Задача может решаться как в один так и в два прохода по массиву.
Задание А. Дан массив из 40 случайных чисел из интервала [-10; 10]. Вывести его в строку и найти



Program n4;
Uses Crt;
var a:array[1..40] of real;
s:real;
i:integer;
begin
ClrScr;
For i:=1 to 40 do begin
a[i]:=Random(20)-10;
write (a[i]:10:5);
end;
Writeln;
S:=0;
For i:=1 to 40 do S:=S+sin(a[i]);
writeln ('S=',S:10:5);
end.
Эту формулировку задачи я подсмотрел в методичке для студентов одного из Ивановских ВУЗов. Эти задачи решаются по одному образцу и требуют внести лишь небольшие изменения.
К задачам второй группы можно отнести задачи на нахождение суммы элементов массива удовлетворяющих условию. В этих задачах требуется заполнить массив указанным способом и организовать цикл с вложенным условием для нахождения суммы элементов массива. Эту задачу также можно решить в один цикл. Когда идет заполнение и в этом же цикле проверяется, соответствует ли этот элемент условию.
Задание В. Заполнить массив из 10 целых чисел с клавиатуры положительными и отрицательными числами. Найти сумму положительных элементов массива.
Program n5;
Uses Crt;
var a:array[1..10] of integer;
s,i:integer;
begin
ClrScr;
For i:=1 to 10 do begin
Write('ВВеди ',i,'-е число');
Readln(a[i]);
end;
S:=0;
For i:=1 to 10 do if (a[i]>0) then S:=S+ a[i];
writeln ('S=',S:8);
end.
В заданиях группы С, я включаю задачи когда найденную сумму необходимо с чем ни будь сравнить. Требуется организовать еще один цикл, в который необходимо вставить условие.
Задание С. Дан массив из 15 целых чисел заполненный случайными числами из интервала [0; 20]. Выведите этот массив в строку и найдите количество четных элементов массива, которые меньше среднего арифметического его элементов.
Program n6;
Uses Crt;
var a:array[1..15] of integer;
s:real;
i,k:integer;
begin
ClrScr;
s:=0;
For i:=1 to 15 do begin
a[i]:=Random(20);
write (a[i]:10);
S:=S+a[i];
end;
Writeln;
s:=s/15;
Writeln('Среднее арифметическое = ',s:10:5);
k:=0;
For i:=1 to 15 do if (a[i] Mod 2 = 0) and (a[i]


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


Нахождение наибольшего (наименьшего) элемента в массиве

Задачи на нахождение наибольшего или наименьшего элемента тоже отличаются усложнением алгоритма. К первой группе задач можно отнести задачи на нахождение наибольшего или наименьшего элемента не во всем массиве, а на определенном интервале. Требуется заполнить массив и правильно изменить параметры в стандартном алгоритме поиска. Эту задачу невозможно решить, если не понимаешь, как работает алгоритм поиска. Разобравшись в нем, ученику не составит труда решить подобную задачу.
Задание А. Дан массив из 20 элементов заполненный случайными целыми числами из интервала [-10, 10]. Выведите этот массив в строку и найдите наибольший элемент лежащий между 5 и 15 элементами данного массива.
Program n7;
Uses Crt;
var a:array[1..20] of integer;
i,max:integer;
begin
ClrScr;
For i:=1 to 20 do begin
a[i]:=Random(20)-10;
write (a[i]:10);
end;
Writeln;
max:=a[5];
for i:=6 to 15 do if (a[i]>max) then max:=a[i];
writeln('Максимальное число из интервала =',max:8);
end.
В эти задачи можно добавлять вопрос поиска номера максимального или минимального элемента. Это лишь немного усложнит алгоритм.
Ко второй группе задач я отношу задачи, где не просто нужно найти максимальное или минимальное число, а что ни будь при помощи найденного числа еще проверить. В данных задачах необходимо добавить еще один цикл в котором найденный элемент с чем ни будь сравнивается. Получается, что к уже изученным алгоритмам поиска и обработки массива, необходимо добавить алгоритм нахождения максимального или минимального элемента.
Задание В. Дан массив из 20 элементов заполненный случайными целыми числами из интервала [-10, 10]. Выведите этот массив в строку и найдите сколько раз в данном массиве встречается максимальный по величине элемент.
Program n8;
Uses Crt;
var a:array[1..20] of integer;
i,max,k:integer;
begin
ClrScr;
For i:=1 to 20 do begin
a[i]:=Random(20)-10;
write (a[i]:10);
end;
Writeln;
max:=a[1];
for i:=2 to 20 do if (a[i]>max) then max:=a[i];
k:=0;
for i:=1 to 20 do if (a[i]=max) then k:=K+1;
writeln('Максимальное число из интервала =',max:8);
writeln('Оно встречается =',k:8,' раз');
end.
В заданиях С нужно найти максимальный элемент и произвести замену или другие изменения в массиве и повторно вывести массив на экран.
Задание С. Дан массив из 10 целых положительных чисел, заполненный с клавиатуры. Найти максимальный и минимальный элемент в массиве и поменять их местами.
Program n9;
Uses Crt;
var a:array[1..10] of integer;
i,min,max,n1,n2,t:integer;
begin
ClrScr;
For i:=1 to 10 do begin
Write('ВВеди ',i,'-е число');
Readln(a[i]);
end;
min:=a[1];n1:=1;
max:=a[1];n2:=1;
for i:=1 to 10 do begin
if (a[i]>max) then begin
max:=a[i]; n2:=i;
end;
if (a[i]
В этой задаче ученику необходимо в одном цикле организовать поиск максимального и минимального элемента и номеров, под которыми они стоят. Затем, используя эти номера через вспомогательную переменную обменять максимальное и минимальное значение местами и повторно вывести массив на экран.

Организация массива

Память под массив может выделяться автоматически или динамически.

Автоматическое выделение памяти используют, когда размер массива известен на этапе компиляции (т. е. при написании кода).

Динамическое выделение памяти используют, когда размер массива неизвестен на этапе компиляции (допустим, запрашивается у пользователя).

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

Глобальные автоматические массивы в плане переполнения стека безопасны. Но они будут видны во всём коде, лексикографически расположенному после объявления массивов, что может спровоцировать их использование напрямую, минуя их передачу в функции через параметры. Это приведёт к возникновению побочных эффектов работы функций, что затрудняет отладку и делает программы менее надёжными. Такого использования глобальных массивов следует избегать.

Использование автоматических массивов

Автоматические массивы используют, когда размер массива известен на этапе компиляции.

Размер массива в коде настоятельно рекомендуется указывать с помощью именованной константы. Это полезно по нескольким соображениям:

  1. имя константы должно указывать на область её применения — самодокументирование кода;
  2. при необходимости изменить в коде размер массива потребуется внести правку только в одном месте;
  3. размер массива, как правило, используется в циклах прохода по массиву, проверки границы и пр., поэтому использование символического имени избавит от необходимости тщательной проверки и правки всего кода при изменении размера массива.

Тип константного выражения для определения размера (количество элементов) автоматического массива должен быть целочисленный: char , int , unsigned int , long , etc.

Память, отведённая под автоматические массивы, освобождается при выходе из области видимости переменной-массива. Для локальных массивов это функция или блок. Глобальные массивы уничтожаются при выходе из программы.

Пример определения глобального автоматического массива длиной 10 элементов типа int :

Пример определения локального автоматического массива длиной 10 элементов типа int :

Использование массивов с динамическим выделением памяти

Массивы с динамическим выделением памяти используют, когда размер массива не известен на этапе компиляции. Реальный размер массива может вычисляться в программе или вводиться пользователем — неважно.

Память для массива выделяется оператором new в форме new тип[количество_элементов] .

Тип выражения, определяющего размер (количество элементов) массива должен быть целочисленным. Также это выражение может быть и константным.

Когда работа с массивом закончена, память, выделенную под массив необходимо освободить. Это делается с помощью оператора delete в форме delete [] имя_переменной . После того, как память освобождена, работать с массивом нельзя.

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

Заполнение массива значениями

При решении учебных задач, обычно предлагается заполнить массив значениями либо введёнными с клавиатуры, либо случайными значениями из определённого диапазона. Начнём со второго случая, как более простого (Парадокс? Нет, правда жизни).

Заполнение массива случайными числами

Для начала необходим генератор случайных чисел. Ниже приведён код одной из простейших реализаций:

Заполнение массива значениями, естественно, делаем в цикле. Помним, что элементы массива в C/C++ нумеруются с 0. Следовательно последний элемент массива имеет индекс на единицу меньший, чем размер массива.

В примере показано заполнение глобального автоматического массива из 10 элементов типа int случайными значения из диапазона от −100 до 100 включительно:

Обратите внимание на включение заголовочных файлов!

Заполнение массива числами, введёнными пользователем

Как ни странно, это более сложный случай. Дело в том, что во-первых, наличие человека всегда может приводить к некорректному вводу данных (ошибкам), во-вторых, для человека необходимо обеспечить какой-никакой интерфейс, а в-третьих, система потокового ввода-вывода STL имеет свои неприятные особенности.

Оно как бы работает, но если вы попытаетесь в качестве числа (конечно случайно!) ввести 1111111111111111111111111111111111 или 11q, то, в зависимости от компилятора, сможете наблюдать некоторые интересные эффекты работы вашей программы.

Поэтому приходится писать более сложный код:

Подробный разбор данного фрагмента выходит за рамки данной статьи. Но интересующиеся могут его разобрать, вооружившись, например, известной книгой Г. Шилдта.

Вывод на консоль значений из массива

Вывод значений массива на консоль реализуется элементарно. В свете уже вышесказанного даже нечего добавить:

Как видно из комментариев, за поиск минимального значения и его индекса отвечает последний фрагмент программы.

Определяются две переменные, одна из которых будет содержать минимальное значение, а вторая — индекс элемента с минимальным значением. Эти переменные инициализируются первым (нулевым) элементом массива и нулём соответственно. Далее, в цикле каждое следующее значение элемента массива сравнивается с уже найденным наименьшим значением и, если текущее значение меньше запомненного, то запоминается текущее значение и его индекс.

Поиск определённого значения в массиве

Поиск определённого значения в неупорядоченном массиве осуществляется с помощью алгоритма линейного поиска. Этот простейший алгоритм заключается в последовательном переборе элементов массива и сравнением их с искомым значением.

Задачи на поиск в массиве могут быть в двух формах:

  1. найти первое (последнее) вхождение искомого значения
  2. найти все вхождения

Поиск первого вхождения:

Поиск последнего вхождения:

Обратите внимание на следующие моменты.

Переменная цикла i описана перед циклом. Таким образом, эта переменная продолжает существовать после окончания цикла, и её значение может быть использовано.

Если искомый элемент найден, то цикл завершается досрочно оператором break : просматривать остальную часть массива не имеет смысла — задача уже выполнена.

Во втором случае переменная i имеет знаковый тип int . Отрицательное значение используется в качестве флага, что весь массив просмотрен, и значение не найдено.

Поиск всех вхождений:

Здесь цикл не прерывается. Массив просматривается полностью.

Сумма/произведение отрицательных элементов массива

Сумма элементов массива с чётными/нечётными индексами

Работа с массивами с применением функций

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

Обратите внимание, что выделение памяти под массив и её освобождение происходит в одной функции (в данном случае, в main() ). Выделять память в одной функции, а освобождать в другой — плохая идея, чреватая ошибками.

Заключение

В этой статье рассмотрены только самые элементарные приёмы работы с массивами, которые помогут (надеюсь!) начинающему кодеру понять принципы работы с массивами.

Рассматриваются такие вопросы, как заполнение массива, вывод массива на экран, поиск по условию, создание нового массива.

Почему вдруг я захотел написать эту статью? А потому что 80% всех часто задаваемых вопросов по алгоритмам связано с массивами. Ну например, как вывести на экран все отрицательные числа массива? Или найти третий нулевой элемент массива. А ещё заменить первый чётный элемент последним нечётным. Таких задач бесконечное множество, однако методы их решения стандартны. Программирование давно превратилось из искусства в ремесло. Потому и надо искать знакомые методы, а не изобретать велосипед. Ну вот, вроде с введением всё.

Для начала вспомним, что есть одномерный массив. Массивы представляют собой ограниченную упорядоченную совокупность однотипных величин. Каждая отдельная величина называется элементом массива. Тип элементов может быть любым, принятым в языке ПАСКАЛЬ, кроме файлового типа. Тип элемента называется базовым типом. Вся совокупность элементов определяется одним именем. Для обозначения отдельных элементов используется конструкция, называемая переменной с индексом или с индексами:

В качестве индекса может быть использовано выражение. Тип индексов может быть только интервальным или перечисляемым. Действительный и целый типы недопустимы. Индексы интервального типа, для которого базовым является целый тип, могут принимать отрицательные, нулевое и положительные значения.

Ниже я попытаюсь изобразить собственное представление одномерного массива. Вот он какой. Предположим, что массив уже заполнен (потом объясню, как это сделать). Проще говоря, это всего лишь набор ящиков A , в которых хранятся значения.

У каждого ящика есть свой номер (индекс i ). В каждом ящике хранится некоторое значение (элемент A[i] ). Тогда для массива, изображённого на рисунке, справедливо следующее:

Так что одномерный массив - это самый простой тип данных сложной структуры.

Попробуем теперь обратиться к некоторым элементам массива. Например выведем на экран третий элемент. Его переменная будет выглядеть A[3] .

Первый способ более универсален, поскольку i - индекс элемента - может изменяться где-то в другом месте программы. Во втором случае мы печатаем строго третий элемент, что и требовалось. В третьем случае мы вводим новую переменную z , равную A[3] , чтобы в других местах программы ещё несколько раз обращаться к A[3] через z .

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

Обычно задачи про одномерные массивы начинаются со слов "заполните массив. " или "дан одномерный массив. " - всё это предполагает то, что массив был ранее создан и заполнен.

Теперь нам ясно, что присвоить элементу массива значение можно следующим образом:

Но если этих элементов десять или десять тысяч? Тогда на помощь приходит оператор цикла For-to-do . Приведу такой сэмпл:

Получим в каждом элементе массива число в два раза большее, чем его индекс. Это значит, что в первым элементом будет 2, а вторым - 20000. Конечно, вместо выражения i*2 можно использовать любые математические формулы. Тогда каждый раз массив будет заполняться по функциональной зависимости, где индекс - это аргумент функции ( i ), а сам элемент - значение функции ( A[i] ). Посмотрим массив значений функции y=x 2 на промежутке [1; 20].

Здесь видно, что в программе y[x]:=sqr(x) - это тоже самое, что и математическое выражение y(x)=x 2 . А задание к этой программке будет звучать примерно так: "Заполнить массив y квадратами чисел от 1 до 20".

Но если задании сказано, что массив следует заполнить с клавиатуры? В основе заполнения массивов, как мы выяснили, лежит простое присваивание. Ну а там, где присваивание, есть и ввод с клавиатуры. Вспомним как это делается для обычных переменных:

Теперь программа ожидает, пока мы наберём на клаве число и нажмём Enter. Всё! Наше число хранится в переменной x . Прикидываем, что элемент массива - это та же переменная, только с индексом:

В зависимости от индекса i введённое пользователем число запишется в массиве A по номеру i . Вспомним, как мы присваивали значения элементов в цикле:

Программа запрашиват числа одно за другим, пока мы не введём 20 чисел. И все они по окончании цикла будут находиться в массиве A по тем номерам и в том порядке, как мы их вводили. Параллельно с вводом с клавиатуры можно выводить на экран номер вводимого элемента, чтобы пользователь не запутался:

Тогда на экране сначала покажется надпись A[1]= и рядом курсор ввода. Ну вот, теперь мы можем заполнять массивы с клавиатуры!

Здесь всё остаётся также, как если бы мы заполняли массив по функции, но в данном примере функция Random() каждый раз не определена и генерируется случайно.

Тогда мы получим массив, заполненный разными числами от 0 до 99 благодаря функции Random . Если умело использовать её, то можно заполнить массив не только от 0 до 99, но и от -100 до 100. Для этого сгенерируем случайное число Random(201) (это будет от 0 до 200) и отнимем 100. Тогда, если получится 0, отнимается 100 и получаем
-100. Если генерируется 200, опять отнимается 100 и получаем 100. Тут в общем-то всё просто, если в школе учили алгебру и знаете определение "область принимаемых значений".

Теперь мы умеем заполнять массив тремя способами. Этого хватит для решения задач любой сложности. Ведь главное в программе - это исходные данные, полученные извне.

Эту операцию, как и заполнение, тоже можно выполнить несколькими способами. Это может быть вывод элементов в столбец, в строку (один за другим) или используя форматный вывод. В задачах пишут примерно так: "вывести массив на экран", "напечатать элементы массива в строку", "вывести на экран элементы массива спосбом форматированного вывода". Как мы знаем, вывод на экран осуществляется оператором Writeln () . Если вы об этом слышите впервые, то можете выключить компьютер и идти спать :).

Итак, вывод на экран значения элемента массива - это очень просто:

Главное помнить, что в случае с WriteLn добавляется перевод строки и следующий вывод печатается на новой строке. С Write весь вывод идёт в одну строку без пробелов! Потому-то пробел и добавляют "искуственно" с помощью Write (' ') .

Теперь же рассмотрим, как элементы массива можно вывести в цикле. Это аналогично алгоритму заполнения с клавиатуры, только мы не вводим, а выводим значения. Следующий сэмпл демонстрирует самый простой вывод массива в столбец (обратите внимание на WriteLn , который переводит строку):

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

Или так, что проще:

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

Для начала следует вспомнить, что условие выражается с помощью оператора If . Потом надо сесть и хорошо подумать - какое условие следует вычислить? Рассмотрим простейшее условие вывода на экран.

Допустим задание звучит так: "вывести на экран элементы, равные нулю". Это очень просто. Для каждого элемента массива в цикле вычисляется следующее условие:

Условие читается так: "Если элемент A[i] равен нулю, то выводим на экран значение A[i] ". Итак, сэмпл программы, который выводит на экран нулевые элементы, будет выглядеть так:

Допустим нам необходимо не только вывести на экран нулевые элементы, но и подсчитать их количество. Как это сделать? Это делается с помощью такого же условия, но для подсчёта мы вводим новую переменную. Пусть это будет переменная целого типа z:integer . Тогда каждый раз при выполнении условия к ней будет прибавляться единица. В этом и заключается принцип счётчика.

Как только очередной элемент равен нулю, он выводится на экран оператором WriteLn , после чего к счётчику z прибавляется 1.

Иногда в задании указывается, что из определённых элементов массива нужно составить новый массив. Пусть это будет массив B[20] .

Прежде, чем приступить к написанию программы, посмотрим как это можно сделать вручную. Чтобы заполнять поочерёдно все элементы массива B при перечислении массива A , необходимо установить счётчик индекса для массива B (пусть это будет n:=1 ). Когда будет обнаружен первый ноль, он будет записан в B[n] , после чего n:=n+1 . Следующий ноль будет записан в B[2] и так далее.

  1. Вначале n:=1 .
  2. Берём i:=1 элемент массива A .
  3. Сравниваем его с нулём.
  4. Если он равен нулю, то присваиваем его B[n] .
  5. Увеличиваем n на единицу.
  6. Цикл повторяется.

Теперь, когда алгоритм ясен, составим сэмпл. Вообще, в этой программе z и n равны, так как они обе показывают число нулей.

Кстати, вместо конструкции n:=n+1 можно использовать стандартную функцию инкремента (приращения переменной) inc(n) . Вместо кнструкции n:=n+x можно применить inc(n,x) .

От начала до конца я рассматривал такую задачу:

Дан массив целых чисел A , состоящий из 20 элементов. Определить число нулевых элементов и записать их в массив B .

Составим на основе предыдущих сэмплов цельную работающую программу. Вообще, в этой программе z и n равны, так как они обе показывают число нулей. Потому оставляю только n .

For i:=1 to 20 do
begin
Write ('A[',i,']=');
ReadLn (A[i]);
end;

For i:=1 to 20 do
If A[i]:=0 then
begin
WriteLn (A[i]);
n:=n+1;
B[n]:=A[i];
end;

WriteLn ('В массиве найдено ',n,'нулей.');
ReadKey;

Читайте также: