Заполнение одномерного массива паскаль. Заполнение и обработка массива

Одномерные массивы. Формирование массива и вывод его элементов

Определение понятия

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

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

Вектор (линейный или одномерный массив ) - это пример массива, в котором элементы нумеруются одним индексом.

• В качестве номера (индекса) элемента массива, в общем случае, используется выражение порядкового типа (чаще всего - это целая константа или переменная целого типа: integer , word , byte или shortint )
• При обращении к элементу массива индекс указывается в квадратных скобках. Например, a, mass.
• Обработка элементов массива производится при изменении индексов элементов. Например, в случае использования выражения следующие переменные удобно применять для просмотра в цикле элементов массива:
  • a[i] - всех элементов;
  • a - элементов, стоящих на четных местах;
  • a - элементов, стоящих на нечетных местах

Описание массива

• Определение переменной как массив без предварительного описания типа массива

Примечание

• • Описание массива требуется компилятору для выделения памяти под его элементы.
  • Переменная определяется как массив посредством служебного слова array (массив). В квадратных скобках указывается диапазон, т. е. нижняя и верхняя граница значения индекса массива. Значение верхней границы не может быть меньше нижней.
  • Здесь переменные s и k считаются разных типов. Для обеспечения совместимости необходимо применять описание переменных через предварительное описание типа.
  • Если типы массивов идентичны, то в программе один массив может быть присвоен другому. В этом случае значения всех переменных одного массива будет присвоены соответствующим элементам второго массива.
  • Над массивами не определены операции отношения. Сравнивать два массива можно только поэлементно.
• Предварительное описание типа массива

Примечание

• • Доступ к элементам массива будет осуществляться так: a, a, a, a, a (т. е. массив содержит пять элементов).
  • Употребление констант (в данном примере n) при описании массива предпочтительно, т. к. в случае изменения размеров массива не нужно будет вносить исправления по всему тексту программы.
• Задание массива типизированной константой

Примечание

• • В данном примере не только выделяется память под массив, но и происходит заполнение ячеек данными.
  • Элементы массива можно изменять в ходе программы (как и все типизированные константы).

Заполнение массива данными

§ Для заполнения массива данными (и его вывода) чаще всего используется цикл с параметром for

§ Для заполнения массива случайными числами используется функция random и процедура randomize (инициализации генератора случайных чисел). Формат записи такой: random(B - A) + A , где A и B берутся из интервала :4);

Пример программы на ввод и вывод массива

Постановка задачи. Получить сумму элементов массива, состоящего из 10 целочисленных элементов. Элементы массива вводятся с клавиатуры.

Пример программы работы с элементами массива

Постановка задачи. Получить среднее арифметическое элементов массива. Элементы массива заполняются случайными числами.

Разделы: Информатика

Цели:

1. Познакомить учащихся с возможностью заполнения и обработки массива.
2. Создать графический интерфейс проекта по заполнению массива и подсчета суммы элементов в заданном массиве.
3. Развивать познавательный интерес к предмету
4. Воспитывать ответственное отношение к обучению

ХОД УРОКА

1. Актуализация урока

Организационный момент

Фронтальный опрос по предыдущей теме “Понятие массива. Одномерный массив”

2. Формирование умений и навыков

Объяснение нового материала

Объявление массива

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

A: array of integer;

Основные задачи при работе с массивами

1. Формирование (заполнение) массива

1.1. по формулам For i:=1 to 10 do a[i]:= i*i;

1.2. сгенерировать случайным образом For i:=1 to 10 do a[i]:= random(20):

Встроенная функция RANDOM(MAX), возвращает случайное целое число, равномерно распределенное в диапазоне от 0 до МАХ – 1(МАХ – параметр обращения)

1.3. ввести с клавиатуры For i:=1 to 10 do read(a[i]);

2. Сортировка массива (по возрастанию, по убыванию);

3. Поиск элементов в массиве;

4. Выбор элементов из массива по условию;

Заполнение массива случайным образом.

Для начала работы с массивом его необходимо заполнить, т.е. присвоить элементам массива определенные значения. Для генерации последовательности случайных чисел используем функцию Random(100). При запуске программы данная функция выведет псевдослучайную последовательность целых чисел в интервале от 0 до 100.

Для генерации различающихся между собой последовательностей случайных чисел рекомендуется использовать оператор Randomize

Действия с одномерными массивами

