Двумерные массивы
Объявление int A[n] создает в памяти одномерный массив: набор пронумерованных элементов, идущих в памяти последовательно. К каждому элементу массива можно обратиться, указав один индекс — номер этого элемента. Но можно создать и двумерный массив следующим образом: int A[n][m] . Данное объявление создает массив из n объектов, каждый из которых в свою очередь является массивом типа int [m] . Тогда A[i] , где i принимает значения от 0 до n-1 будет в свою очередь одним из n созданных обычных массивов, и обратиться к элементу с номером j в этом массиве можно через A[i][j] .
Подобные объекты (массивы массивов) также называют двумерными массивами. Двумерные массивы можно представлять в виде квадратной таблицы, в которой первый индекс элемента означает номер строки, а второй индекс – номер столбца. Например, массив A[3][4] будет состоять из 12 элементов и его можно записать в виде
A[0][0] A[0][1] A[0][2] A[0][3] A[1][0] A[1][1] A[1][2] A[1][3] A[2][0] A[2][1] A[2][2] A[2][3]
Для считывания, вывода на экран и обработки двумерных массивов необходимо использовать вложенные циклы. Первый цикл – по первому индексу (то есть по всем строкам), второй цикл – по второму индексу, то есть по всем элементам в строках (столбцам). Например, вывести на экран двумерный массив в виде таблицы, разделяя элементы в строке одним пробелом можно следующим образом:
int A[n][m]; for (int i = 0; i < n; ++i) < // Выводим на экран строку i for (int j = 0; j < m; ++j) < cout cout
А считать двумерный массив с клавиатуры можно при помощи еще более простого алгоритма (массив вводится по строкам, то есть в порядке, соответствующему первому примеру):
for (i = 0; i < n; ++i) < for (j = 0; j < m; ++j) < cin >> A[i][j]; > >
Обработка двумерного массива
Обработка двумерных массивов производится аналогичным образом. Например, если мы хотим записать в массив таблицу умножения, то есть присвоить элементу A[i][j] значение i * j , это можно сделать следующим образом при помощи вложенных циклов:
for (i = 0; i < n; ++i) < for (j = 0; j < m; ++j) < A[i][j] = i * j; >>
Рассмотрим более сложную задачу и несколько способов ее решения. Пусть дан квадратный двумерный массив int A[n][n] . Необходимо элементам, находящимся на главной диагонали проходящей из левого верхнего угла в правый нижний (то есть тем элементам A[i][j] , для которых i == j ) присвоить значение 1 , элементам, находящимся выше главной диагонали – значение 0, элементам, нахощящимся ниже главной диагонали – значение 2. То есть получить такой массив (пример для n == 4 ):
1 0 0 0 2 1 0 0 2 2 1 0 2 2 2 1
Рассмотрим несколько способов решения этой задачи. Элементы, которые лежат выше главной диагонали – это элементы A[i][j] , для которых i < j , а для элементов ниже главной диагонали i >j . Таким образом, мы можем сравнивать значения i и j и по ним определять значение A[i][j] . Получаем следующий алгоритм:
for (i = 0; i < n; ++i) < for (j = 0; j < n; ++j) < if (i < j) < A[i][j] = 0; >else if (i > j) < A[i][j] = 2; >else < A[i][j] = 1; >> >
Данный алгоритм плох, поскольку выполняет одну или две инструкции if для обработки каждого элемента. Если мы усложним алгоритм, то мы сможем обойтись вообще без условных инструкций.
Сначала заполним главную диагональ, для чего нам понадобится один цикл:
for (i = 0; i
Затем заполним значением 0 все элементы выше главной диагонали, для чего нам понадобится в каждой из строк с номером i присвоить значение элементам A[i][j] для j = i+1 , . n-1 . Здесь нам понадобятся вложенные циклы:
for (i = 0; i < n; ++i) < for (j = i + 1; j < n; ++j) < A[i][j] = 0; >>
Аналогично присваиваем значение 2 элементам A[i][j] для j = 0 , . i-1 :
for (i = 0; i < n; ++i) < for (j = 0; j < i; ++j) < A[i][j] = 2; >>
Можно также внешние циклы объединить в один и получить еще одно, более компактное решение:
for (i = 0; i < n; ++i) < // Заполняем строку с номером i for (j = 0; j < i; ++j) < A[i][j] = 2; // Сначала пишем 2 ниже диагонали >A[i][j] = 1; // После завершения предыдущего цикла i==j, пишем 1 for (++j; j < n; ++j) // Цикл начинаем с увеличения j на 1 < A[i][j] = 0; // Записываем 0 выше диагонали >>
Многомерные массивы
Можно объявлять не только двумерные массивы, но и массивы с большим количеством измерений. Например, объявление int A[n][m][l] создает трехмерный массив из n*m*l элементов. Для обращения к каждому элементу такого массива необходимо указать три индекса: A[i][j][k] , при этом 0
Передача двумерных массивов в функцию
В функцию можно передавать двумерный массив в качестве параметра, если размер этого массива фиксирован и объявлен в описании функции. То есть если заранее известен размер массива, то можно определить функцию, получающую в качестве параметра двумерный массив такого размера:
void f (int A[10][10]) < . >int main()
Проблема заключается в том, что в этом случае нельзя использовать массивы произвольного размера.
Чтобы использовать массивы произвольного размера, нам на помощь прийдут указатели. Для начала разберемся, как представлять двумерный массив в виде указателей.
Одномерный массив int A[n] это почти то же самое, что указатель на переменную типа int : int * A .
Тогда двумерный массив - это массив, каждый из элементов которого является одномерным массивом, то есть указателем на какой-то адрес целого числа в памяти. То есть двумерный массив - это массив элементов типа int * или же это указатель на переменную типа int * , то есть это переменная типа int ** .
Итак, двойной указатель можно объявить так:
int ** A;
Теперь выделим память для массива A . Если мы хотим, чтобы в массиве A было n элементов, каждый из которых является указателем на тип int , то сделаем это при помощи операции new :
A = new int * [n];
Теперь A указывает на область памяти, содержащей n элементов, каждый из которых имеет тип int * и указывает на некоторую область памяти, пока еще не выделенную. Выделим эту память - сделаем все A[i] указателями на область памяти из m элементов типа int :
for (int i = 0; i
Функцию, получающую в качестве параметра двумерный массив, можно объявлять так:
void f (int ** A, int n, int m)
Как и в случае с одномерным массивом, передаваемым как указатель, нам нужно одновременно передавать размеры массива - количество строк n и количество столбцов m .
При таком способе объявления массива и выделения памяти можно сделать так, чтобы в разных строчках массива было различное число элементов.
Форматирование чисел при выводе
Допустим, мы заполним массив таблицей умножения: A[i][j]=i*j как в примере в начале раздела. Если мы теперь попробуем вывести этот массив на экран, разделяя элементы в строке одним пробелом, то из-за того, что числа имеют различную длину столбцы таблицы окажутся неровными:
0 0 0 0 0 0 0 0 0 0 0 1 2 3 4 5 6 7 8 9 0 2 4 6 8 10 12 14 16 18 0 3 6 9 12 15 18 21 24 27
Для того, чтобы получить ровные столбцы необходимо, выводить числа так, чтобы одно выводимое число имело ширину, например, ровно в 3 символа, а “лишние” позиции были бы заполнены пробелами. Тогда получится следующая таблица:
0 0 0 0 0 0 0 0 0 0 0 1 2 3 4 5 6 7 8 9 0 2 4 6 8 10 12 14 16 18 0 3 6 9 12 15 18 21 24 27
Для того, чтобы выводимое число или строка имело ровно заданную ширину, необходимо перед выводом его на экран для потока cout вызвать метод width с параметром 3 . Данный метод устанавливает ширину поля для выводимого значения. Получим следующую программу для вывода:
for(int i = 0; i < n; ++i) < for(int j = 0; j < m; ++j) < cout.width(3); cout cout
Заметим, что мы теперь не выводим пробел после каждого числа, поскольку мы добавили этот пробел к ширине выводимого поля. Функция width действует однократно, только на следующее выводимый в поток значение, поэтому ее нужно вызывать перед каждым выводом числа на экран.
Внимание! Если выводимое число или строка имеет большую длину, чем это было установлено функцией width , то это число или строка будут выведены полностью, а не будет обрезано до указанного значения. То есть предпочтительней вывести результат некрасиво, нежели неверно.
Упражнения
Общие требования к оформлению программ.
Считывание данных осуществляется функцией void Read (int **& A, int & n, int & m) . Эта функция считывает размер массива в переменные n и m , передаваемые по ссылке, выделяет память под хранение массива.
Решение задачи осуществляется функцией, получающей в качестве параметра массив (типа int ** ), его размеры, дополнительные параметры при необходимости.
Вывод массива на экран осуществляется отдельной функцией Print , получающей в качестве параметров массив и его размеры.
Типичный вид программы на примере задачи A:
void Read (int **& A, int & n) < . >void Fill (int ** A, int n) < . >void Print (int ** A, int n) < . >int main()
A: Максимум
Найдите индексы первого вхождения максимального элемента. Выведите два числа: номер строки и номер столбца, в которых стоит наибольший элемент в двумерном массиве. Если таких элементов несколько, то выводится тот, у которого меньше номер строки, а если номера строк равны то тот, у которого меньше номер столбца.
3 4
0 3 2 4
2 3 5 5
5 1 2 3
Как задать двумерный массив
Часто в задачах приходится хранить прямоугольные таблицы с данными. Такие таблицы называются матрицами или двумерными массивами. В языке программирования Питон таблицу можно представить в виде списка строк, каждый элемент которого является в свою очередь списком, например, чисел. Например, приведём программу, в которой создаётся числовая таблица из двух строк и трех столбцов, с которой производятся различные действия.
a = [[1, 2, 3], [4, 5, 6]] print(a[0]) print(a[1]) b = a[0] print(b) print(a[0][2]) a[0][1] = 7 print(a) print(b) b[2] = 9 print(a[0]) print(b)
Здесь первая строка списка a[0] является списком из чисел [1, 2, 3] . То есть a[0][0] == 1 , значение a[0][1] == 2 , a[0][2] == 3 , a[1][0] == 4 , a[1][1] == 5 , a[1][2] == 6 .
Для обработки и вывода списка, как правило, используют два вложенных цикла. Первый цикл перебирает номер строки, второй цикл бежит по элементам внутри строки. Например, вывести двумерный числовой список на экран построчно, разделяя числа пробелами внутри одной строки, можно так:
a = [[1, 2, 3, 4], [5, 6], [7, 8, 9]] for i in range(len(a)): for j in range(len(a[i])): print(a[i][j], end=' ') print()
Однажды мы уже пытались объяснить, что переменная цикла for в Питоне может перебирать не только диапазон, создаваемый с помощью функции range() , но и вообще перебирать любые элементы любой последовательности. Последовательностями в Питоне являются списки, строки, а также некоторые другие объекты, с которыми мы пока не встречались. Продемонстрируем, как выводить двумерный массив, используя это удобное свойство цикла for :
a = [[1, 2, 3, 4], [5, 6], [7, 8, 9]] for row in a: for elem in row: print(elem, end=' ') print()
Естественно, для вывода одной строки можно воспользоваться методом join() :
for row in a: print(' '.join([str(elem) for elem in row]))
Используем два вложенных цикла для подсчета суммы всех чисел в списке:
a = [[1, 2, 3, 4], [5, 6], [7, 8, 9]] s = 0 for i in range(len(a)): for j in range(len(a[i])): s += a[i][j] print(s)
Или то же самое с циклом не по индексу, а по значениям строк:
a = [[1, 2, 3, 4], [5, 6], [7, 8, 9]] s = 0 for row in a: for elem in row: s += elem print(s)
2. Создание вложенных списков
Пусть даны два числа: количество строк n и количество столбцов m . Необходимо создать список размером n × m , заполненный нулями.
Очевидное решение оказывается неверным:
a = [[0] * m] * n
В этом легко убедиться, если присвоить элементу a[0][0] значение 5 , а потом вывести значение другого элемента a[1][0] — оно тоже будет равно 5. Дело в том, что [0] * m возвращает ccылку на список из m нулей. Но последующее повторение этого элемента создает список из n элементов, которые являются ссылкой на один и тот же список (точно так же, как выполнение операции b = a для списков не создает новый список), поэтому все строки результирующего списка на самом деле являются одной и той же строкой.
В визуализаторе обратите внимание на номер id у списков. Если у двух списков id совпадает, то это на самом деле один и тот же список в памяти.
n = 3 m = 4 a = [[0] * m] * n a[0][0] = 5 print(a[1][0])
Таким образом, двумерный список нельзя создавать при помощи операции повторения одной строки. Что же делать?
Первый способ: сначала создадим список из n элементов (для начала просто из n нулей). Затем сделаем каждый элемент списка ссылкой на другой одномерный список из m элементов:
n = 3 m = 4 a = [0] * n for i in range(n): a[i] = [0] * m
Другой (но похожий) способ: создать пустой список, потом n раз добавить в него новый элемент, являющийся списком-строкой:
n = 3 m = 4 a = [] for i in range(n): a.append([0] * m)
Но еще проще воспользоваться генератором: создать список из n элементов, каждый из которых будет списком, состоящих из m нулей:
n = 3 m = 4 a = [[0] * m for i in range(n)]
В этом случае каждый элемент создается независимо от остальных (заново конструируется список [0] * m для заполнения очередного элемента списка), а не копируются ссылки на один и тот же список.
3. Ввод двумерного массива
Пусть программа получает на вход двумерный массив в виде n строк, каждая из которых содержит m чисел, разделенных пробелами. Как их считать? Например, так:
3 1 2 3 4 5 6 7 8 9
# в первой строке ввода идёт количество строк массива n = int(input()) a = [] for i in range(n): a.append([int(j) for j in input().split()])
Или, без использования сложных вложенных вызовов функций:
3 1 2 3 4 5 6 7 8 9
# в первой строке ввода идёт количество строк массива n = int(input()) a = [] for i in range(n): row = input().split() for i in range(len(row)): row[i] = int(row[i]) a.append(row)
Можно сделать то же самое и при помощи генератора:
3 1 2 3 4 5 6 7 8 9
# в первой строке ввода идёт количество строк массива n = int(input()) a = [[int(j) for j in input().split()] for i in range(n)]
4. Пример обработки двумерного массива
Пусть дан квадратный массив из n строк и n столбцов. Необходимо элементам, находящимся на главной диагонали, проходящей из левого верхнего угла в правый нижний (то есть тем элементам a[i][j] , для которых i==j ) присвоить значение 1 , элементам, находящимся выше главной диагонали – значение 0, элементам, находящимся ниже главной диагонали – значение 2. То есть необходимо получить такой массив (пример для n==4 ):
1 0 0 0 2 1 0 0 2 2 1 0 2 2 2 1
Рассмотрим несколько способов решения этой задачи. Элементы, которые лежат выше главной диагонали – это элементы a[i][j] , для которых ij . Таким образом, мы можем сравнивать значения i и j и по ним определять значение A[i][j] . Получаем следующий алгоритм:
n = 4 a = [[0] * n for i in range(n)] for i in range(n): for j in range(n): if i < j: a[i][j] = 0 elif i >j: a[i][j] = 2 else: a[i][j] = 1 for row in a: print(' '.join([str(elem) for elem in row]))
Данный алгоритм плох, поскольку выполняет одну или две инструкции if для обработки каждого элемента. Если мы усложним алгоритм, то мы сможем обойтись вообще без условных инструкций.
Сначала заполним главную диагональ, для чего нам понадобится один цикл:
for i in range(n): a[i][i] = 1
Затем заполним значением 0 все элементы выше главной диагонали, для чего нам понадобится в каждой из строк с номером i присвоить значение элементам a[i][j] для j = i+1 , . n-1 . Здесь нам понадобятся вложенные циклы:
for i in range(n): for j in range(i + 1, n): a[i][j] = 0
Аналогично присваиваем значение 2 элементам a[i][j] для j = 0 , . i-1 :
for i in range(n): for j in range(0, i): a[i][j] = 2
Можно также внешние циклы объединить в один и получить еще одно, более компактное решение:
n = 4 a = [[0] * n for i in range(n)] for i in range(n): for j in range(0, i): a[i][j] = 2 a[i][i] = 1 for j in range(i + 1, n): a[i][j] = 0 for row in a: print(' '.join([str(elem) for elem in row]))
А вот такое решение использует операцию повторения списков для построения очередной строки списка. i -я строка списка состоит из i чисел 2 , затем идет одно число 1 , затем идет n-i-1 число 0 :
n = 4 a = [0] * n for i in range(n): a[i] = [2] * i + [1] + [0] * (n - i - 1) for row in a: print(' '.join([str(elem) for elem in row]))
А можно заменить цикл на генератор:
n = 4 a = [0] * n a = [[2] * i + [1] + [0] * (n - i - 1) for i in range(n)] for row in a: print(' '.join([str(elem) for elem in row]))
5. Вложенные генераторы двумерных массивов
Для создания двумерных массивов можно использовать вложенные генераторы, разместив генератор списка, являющегося строкой, внутри генератора всех строк. Напомним, что сделать список из n строк и m столбцов можно при помощи генератора, создающего список из n элементов, каждый элемент которого является списком из m нулей:
[[0] * m for i in range(n)]
Но при этом внутренний список также можно создать при помощи, например, такого генератора: [0 for j in range(m)] . Вложив один генератор в другой, получим вложенные генераторы:
[[0 for j in range(m)] for i in range(n)]
Но если число 0 заменить на некоторое выражение, зависящее от i (номер строки) и j (номер столбца), то можно получить список, заполненный по некоторой формуле.
Например, пусть нужно задать следующий массив (для удобства добавлены дополнительные пробелы между элементами):
0 0 0 0 0 0 0 1 2 3 4 5 0 2 4 6 8 10 0 3 6 9 12 15 0 4 8 12 16 20
В этом массиве n = 5 строк, m = 6 столбцов, и элемент в строке i и столбце j вычисляется по формуле: a[i][j] = i * j .
Для создания такого массива можно использовать генератор:
[[i * j for j in range(m)] for i in range(n)]
Программирование в "Эврике"
Теперь мы можем присваивать каждому элементу списка A новое значение. Например, мы можем сделать элемент A[0] также равным списку:
A[0]=range[3]
Теперь A будет равно [[0, 1, 2], 1, 2, 3, 4] , то есть объект A[0] будет списком [0, 1, 2] . В свою очередь, мы можем обращаться к отдельным элементам списка A[0] : A[0][0]==0 , A[0][1]==1 , A[0][2]==2 .
На практике часто приходится иметь дело с прямоугольными таблицами данных, также называемых двумерными массивами. Их можно представлять в виде списка из n элементов (строк), каждый из которых является списком из m элементов (столбцов). Тогда к отдельному элементу двумерного массива A можн обращаться, как A[i][j] , где i является номером строки, 0
Итак, создадим массив A из n=3 строк и m=5 столбцов:
n=3 m=5 A=range(n) # A является списком из n строк for i in range(n): A[i]=range(m) # Каждая строка является списком из m элементов
Заполнение массива
Теперь заполним массив нулями. Для этого нам понадобится два вложенных цикла: внешний цикл по всем строкам, а внутренний – по всем столбцам.
for i in range(n): for j in range(m): A[i][j]=0
Если мы захотим записать в массив таблицу умножения, присвоив элементу A[i][j] значение i*j , последнюю строку в этом примере нужно записать в виде A[i][j]=i*j .
Вывод массива на экран
Конечно, можно вывести массив A на экран одной командой print A , но тогда все элементы будут выведены в одну строку:
[[0, 0, 0, 0, 0], [0, 1, 2, 3, 4], [0, 2, 4, 6, 8]]
Но можно вывести массив в виде таблицы, так, чтобы каждая строка массива была выведена на одной строке, а внутри строки числа разделялись одним пробелом, то есть в виде:
A[0][0] A[0][1] A[0][2] A[0][3] A[0][4] A[1][0] A[1][1] A[1][2] A[1][3] A[1][4] A[2][0] A[2][1] A[2][2] A[2][3] A[2][4]
Для этого снова понадобятся два вложенных цикла. Один цикл по всем строкам, другой – по всем столбцам. В результате получаем:
for i in range(n): for j in range(m): print A[i][j], print
Обратите внимание на запятую, поставленную после инструкции print A[i][j] , необходимую для того, чтобы печать продолжалась на этой же строке. А вот инструкцию print без параметров для перехода на новую строку мы даем после завершения внутреннего цикла, то есть после вывода всей строки на экран. Вот что получится:
0 0 0 0 0 0 1 2 3 4 0 2 4 6 8
Считывание с клавиатуры
Теперь рассмотрим проблему считывания массива с клавиатуры в таком же виде. Проблема заключается в том, что функция input позволяет считать только одно значение, записанное в строке и выдаст ошибку при считывании набора чисел, разделенных пробелами. А функция raw_input сможет считать строку как единое целое вместе со всеми пробелами. Разбить строку на отдельные выражения, разделенные пробелами можно при помощи метода split() . Этот метод применяется к строке и возвращает список подстрок, состоящих из непробельных символов и разделенных пробелами. То есть если применить метод split к строке '1 2 3' , то получится список из 3 строк: ['1', '2', '3'] . Таким образом, мы можем разбить каждую входную строку на отдельные подстроки, а затем преобразовать эти подстроки к числовому виду при помощи функции int . В результате получаем следующий код (предполагается, что массив A из n строк и m столбцов уже создан):
for i in range(n): # Цикл по всем строкам s=raw_input() # Считали строку в переменную s s=s.split() # Разбили s на слова и записали их в виде списка for j in range(m): A[i][j]=int(s[j]) # Элементу A[i][j] присваиваем значение s[j]
Общий пример программы
Теперь объединим это все в одну программу, которая считывает с клавиатуры числа n и m (заданные в одной строке), затем создает массив из n строк и m столбцов, затем считывает его с клавиатуры построчно, затем увеличивает каждый элемент массива на 1, наконец, печатает результат:
# Считываем размеры массива s=raw_input() s=s.split() n=int(s[0]) m=int(s[1]) # Создаем массив A=range(n) for i in range(n): A[i]=range(m) # Считываем массив с клавиатуры for i in range(n): s=raw_input() s=s.split() for j in range(m): A[i][j]=int(s[j]) # Увеличиваем все элементы на 1 for i in range(n): for j in range(m): A[i][j]=A[i][j]+1 # Выводим массив на экран for i in range(n): for j in range(m): print A[i][j], print
Сложный пример обработки массива
Пусть дан квадратный массив из n строк и n столбцов. Необходимо элементам, находящимся на главной диагонали проходящей из левого верхнего угла в правый нижний (то есть тем элементам A[i][j] , для которых i==j ) присвоить значение 1 , элементам, находящимся выше главной диагонали – значение 0, элементам, находящимся ниже главной диагонали – значение 2. То есть получить такой массив (пример для n==4 ):
1 0 0 0 2 1 0 0 2 2 1 0 2 2 2 1
Рассмотрим несколько способов решения этой задачи. Элементы, которые лежат выше главной диагонали – это элементы A[i][j] , для которых ij . Таким образом, мы можем сравнивать значения i и j и по ним определять значение A[i][j] . Получаем следующий алгоритм:
for i in range(n): for j in range(n): if ij: A[i][j]=2 else: A[i][j]=1
Данный алгоритм плох, поскольку выполняет одну или две инструкции if для обработки каждого элемента. Если мы усложним алгоритм, то мы сможем обойтись вообще без условных инструкций.
Сначала заполним главную диагональ, для чего нам понадобится один цикл:
for i in range(n): A[i][i]=1
Затем заполним значением 0 все элементы выше главной диагонали, для чего нам понадобится в каждой из строк с номером i присвоить значение элементам A[i][j] для j = i+1 , . n-1 . Здесь нам понадобятся вложенные циклы:
for i in range(n): for j in range(i+1,n): A[i][j]=0
Аналогично присваиваем значение 2 элементам A[i][j] для j = 0 , . i-1 :
for i in range(n): for j in range(0,i): A[i][j]=2
Можно также внешние циклы объединить в один и получить еще одно, более компактное решение:
for i in range(n): for j in range(0,i): A[i][j]=2 A[i][i]=1 for j in range(i+1,n): A[i][j]=0
Форматирование чисел при выводе
Допустим, мы заполним массив таблицей умножения: A[i][j]=i*j как в примере в начале раздела. Если мы теперь попробуем вывести этот массив на экран, разделяя элементы в строке одним пробелом, то из-за того, что числа имеют различную длину столбцы таблицы окажутся неровными:
0 0 0 0 0 0 0 0 0 0 0 1 2 3 4 5 6 7 8 9 0 2 4 6 8 10 12 14 16 18 0 3 6 9 12 15 18 21 24 27
Для того, чтобы получить ровные столбцы необходимо, выводить числа так, чтобы одно выводимое число имело длину, например, ровно в 2 символа, а "лишние" позиции были бы заполнены пробелами.
0 0 0 0 0 0 0 0 0 0 0 1 2 3 4 5 6 7 8 9 0 2 4 6 8 10 12 14 16 18 0 3 6 9 12 15 18 21 24 27
Без лишних комментариев покажем, как в программе указать, что целое число x нужно выводить так, чтобы оно занимало ровно две позиции: print "%2d" % x . Здесь, естественно, можно заменить значение x на то значение, которое необходимо напечатать, а число 2 на любую другую ширину поля.
Итак, для печати ровной таблицы умножения можно воспользоваться следующим кодом:
for i in range(n): for j in range(m): print "%2d" % A[i][j],
Многомерные массивы
Многомерным называется такой массив, который отличается двумя или более измерениями, причем доступ к каждому элементу такого массива осуществляется с помощью определенной комбинации двух или более индексов. Многомерный массив индексируется двумя и более целыми числами.
Двумерные массивы
Простейшей формой многомерного массива является двумерный массив. Местоположение любого элемента в двумерном массиве обозначается двумя индексами. Такой массив можно представить в виде таблицы, на строки которой указывает один индекс, а на столбцы — другой. Пример объявления и инициализации двумерного массива показан ниже:
// Объявляем двумерный массив int[,] myArr = new int[4, 5]; Random ran = new Random(); // Инициализируем данный массив for (int i = 0; i < 4; i++) < for (int j = 0; j < 5; j++) < myArr[i, j] = ran.Next(1, 15); Console.Write("\t", myArr[i, j]); > Console.WriteLine(); >
Обратите особое внимание на способ объявления двумерного массива. Схематическое представление массива myArr показано ниже:
Если вам приходилось раньше программировать на С, С++ или Java, то будьте особенно внимательны, объявляя или организуя доступ к многомерным массивам в C#. В этих языках программирования размеры массива и индексы указываются в отдельных квадратных скобках, тогда как в C# они разделяются запятой.
Массивы трех и более измерений
В C# допускаются массивы трех и более измерений. Ниже приведена общая форма объявления многомерного массива:
тип[. ] имя_массива = new тип[размер1, размер2, . размеры];
Ниже приведен пример программы, использующей трехмерный массив:
int[,,] myArr = new int[5,5,5]; for (int i = 0; i < 5; i++) for (int j = 0; j < 5; j++) for (int k = 0; k < 5; k++) myArr[i, j, k] = i + j + k;Инициализация многомерных массивов
Для инициализации многомерного массива достаточно заключить в фигурные скобки список инициализаторов каждого его размера:
тип[,] имя_массива = < , < val, val, val, . val>, >;
где val обозначает инициализирующее значение, а каждый внутренний блок — отдельный ряд. Первое значение в каждом ряду сохраняется на первой позиции в массиве, второе значение — на второй позиции и т.д. Обратите внимание на то, что блоки инициализаторов разделяются запятыми, а после завершающей эти блоки закрывающей фигурной скобки ставится точка с запятой.
Ниже в качестве примера приведена общая форма инициализации двумерного массива:
int[,] myArr = < , , , >;