1. Вычисление суммы элементов

For I:= 1 To 10 Do s:=s+ a[i]; (обычное накопление суммы в s)

2. Вычисление произведения

For I:= 1 To 10 Do р:=р* a[i]; (обычное накопление произведения в р)

3. Поиск элемента с заданным значением

3. Прим енение умений и навыков на практике

Проект “Сумма элементов в массиве”. Разработаем проект “Сумма элементов в массиве”, который будет производить заполнение массива случайными числами и вычислять сумму этих чисел

Для начала создадим процедуру заполнения массива

1.Запустить систему программирования Delphi.

2. Работа над проектом начинается с создания графического интерфейса, для этого в окне Конструктор форм на форму помещаются управляющие элементы. Для создания графического интерфейса проекта разместим на форме два текстовых поля для вывода числовых данных (одно – заполнение массива, другое – вывод суммы) и две кнопки для реализации событийных процедур: заполнение массива и сумма

3. С помощью Панели инструментов поместить на форму Forml текстовое поле Editl и командную кнопку Buttonl

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

4. Осуществить двойной щелчок по кнопке Buttonl, появится заготовка событийной процедуры TForml.ButtonlClick: Произвести объявление массива A и описание переменных I, S в разделе описания переменных var

A:array of integer;

procedure TForm1.Button1Click(Sender: TObject);

For I:= 1 To 10 Do

A[I] := Random(10);

Edit1.Text:= Edit1.Text +" " + IntToStr(a[i]);

5. Сохранение проекта (Save Project As)

6. Компиляция проекта (Project - Compile)

Теперь создадим процедуру для вычисления суммы элементов в заполненном массиве

С помощью Панели инструментов п оместим на форму Forml кнопку Button2 и текстовое поле Edit2. Двойной щелчок мышью по кнопке Button2, для которой надо создать программный код, вызывает окно Программный код с пустой заготовкой событийной процедуры.

procedure TForm1.Button2Click(Sender: TObject);

For I:= 1 To 10 Do

Edit2.Text:= Edit2.Text +" " + IntToStr(s)

Сохранение проекта всего проекта (Save Project).

Произведем компиляцию проекта (нажатием клавиши F9).

Щелкнуть по кнопкам Заполнить массив и Сумма.

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

4. Подведение итогов

5. Домашнее задание: Создать проект “Произведение элементов массива”, предусматривающий заполнение массива случайными числами и возможность вывода в текстовое поле произведение всех элементов в массиве.

Одномерный массив – это именованная последовательность, состоящая из пронумерованных элементов одного типа. Элементы могут быть любого имеющегося в Pascal (за исключение файлового) типа данных. Номер, также называемый индексом, имеет каждый элемент массива. Индекс должен быть порядкового типа. Одномерный массив можно объявить как в качестве переменной:

var <имя переменной>: array of <тип элементов>;

так и типа:

type <имя типа> = array of <тип элементов>;

Здесь m – номер первого элемента, а n – последнего. Например, если диапазон задан так: , то это означает, что определен одномерный массив размерностью в 10 элементов, с индексами от 1 до 10.

Для обращения к элементу массива нужно указать его имя и номер: mas[i], тут mas – имя, i – номер. В программе ниже мы объявим массив и произведем простые операции над его элементами.

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

for i:=1 to n do
begin
mas[i]:=i;
write(mas[i]:3);
end;

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

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

Алгоритмы сортировки:

Алгоритмы поиска:

К числу менее сложных и в тоже время востребованных относятся методы определения количества положительных и отрицательных, минимального и максимального элементов. Рассмотрим их.

Поиск максимального элемента в массиве :

Для того чтобы сделать программу для поиска минимального элемента нужно всего лишь поменять знак < в 15 строке на >.

Определение количества положительных элементов :

Урок из серии: «Язык программирования Паскаль »

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

Например, запись Mas, A позволяет обратиться ко второму элементу массива MAS и десятому элементу массива A. При работе с двумерным массивом указывается два индекса, с n-мерным массивом — n индексов.

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

Индексированные элементы массива называются индексированными переменными. За границы массива выходить нельзя. То есть, если в массиве Mas пять элементов, то обращение к шестому или восьмому элементу приведет к ошибке.

Рассмотрим типичные операции, возникающие при работе с одномерными массивами.

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

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

Паскаль не имеет средств ввода-вывода элементов массива сразу, поэтому ввод и значений производится поэлементно. Значения элементу массива можно присвоить с помощью оператора присваивания, или ввести с клавиатуры с помощью операторов Read или Readln. Очень удобно перебирать все элементы массива в цикле типа for.

Способы заполнения одномерных массивов:

1. Ввод значения с клавиатуры.
2. Задание значений в операторе присваивания с помощью генератора случайных чисел. Этот способ более удобен, когда много элементов в массиве (ввод их значений с клавиатуры занимает много времени).
3. Задание значений по формуле.
4. Ввод элементов массива из файла

1. Ввод значений элементов массива с клавиатуры. В связи с тем, что использовался оператор Readln, каждое значение будет вводиться с новой строки.

2. Заполнение массива числами, сгенерированными случайным образом из интервала . Подключаем датчик случайных чисел — функцию random.

3. Заполнение массива по формуле. Каждому элементу массива присваивается значение, вычисленное по формуле. Если каждый элемент массива равен утроенному значению его порядкового номера (индекса), то процедура будет иметь вид:

4. Чтение чисел из файла. Нужно заранее создать текстовый файл, в который запишите несколько строк, в каждой из которых по 30 чисел.

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

Вывод значений элементов массива на экран выполняется, как и ввод, поэлементно в цикле. Для вывода будем использовать операторы Write или Writeln. В качестве входных параметров будем передавать процедуре не только массив, но и количество элементов, которые надо вывести, начиная с первого (это понадобится нам, когда мы будем удалять и добавлять элементы в массиве).

Пример 1. Заполнить массив с клавиатуры и вывести его на экран.

Решение.

В программе будет использоваться две процедуры: процедура Init1 (заполнение массива с клавиатуры) и процедура Print (вывод массива на экран).

Пример 2. Заполнить массив из текстового файла и вывести на экран. В текстовом файте несколько строк, в каждой строке по 30 чисел.

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

На следующем уроке продолжим знакомиться с алгоритмами обработки одномерных массивов.

Массив это структура данных, представленная в виде группы ячеек одного типа, объединенных под одним единым именем. Массивы используются для обработки большого количества однотипных данных. Имя массива является , что такое указатели расскажу немного позже. Отдельная ячейка данных массива называется элементом массива. Элементами массива могут быть данные любого типа. Массивы могут иметь как одно, так и более одного измерений. В зависимости от количества измерений массивы делятся на одномерные массивы, двумерные массивы, трёхмерные массивы и так далее до n-мерного массива. Чаще всего в программировании используются одномерные и двумерные массивы, поэтому мы рассмотрим только эти массивы.

Одномерные массивы в С++

Одномерный массив — массив, с одним параметром, характеризующим количество элементов одномерного массива. Фактически одномерный массив — это массив, у которого может быть только одна строка, и n-е количество столбцов. Столбцы в одномерном массиве — это элементы массива. На рисунке 1 показана структура целочисленного одномерного массива a . Размер этого массива — 16 ячеек.

Рисунок 1 — Массивы в С++

Заметьте, что максимальный индекс одномерного массива a равен 15, но размер массива 16 ячеек, потому что нумерация ячеек массива всегда начинается с 0. Индекс ячейки – это целое неотрицательное число, по которому можно обращаться к каждой ячейке массива и выполнять какие-либо действия над ней (ячейкой).

//синтаксис объявления одномерного массива в С++: /*тип данных*/ /*имя одномерного массива*/; //пример объявления одномерного массива, изображенного на рисунке 1: int a;

где, int —целочисленный ;

А — имя одномерного массива;
16 — размер одномерного массива, 16 ячеек.

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

//ещё один способ объявления одномерных массивов int mas, a;

Объявлены два одномерных массива mas и а размерами 10 и 16 соответственно. Причём в таком способе объявления все массивы будут иметь одинаковый тип данных, в нашем случае — int .

// массивы могут быть инициализированы при объявлении: int a = { 5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 }; // инициализация одномерного массива

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

Int a={5,-12,-12,9,10,0,-9,-12,-1,23,65,64,11,43,39,-15}; // инициализации массива без определения его размера.

В данном случае компилятор сам определит размер одномерного массива. Размер массива можно не указывать только при его инициализации, при обычном объявлении массива обязательно нужно указывать размер массива. Разработаем простую программу на обработку одномерного массива.

// array.cpp: определяет точку входа для консольного приложения. #include "stdafx.h" #include << "obrabotka massiva" << endl; int array1 = { 5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 }; // объявление и инициализация одномерного массива cout << "indeks" << "\t\t" << "element massiva" << endl; // печать заголовков for (int counter = 0; counter < 16; counter++) //начало цикла { //вывод на экран индекса ячейки массива, а затем содержимого этой ячейки, в нашем случае - это целое число cout << "array1[" << counter << "]" << "\t\t" << array1 << endl; } system("pause"); return 0; }

// код Code::Blocks

// код Dev-C++

// array.cpp: определяет точку входа для консольного приложения. #include using namespace std; int main(int argc, char* argv) { cout << "obrabotka massiva" << endl; int array1 = { 5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 }; // объявление и инициализация одномерного массива cout << "indeks" << "\t\t" << "element massiva" << endl; // печать заголовков for (int counter = 0; counter < 16; counter++) //начало цикла { //вывод на экран индекса ячейки массива, а затем содержимого этой ячейки, в нашем случае - это целое число cout << "array1[" << counter << "]" << "\t\t" << array1 << endl; } return 0; }

В строках 10 — 11 объявлен и проинициализирован целочисленный одномерный массив с именем array1 , размер которого равен 16 ячейкам, то есть такой массив может хранить 16 чисел. Любая обработка массива осуществима только совместно с циклами. Какой цикл выбрать для обработки массива — это вам решать. Но лучше всего для этой задачи подходит . Переменную-счётчик counter будем использовать для обращения к элементам одномерного массива array1 . В условии продолжения цикла for стоит строгий знак неравенства, так как шестнадцатого индекса в одномерном массиве array1 нет. А так как нумерация ячеек начинается с нуля, то элементов в массиве 16. В теле цикла for оператор cout печатает элементы одномерного массива (см. Рисунок 2).

Obrabotka massiva indeks element massiva array1 5 array1 -12 array1 -12 array1 9 array1 10 array1 0 array1 -9 array1 -12 array1 -1 array1 23 array1 65 array1 64 array1 11 array1 43 array1 39 array1 -15 Для продолжения нажмите любую клавишу. . .

Рисунок 2 — Массивы в С++

Разработаем ещё одну программу на обработку одномерного массива в С++. Программа должна последовательно считывать десять введённых чисел с клавиатуры. Все введённые числа просуммировать, результат вывести на экран.

// array_sum.cpp: определяет точку входа для консольного приложения. #include "stdafx.h" #include << "Enter elementi massiva: " << endl; int sum = 0; for (int counter = 0; counter < 10; counter++) // цикл для считывания чисел cin >> << "array1 = {"; for (int counter = 0; counter < 10; counter++) // цикл для вывода элементов массива cout << array1 << " "; // выводим элементы массива на стандартное устройство вывода for (int counter = 0; counter < 10; counter++) // цикл для суммирования чисел массива sum += array1; // суммируем элементы массива cout << "}\nsum = " << sum << endl; system("pause"); return 0; }

// код Code::Blocks

// код Dev-C++

// array_sum.cpp: определяет точку входа для консольного приложения. #include using namespace std; int main(int argc, char* argv) { int array1; // объявляем целочисленный массив cout << "Enter elementi massiva: " << endl; int sum = 0; for (int counter = 0; counter < 10; counter++) // цикл для считывания чисел cin >> array1; // считываем вводимые с клавиатуры числа cout << "array1 = {"; for (int counter = 0; counter < 10; counter++) // цикл для вывода элементов массива cout << array1 << " "; // выводим элементы массива на стандартное устройство вывода for (int counter = 0; counter < 10; counter++) // цикл для суммирования чисел массива sum += array1; // суммируем элементы массива cout << "}\nsum = " << sum << endl; return 0; }

Перед тем как выполнять обработку массива его необходимо объявить, причём размер одномерного массива равен 10, так как это оговорено условием задачи. В переменной sum будем накапливать сумму элементов одномерного массива. Первый цикл for заполняет объявленный одномерный массив, введёнными с клавиатуры числами, строки 12 — 13 . Переменная счётчик counter используется для последовательного доступа к элементам одномерного массива array1 , начиная с индекса 0 и до 9-го включительно. Второй цикл for выводит на экран элементы массива, строки 15 — 16 . Третий цикл for последовательно считывает элементы одномерного массива и суммирует их, сумма накапливается в переменной sum , строки 17 — 18 . Результат работы программы смотреть на рисунке 3.

Enter elementi massiva: 0 1 2 3 4 5 6 7 8 9 array1 = {0 1 2 3 4 5 6 7 8 9 } sum = 45 Для продолжения нажмите любую клавишу. . .

Рисунок 3 — Массивы в С++

Сначала последовательно были введены все 10 чисел, после чего отобразился одномерный массив, и напечаталась сумма чисел массива.

Двумерные массивы в С++

До этого момента мы рассматривали одномерные массивы, которыми не всегда можно ограничиться. Допустим, необходимо обработать некоторые данные из таблицы. В таблице есть две характеристики: количество строк и количество столбцов. Также и в двумерном массиве, кроме количества элементов массива, есть такие характеристики как, количество строк и количество столбцов двумерного массива. То есть, визуально, двумерный массив — это обычная таблица, со строками и столбцами. Фактически двумерный массив — это одномерный массив одномерных массивов. Структура двумерного массива, с именем a , размером m на n показана ниже (см. Рисунок 4).

Рисунок 4 — Массивы в С++

где, m — количество строк двумерного массива;
n — количество столбцов двумерного массива;
m * n — количество элементов массива.

// синтаксис объявления двумерного массива /*тип данных*/ /*имя массива*/;

В объявлении двумерного массива, также как и в объявлении одномерного массива, первым делом, нужно указать:

• тип данных;
• имя массива.

После чего, в первых квадратных скобочках указывается количество строк двумерного массива, во вторых квадратных скобочках — количество столбцов двумерного массива. Двумерный массив визуально отличается от одномерного второй парой квадратных скобочек. Рассмотрим пример объявления двумерного массива. Допустим нам необходимо объявить двумерный массив, с количеством элементов, равным 15. В таком случае двумерный массив может иметь три строки и пять столбцов или пять строк и три столбца.

// пример объявление двумерного массива: int a;

• a — имя целочисленного массива
• число в первых квадратных скобках указывает количество строк двумерного массива, в данном случае их 5;
• число во вторых квадратных скобках указывает количество столбцов двумерного массива, в данном случае их 3.

// инициализация двумерного массива: int a = { {4, 7, 8}, {9, 66, -1}, {5, -5, 0}, {3, -3, 30}, {1, 1, 1} };

В данном массиве 5 строк, 3 столбца. после знака присвоить ставятся общие фигурные скобочки, внутри которых ставится столько пар фигурных скобочек, сколько должно быть строк в двумерном массиве, причём эти скобочки разделяются запятыми. В каждой паре фигурных скобочек записывать через запятую элементы двумерного массива. Во всех фигурных скобочках количество элементов должно совпадать. Так как в массиве пять строк, то и внутренних пар скобочек тоже пять. Во внутренних скобочках записаны по три элемента, так как количество столбцов — три. Графически наш массив будет выглядеть, как двумерная таблица (см. Рисунок 5).

Рисунок 5 — Массивы в С++

В каждой ячейке двумерного массива a показано значение, в нижнем правом углу показан адрес данной ячейки. Адресом ячейки двумерного массива является имя массива, номер строки и номер столбца.

Разработаем несложную программу, на обработку двумерного массива, которая называется «Лабиринт». Лабиринт должен быть построен на основе двумерного массива. Размер лабиринта выберем на свое усмотрение.

// array2.cpp: определяет точку входа для консольного приложения. #include "stdafx.h" #include < 33; i++) //переключение по строкам { for (int j = 0; j < 20; j++)// переключение по столбцам if (mas[i][j] == 1) { // вывести два раза символ (номер которого 176 в таблице аски) в консоль cout << static_cast(176); cout << static_cast(176); } else cout << " "; // вывести два пробела cout << endl; } system("pause"); return 0; }

// код Code::Blocks

// код Dev-C++

// array2.cpp: определяет точку входа для консольного приложения. #include using namespace std; int main(int argc, char* argv) { // 1-условно "стенки лабиринта" // 2-"правильный путь, выход из лабиринта" // 0-"ложный путь" int mas = { {1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,}, // инициализация двумерного массива {1,2,1,0,0,1,0,1,2,2,2,1,1,1,1,0,0,0,0,1,}, {1,2,1,1,0,1,0,1,2,1,2,2,2,2,1,0,1,1,0,1,}, {1,2,2,2,2,2,2,1,2,1,1,1,1,2,1,0,0,1,0,1,}, {1,1,1,1,1,1,2,1,2,1,0,0,1,2,1,1,0,1,0,1,}, {1,0,0,1,0,0,2,2,2,1,1,0,0,2,0,0,0,1,0,1,}, {1,0,1,1,0,1,1,1,1,1,0,0,1,2,1,1,1,1,0,1,}, {1,0,0,0,0,0,0,0,0,1,1,1,1,2,1,0,0,0,0,1,}, {1,1,1,1,1,1,0,1,1,1,2,2,2,2,1,0,1,1,1,1,}, {1,1,0,0,0,1,0,0,1,1,2,1,1,1,1,0,0,0,0,1,}, {1,0,0,1,0,0,0,0,0,1,2,2,2,2,1,1,1,1,0,1,}, {1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,0,0,0,0,1,}, {1,2,2,2,2,2,2,2,2,2,2,2,2,2,1,0,1,1,1,1,}, {1,2,1,1,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1,}, {1,2,1,0,0,0,1,2,2,2,1,0,0,0,0,0,1,1,0,1,}, {1,2,1,1,1,1,1,2,1,2,1,1,1,0,1,0,0,0,0,1,}, {1,2,1,2,2,2,1,2,1,2,2,2,1,1,1,1,1,1,1,1,}, {1,2,1,2,1,2,1,2,1,0,1,2,2,2,2,2,2,2,2,1,}, {1,2,1,2,1,2,1,2,1,0,1,1,1,1,1,1,1,1,2,1,}, {1,2,1,2,1,2,1,2,1,0,0,0,0,0,0,0,0,0,2,1,}, {1,2,1,2,1,2,2,2,1,0,1,1,1,1,1,1,0,1,2,1,}, {1,2,1,2,1,1,1,1,1,0,0,0,1,0,1,0,0,1,2,1,}, {1,2,1,2,2,1,0,0,1,1,1,0,0,0,1,0,1,1,2,1,}, {1,2,1,1,2,1,1,0,0,0,0,0,1,0,1,0,0,1,2,1,}, {1,2,1,1,2,1,0,0,1,1,1,1,1,1,1,1,1,1,2,1,}, {1,2,1,1,2,1,1,0,1,2,2,2,2,2,2,2,2,2,2,1,}, {1,2,1,1,2,1,0,0,1,2,1,1,1,1,1,1,1,1,1,1,}, {1,2,1,1,2,1,0,1,1,2,1,1,1,1,1,1,1,1,2,2,}, {1,2,1,1,2,1,0,0,1,2,1,1,2,2,2,2,2,2,2,1,}, {1,2,1,1,2,1,0,1,1,2,1,1,2,1,1,1,1,1,1,1,}, {1,2,1,1,2,1,0,0,1,2,1,1,2,1,0,0,0,1,0,1,}, {1,2,2,2,2,1,0,1,1,2,2,2,2,0,0,1,0,0,0,1,}, {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,} }; // два цикла - внутренний и внешний, осуществляющие обращение к каждому элементу массива for (int i = 0; i < 33; i++) //переключение по строкам { for (int j = 0; j < 20; j++)// переключение по столбцам if (mas[i][j] == 1) { // вывести два раза символ (номер которого 176 в таблице аски) в консоль cout << static_cast(176); cout << static_cast(176); } else cout << " "; // вывести два пробела cout << endl; } return 0; }

Правильный и ложный пути можно было бы обозначать одной и той же цифрой, например, нулём, но для наглядности правильный путь обозначен цифрой 2. Инициализация массива выполнялась вручную, только для того, что бы упростить программу. Так как в программе выполняется обработка двумерного массива, нужны два цикла, для переключения между элементами двумерного массива. Первый цикл for выполняет переключение между строками двумерного массива. Так как строк в двумерном массиве 33, то и переменная-счетчик i инкрементируется от 0 до 33, строка 46 . Внутри первого цикла стоит цикл for , который переключается между элементами строки двумерного массива. В теле второго цикла for внутри выполняетcя унарная операция преобразования типа данных — static_cast<>() , которая печатает символ , под номером 176. операция преобразования типов данных дублируется для увеличения ширины лабиринта. Результат работы программы (см. Рисунок 6).

Рисунок 6 — Массивы в С++