Работа с двумерными числовыми массивами - Программирование, компьютеры и кибернетика курсовая работа
Главная
Программирование, компьютеры и кибернетика
Работа с двумерными числовыми массивами
Анализ методики использования многомерных массивов в среде Delphi. Общее понятие массивов, их реализация, достоинства, недостатки. Массивы в Object Pascal. Описание функциональной структуры приложения: модуль MatrixOperations, модуль fileIO, модуль form.
посмотреть текст работы
скачать работу можно здесь
полная информация о работе
весь список подобных работ
Нужна помощь с учёбой? Наши эксперты готовы помочь!
Нажимая на кнопку, вы соглашаетесь с
политикой обработки персональных данных
Студенты, аспиранты, молодые ученые, использующие базу знаний в своей учебе и работе, будут вам очень благодарны.
2 wordArray : Array[Word] of Integer; // размер равен High(Word)
3 multiArray : Array[Byte, 1..5] of char; // двумерный массив
4 rangeArray : Array[5..20] of string; // размер равен 16
У для динамических массивов память заранее не выделяется, создаётся только указатель. У таких массивов необходимо задавать размер перед использованием. Например
устанавливает длину первой размерности массива dynArray в пять, при этом выделяется необходимая память. Для всех динамических массивов минимальный индекс равен нулю.
Отдельные подмассивы многомерного динамического массива могут иметь разные размеры, так как по сути они являются отдельными массивами.
Пример определения динамических массивов:
2 byteArray: Array of Byte; // одномерный массив
3 multiArray: Array of Array of string; // двумерный массив
1.2.3 Функции для работы с массивами
Copy (Source : array; StartIndex, Count : Integer ) : array - создает копию части массива.
High (type or variable): Ordinal type - возвращает верхнюю границу диапазона значений массива.
Length (const SourceArray: array): Integer - возвращает число элементов в массиве.
Low (type or variable): Ordinal type - возвращает нижнюю границу диапазона значений массива
SetLength (var ArrayToChange: Array type; Dim1Length: Integer {;Dim2Length: Integer; ...}) - изменяет размер динамического массива. Для многомерных массивов может принимать более одного параметра длины.
Slice (SourceArray: array; Count: Integer): array - создает часть массива для передачи его как параметр в процедуру или функцию.
При использовании динамических массивов необходимо помнить, что вызовы SetLength выделяют для массива дополнительную память, которую необходимо освобождать после окончания работы с массивом. Для этого ему нужно присвоить специальное значение nil .
1.3 Использование ма ссивов в рамках данного проекта
Работа со статическими массивами более проста и менее затратна в плане использования ресурсов компьютера, но так как в задании нигде не оговариваются конкретные размеры исходных матриц, то было принято решение построить программу ну основе использования динамических массивов.
Приложение построено таким образом, что размер используемой матрицы можно менять во время выполнения, так же он автоматически определяется при загрузке исходных данных из файла. Размеры динамических массивов внутри программы изменяются соответствующим образом автоматически.
Приложение предназначено для выполнения специфической обработки матриц. Исходные матрицы должны загружаться из файла, либо вводиться непосредственно в элементы интерфейса приложения.
Граничные условия на вводимые данные таковы:
· Размеры матрицы должны лежать в пределах [1; 2147483647]. Если введено число, выходящее из этого диапазона, либо значение, не являющееся целым числом, то размер устанавливается равным единице.
· Элементы матрицы должны лежать в пределах [-2147483648; 2147483647]. Если какой-то из элементов лежит вне этого диапазона, либо введёно значение, не являющееся целым числом, то элемент устанавливается равным нулю.
· В заданиях, связанных с подсчётом сумм элементов, результат может лежать в пределах [-9223372036854775808; 9223372036854775807]. Если сумма выходит за эти пределы, результат не определён.
2.2 Функциональная структура программы
MatrixOperations - различные операции с матрицей
fileIO - сохранение матрицы в файл/ чтение матрицы из файла
form - форма приложения, процедуры обмена данными между массивами и элементами формы. Структура связей модулей такова:
Это основной модуль программы, содержащий процедуры для выполнения матричных операций, предусмотренных заданием.
Определяет повсеместно используемые типы «матрица» и «вектор»:
Поиск максимальных элементов в матрице.
Процедура GetMaxVals , которая, перебирая все строки матрицы, находит в каждой максимальный элемент, записывает его значение в массив maxVal, а его номер столбца в массив maxValCol. Предварительно процедура выделяет необходимую намять для этих массивов. Листинг:
2 формирует массив максимальных элементов maxVal и массив номеров столбцов,
3 содержащих максимальные элементы maxValCol на основе матрицы arr
5 procedure GetMaxVals(var maxVal, maxValCol: TVector; const arr: TMatrix);
9 //выделим необходимый для каждого массива объём памяти
11 SetLength(maxValCol, high(arr)+1);
12 for RowN:= low(arr) to high(arr) do
14 maxVal[RowN]:= low(integer);//по умолчанию максимальное значение -2147483648
15 maxValCol[RowN]:= -1;//по умолчанию номер столбца с макс элементом -1
16 for ColN:= low(arr[RowN]) to high(arr[RowN]) do
18 if arr[RowN, ColN] > maxVal[RowN] then
19 begin//если элемент больше макс значения, то
20 maxVal[RowN]:= arr[RowN, ColN];//максимальное значение приравняем элементу
21 maxValCol[RowN]:= ColN;//номер столбца приравняем текущему столбцу
Суммы элементов между диагоналями
Далее идут функции, осуществляющие подсчёт сумм элементов выше и ниже пересечения диагоналей, а так же смену местами этих элементов. Главной диагональю считается множество элементов матрицы, индексы которых совпадают, побочной диагональю считается та, которая идёт по диагонали из нижнего левого угла матрицы.
Функции GetSumAbove и GetSumBelow проходят соответствующие половины строк матрицы, для каждой строки высчитывая диапазон столбцов, из которых нужно суммировать элементы:
1 {возвращает сумму элементов выше пересечения диагоналей матрицы arr}
2 function GetSumAbove (const arr: TMatrix): Int64;
5 lastColumn: integer;//номер столбца, содержащего элемент дальней диагонали минус 1
8 for RowN:= 0 to (high(arr) div 2) do
9 begin//с нулевой, по средюю строку
10 lastColumn:= high(arr)-RowN-1;//определим номер столбца последнего элемента, подлежащего суммированию
11 //если число столбцов меньше числа строк, то последний столбец может оказаться ближе
12 if lastColumn > high(arr[RowN]) then lastColumn:= high(arr[RowN]);
13 for ColN:= RowN+1 to lastColumn do //просуммируем элементы в высчитаных пределах
14 Result:= Result + arr[RowN, ColN];
17 {возвращает сумму элементов ниже пересечения диагоналей матрицы arr}
18 function GetSumBelow(const arr: TMatrix): Int64;
21 lastColumn: integer;//номер столбца, содержащего элемент дальней диагонали минус 1
24 for RowN:= (high(arr) div 2)+1 to high(arr) do
25 begin//со средней по последнюю строку
26 lastColumn:= RowN-1;//определим номер столбца последнего элемента, подлежащего суммированию
27 //если число столбцов меньше числа строк, то последний столбец может оказаться ближе
28 if lastColumn > high(arr[RowN]) then lastColumn:= high(arr[RowN]);
29 for ColN:= high(arr)-RowN+1 to lastColumn do //просуммируем элементы в высчитаных пределах
30 Result:= Result + arr[RowN, ColN];
Процедура SwapAboveBelow таким же образом, как функция GetSumAbove , определяет, какие элементы лежат выше пересечения диагоналей, но не суммирует их, а каждый меняет местами с элементом того же столбца, симметричным текущему относительно верхней и нижней границ матрицы. Для смены используется вспомогательная процедура swap для целых чисел, определённая в этом же модуле:
1 {вспомогательная процедура: поменять местами два целых числа}
2 procedure swap(var first, second: integer);
9 {поменять местами элементы выше и ниже пересечения диагоналей матрицы arr}
10 procedure SwapAboveBelow (var arr: TMatrix);
13 lastColumn: integer;//номер столбца, содержащего элемент дальней диагонали минус 1
15 for RowN:= 0 to (high(arr) div 2) do
16 begin//с нулевой, по средюю строку
17 lastColumn:= high(arr)-RowN-1;//определим номер столбца последнего элемента, подлежащего суммированию
18 //если число столбцов меньше числа строк, то последний столбец может оказаться ближе
19 if lastColumn > high(arr[RowN]) then lastColumn:= high(arr[RowN]);
20 for ColN:= RowN+1 to lastColumn do//для каждого элемента в высчитаных пределах
21 //поменяем его местами с элементом того же столбца, отстаящем на то же число строк, но от нижней границы матрицы
22 swap(arr[RowN, ColN], arr[high(arr) - RowN, ColN]);
Далее функция CircuarShift , осуществляющая циклический сдвиг строк матрицы вверх, или вниз. Направление сдвига определяется булевым параметром shiftUp, передаваемым процедуре:
2 осуществляет циклический сдвиг строк матрицы arr вверх при shiftUp = true,
5 procedure CircuarShift(var arr: TMatrix; shiftUp: boolean);
8 tmpRow: TVector;//временная переменная для хранения строки иатрицы
12 if high(arr) < 1 then exit;//если в матрице меньше двух строк - выходим
15 tmpRow:= arr[high(arr)];//сохраним последнюю строку матрицы
16 arr[high(arr)]:= arr[0];//приравняем последнюю строку первой
18 begin//для строк с нулевой по пред-предпоследнюю
19 arr[rowN]:= arr[rowN+1];//текущая строка равна нижней
21 arr[high(arr)-1]:= tmpRow;//предпоследнюю строку приравняем последней
25 tmpRow:= arr[0];//сохраним нулвую строку
26 arr[0]:= arr[high(arr)];//приравняем нулевую строку последней
27 for rowN:= high(arr) downto 2 do
28 begin//для строк с последней по вторую
29 arr[RowN]:= arr[RowN-1];//текущая строка равна верхней
31 arr[1]:= tmpRow;//первую строку приравняем нулевой
Процедура UnwindMatrix осуществляет "разворачивание" матрицы в одномерный массив против часовой стрелки. Эта процедура в своих локальных переменных хранит координаты текущего элемента, текущее направление обхода (посредством перечислимого типа TDirection), а так же границы ещё не обойдённой части матрицы, которые сужаются каждый раз, когда проходится целая строка, или столбец. В этот же момент меняется направление обхода и текущим становится элемент в этом направлении. Обход завершается, когда число пройденных элементов станет равняться количеству элементов в матрице:
2 type TDirection = (down, right, up, left);
4 {обходит матрицу arr против часовой стрелки и наполняет элементами массив res}
5 procedure UnwindMatrix(const arr: TMatrix; var res: TVector);
7 count, cur: integer;//число элементов в матрице и счётчик элементов
10 leftB, bottomB, rightB, topB: integer;//границы обхода - меняются при проходе полной строки или столбца
11 direction: TDirection;//текущее направление обхода
14 if (length(arr) = 0) or (length(arr[0]) = 0) then exit;//если в матрице нет элементов - выходим
15 count:= length(arr) * length(arr[0]);//подсчитаем число элементов в матрице
16 SetLength(res, count);//выделим память для хранения всех элементов матрицы
18 //начальные условия обхода: текущий элемент [0,0], границы совпадают с граниуцами матриы, направление - вниз
28 begin//пока не пройдём count элементов
29 res[cur]:= arr[RowN, ColN];//добавляем текущий элемент в массив
30 //дальненйшие действия зависят от текущего направления обхода
33 if RowN < bottomB then inc(RowN)//если не дошли до нижней границы - сдвигаемся вниз
35 begin//иначе - прошли левый столбец
36 direction:= right;//сменим направление на "вправо"
37 inc(leftB);//сдвинем левую границу к центру
42 if ColN < rightB then inc(ColN)//если не дошли до правой границы - сдвигаемся вправо
44 begin//иначе - прошли нижнюю строку
45 direction:= up;//сменим направление на "вверх"
46 dec(bottomB);//сдвинем нижнюю границу к центру
51 if RowN > topB then dec(RowN)//если не дошли до верхней границы - сдвигаемся вверх
53 begin//иначе - прошли правый столбец
54 direction:= left;//сменим направление на "влево"
55 dec(rightB);//сдвинем правую границу к центру
60 if ColN > leftB then dec(ColN)//если не дошли до левой границы - сдвигаемся влево
62 begin//иначе - прошли верхнюю строку
63 direction:= down;//сменим направление на "вниз"
64 inc(topB);//сдвинем верхнюю границу к центру
Наконец упорядочивание строк матрицы по убыванию суммы элементов каждой строки. Вспомогательная функция getRowSum возвращает сумму элементов заданной строки:
1 {возвращает сумму элементов RowN-ой строки матрицы arr}
2 function getRowSum(const arr: TMatrix; RowN: integer): Int64;
6 if RowN > high(arr) then exit;//если в матрице нет RowN-ой строки - выходим
7 for ColN:= 0 to high(arr[RowN]) do//суммируем элементы строки
8 Result:= Result + arr[RowN, ColN];
Сама сортировка осуществляется посредством процедуры SortRows . Был выбран алгоритм прямой вставки, так как число строк в матрице не предполагается большим, а этот алгоритм эффективен на небольших наборах данных. В любом случае сортировка осуществляется быстро, так как при перемене мест строк не происходит копирование данных, но просто переставляются местами указатели. Листинг этой функции:
1 {сортирует строки матрицы по убыванию сумм элементов каждой строки}
2 procedure SortRows(var arr: TMatrix);
4 i, k: integer;//переменные для алгоритма сортировки
5 tmpRow: TVector;//временная переменная для алгоритма сортировки
7 //алгоритм сортировки методом прямой вставки
9 begin//для строк с первой по последнюю
10 k:= i;//начиная с текущей строки
11 while (k > 0) and (getRowSum(arr, k) > getRowSum(arr, k-1)) do
12 begin//пока не дошли до нулевой строки, и сумма строки над текущей строкой больше текущей суммы
13 swap(arr[k-1], arr[k]);//поменяем текущую строку и строку над ней местами
Этот модуль содержит процедуры для файлового ввода/вывода матриц. Используются текстовые файлы, которые предварительно необходимо открыть и подготовить к чтению/записи.
Формат файла, содержащего матрицу таков: матрица записана построчно, начиная с первой строки, элементы в каждой строке записаны слева направо и разделены произвольным количеством пробелов. Именно такой файл создаёт процедура Write 2 DArray :
2 записывает матрицу arr в текстовый файл outFile. Файл должен быть
5 procedure Write2DArray(const arr: TMatrix; const outFile: TextFile);
9 for rowN:= low(arr) to high(arr) do
11 for colN:= low(arr[rowN]) to high(arr[rowN]) do
13 //ширина поля 12, так как -2147483648 - 11 символов
14 Write(outFile, arr[rowN, colN]: 12);
Процедура Read 2 DArray читает файл по строкам, разбирая каждую строку на подстрока пробелами с помощью процедуры ExtractStrings:
1 { читает матрицу arr из текстового файла inFile. Файл должен быть
3 procedure Read2DArray(var arr: TMatrix; const inFile: TextFile);
6 colCount: integer; //максимальное количество чисел в строке (число столбцов матрицы)
7 lineStr: string; //текущая строка
8 strNumbers: TStringList;//текущая строка, разделённая на подстроки пробелами
12 strNumbers:= TStringList.Create;
18 ExtractStrings([' '], [], PChar(lineStr), strNumbers); //разделим пробелами на подстроки
19 if colCount < strNumbers.Count then colCount:= strNumbers.Count;
20 SetLength(arr, rowN+1, colCount);//выделим память под новую строку
21 for colN:= 0 to strNumbers.Count-1 do //для каждого числа в строке
22 arr[rowN, colN]:= StrToIntDef(strNumbers[colN], 0);
Модуль, содержащий форму, переменную для хранения исходной матрицы, процедуры синхронизации содержания матрицы и элементов формы, а так же процедуру задания размеров матрицы.
Так как задача чётко разделена на задания, оперирующие одними и теми же исходными данными (целочисленным двумерным массивом), было принято решение разделить интерфейс приложения на две части. В верхней части формы отображается матрица исходных данных, которую можно редактировать и размеры которой можно менять. Нижняя часть формы представляет собой набор закладок, каждая из которых соответствует одной из поставленных задач. На каждой закладке содержится описание задания, кнопка «выполнить», а так же элементы, необходимы для отображения результата в рамках этого задания. Некоторые задания состоят в изменении исходной матрицы, результат выполнения таких заданий отображается непосредственно в исходных данных в верхней части формы. Всего существует как минимум три способа выбрать задачу: щёлкнуть мышкой по закладке, выбрать нужный пункт в меню «Задачи», нажать одну из кнопок F1 - F5.
Опишем важные процедуры формы. Процедура ReadMatrix осуществляет чтение исходных данных из таблицы на форме в двумерный массив. Перед началом чтения процедура устанавливает размер массива:
1 {заполнить матрицу в соответствии с содержанием таблицы на форме}
5 SetLength(workMatrix, G_Matrix.RowCount-1, G_Matrix.ColCount-1);
6 for rowN:= 0 to G_Matrix.RowCount-2 do
7 for colN:= 0 to G_Matrix.ColCount-2 do
8 workMatrix[rowN, colN]:= StrToIntDef(G_Matrix.Cells[colN+1, rowN+1], 0);
Процедура writeMatrix осуществляет обратную операцию, она заполняет поля таблицы в соответствии с массивом. Кроме этого она меняет значения числа строк и столбцов в соответствии с размерами массива:
1 {заполнить таблицу на форме в соответствии с содержанием матрицы}
5 G_Matrix.Cells[1, 1]:= '';//если матрица пуста
6 E_RowsN.Text:= IntToStr(high(workMatrix) + 1);
8 E_ColsN.Text:= IntToStr(high(workMatrix[low(workMatrix)]) + 1)
12 for rowN:= low(workMatrix) to high(workMatrix) do
13 for colN:= low(workMatrix[rowN]) to high(workMatrix[rowN]) do
14 G_Matrix.Cells[colN+1, rowN+1]:= IntToStr(workMatrix[rowN, colN]);
Процедура B_SetDimmsClick является обработчиком нажатия кнопки «задать размеры». Она проверяет, не стали ли размеры меньше единицы, меняет число строк и столбцов в таблицах формы, а так же проставляет номера строк и столбцов:
1 {обраюотчик уствновки размеров матрицы}
2 procedure TMainForm.B_SetDimmsClick(Sender: TObject);
7 //значения размеров не должны быть меньше 1
8 RowsN:= StrToIntDef(E_RowsN.Text, 0);
9 if RowsN < 1 then begin RowsN:= 1; E_RowsN.Text:= '1' end;
10 ColsN:= StrToIntDef(E_ColsN.Text, 0);
11 if ColsN < 1 then begin ColsN:= 1; E_ColsN.Text:= '1' end;
12 //число строк и столбцов в таблице, учитывая колонку и строку с номерами
15 //в этих таблицах отображаются одномерные массивы из первого задания
18 //одномерный массив из четвёртого задания имеет длину, равную числу элементов исходной матрицы
19 G_Task4.ColCount:= RowsN * ColsN;
20 //расставим номера строк и столбцов
23 G_Matrix.Cells[0, i+1]:= IntToStr(i+1);
24 G_Task1B.Cells[0, i]:= IntToStr(i+1);
25 G_Task1C.Cells[0, i]:= IntToStr(i+1);
28 G_Matrix.Cells[i+1, 0]:= IntToStr(i+1);
30 G_Task4.Cells[i, 0]:= IntToStr(i+1);
Процедура FormDestroy выполняется при уничтожении формы и выполняет очень важную функцию - освобождает память, которая выделялась во время работы приложения под матрицу исходных данных.
Процедура saveClick является обработчиком щелчка по пункту меню Файл->Сохранить. Она отображает диалог выбора файла для сохранения, создаёт выбранный файл, а после окончания записи закрывает его:
2 procedure TMainForm.saveClick(Sender: TObject);
6 //отобразим диалог выбора файла для сохранения, если отмена - выходим
7 if SaveDialog.Execute = false then exit;
8 AssignFile(outFile, SaveDialog.Files[0]);
10 readMatrix;//прочтём матрицу из таблицы
11 Write2DArray(workMatrix, outFile);//запишем матрицу в файл
12 CloseFile(outFile);//закроем файл.
Процедура loadClick ведёт себя так же, только не создаёт файл, а открывает его для чтения:
2 procedure TMainForm.loadClick(Sender: TObject);
6 //отобразим диалог выбора фала для загрузки, если отмена - выходим
7 if OpenDialog.Execute = false then exit;
8 AssignFile(inFile, OpenDialog.Files[0]);
9 Reset(inFile);//подготовим файл к чтению
10 Read2DArray(workMatrix, inFile);//прочтём матрицу из файла
12 CloseFile(inFile);//закроем файл
Остальные процедуры просто вызывают процедуры и функции других модулей, наполняют результатами соответствующие заданию элементы формы, а в конце обязательно освобождают динамическую память, если таковая была выделена в рамках процедуры.
2.4 Описание формата исходных файлов
Матрица в исходном файле представляется в текстовом виде. Каждая строка матрицы начинается с новой строки. Каждый элемент строки отделён от других произвольным числом пробелов и должен быть представлен целым числом, лежащим в диапазоне [-2147483648; 2147483647]. Если какой-то элемент выходит за границы этого диапазона, либо не является целым числом, то он интерпретируется как ноль.
Пример правильно составленного исходного файла:
100000 10000 20000 40000 -4000
50 100 -20 1000 2000
-100 -50 -20 0 20
4000 -100000 -40000 -10000 80000
Программа предназначена для выполнения определённого набора операций над матрицами. Описание каждой операции можно прочесть на соответствующей вкладке в интерфейсе программы.
Программа предназначена для исполнения на IBM-совместимых компьютерах с операционной системой Windows (тестирование проводилось на Windows XP).
· 10 мегабайт свободной оперативной памяти
Требования приложения к оперативной памяти сильно зависят от размера обрабатываемой матрицы. Соответствующий минимальным требованиям компьютер сможет обрабатывать матрицы размером не менее ста элементов.
Входными параметрами для приложения являются файлы, описанные в пункте 3.4. Так же есть возможность ввести исходную матрицу непосредственно в таблицу на форме.
Выходные данные представляются в элементах формы, расположенных на соответствующей заданию вкладке (смотрите руководство оператора)
Интерфейс приложения разделён на две части. В верхней части формы отображается матрица исходных данных, которую можно редактировать и размеры которой можно менять. Нижняя часть формы представляет собой набор закладок, каждая из которых соответствует одной из поставленных задач. На каждой закладке содержится описание задания, кнопка «выполнить», а так же элементы, необходимы для отображения результата в рамках этого задания. Некоторые задания состоят в изменении исходной матрицы, результат выполнения таких заданий отображается непосредственно в исходных данных в верхней части формы. Всего существует как минимум три способа выбрать задачу: щёлкнуть мышкой по закладке, выбрать нужный пункт в меню «Задачи», нажать одну из кнопок F1 - F5.
Результат двукратного выполнения задачи №3:
Сохранение полученной матрицы в файл:
100000 10000 20000 40000 -4000
4000 -100000 -40000 -10000 80000
Двумерный динамический массив - очень удобная конструкция для представления матрицы, размеры которой во время написания программы не известны. Но при его использовании нужно быть осторожным и учитывать некоторые особенности:
· При вызове SetLength с одним параметром размера будет выделена память только под первую размерность массива (например, будет увеличено число строк в матрице), остальные размерности затронуты не будут (в каждой добавленной строке будет ноль элементов).
· Каждый подмассив многомерного массива может иметь свою размерность (например, каждая строка матрицы в общем то может иметь длину, отличную от других)
· Необходимо всегда знать границы каждой размерности, чтобы не выйти за пределы массива в чужую память. Для этого полезны функции low и high .
· Необходимо всегда освобождать динамически выделенную память.
· При присваивании динамических массивов копирования данных не происходит, присваиваются лишь указатели, таким образом, после присваивания два массива будут указывать на одну и ту же область памяти. Чтобы получить копию массива, можно использовать функцию Copy.
· Copy копирует не весь многомерный массив, но только его первую размерность.
Тест 1 : Квадратная матрица 5 x 5 .
50 100 200 1000 2000
4000 10000 20000 40000 80000
100000 -100000 -40000 -10000 -4000
Результат выполнения первого задания:
Максимальные элементы по строкам: 20; 2000; 80000; 100000; 12
Столбцы с максимальными элементами: 5; 5; 5; 1; 5
Результат выполнения второго задания:
Результат выполнения третьего задания:
Число столбцов нечётно - был произведён сдвиг «вниз»
-1000 -200 -20 2 12
-100 -50 -20 0 20
50 100 200 1000 2000
4000 10000 20000 40000 80000
100000 -100000 -40000 -10000 -4000
Результат выполнения четвёртого задания:
Матрица, «развёрнутая» против часовой стрелки: -100; 50; 4000; 100000; -1000; -200; -20; 2; 12; -4000; 80000; 2000; 20; 0; -20; -50; 100; 10000; -100000; -40000; -10000; 40000; 1000; 200; 20000
Результат выполнения пятого задания:
Строки отсортированы в невозрастающем порядке сумм:
4000 10000 20000 40000 80000
50 100 200 1000 2000
-100 -50 -20 0 20
-1000 -200 -20 2 12
100000 -100000 -40000 -10000 -4000
Тест 2: прямоугольная матрица 3 x 8 .
1 - 18 17 -16 15 -14 13 -12
-2 19 20 2000 200000 20000000 2000000000 11
3 -4 5 -6 7 -8 9 -10
Результат выполнения первого задания:
Максимальные элементы по строкам: 17; 2000000000; 9
Столбцы с максимальными элементами: 3; 7; 7
Результат выполнения второго задания:
1 -4 17 -16 15 -14 13 -12
-2 19 20 2000 200000 20000000 2000000000 11
3 -18 5 -6 7 -8 9 -10
Результат выполнения третьего задания:
Число столбцов чётно - был произведён сдвиг «вверх»
-2 19 20 2000 200000 20000000 2000000000 11
3 -18 5 -6 7 -8 9 -10
1 -4 17 -16 15 -14 13 -12
Результат выполнения четвёртого задания:
Матрица, «развёрнутая» против часовой стрелки: 1; -2; 3; -4; 5; -6; 7; -8; 9; -10; 11; -12; 13; -14; 15; -16; 17; -18; 19; 20; 2000; 200000; 20000000; 2000000000;
Результат выполнения пятого задания:
Строки отсортированы в невозрастающем порядке сумм:
-2 19 20 2000 200000 20000000 2000000000 11
3 -4 5 -6 7 -8 9 -10
1 -18 17 -16 15 -14 13 -12
Тест 3 : прямоугольная матрица 10 x 5, наполненная случайными числами .
Результат выполнения первого задания:
Максимальные элементы по строкам: 20330; 26705; 23701; 21020; 7054
Столбцы с максимальными элементами: 4; 3; 1; 5; 2
Результат выполнения второго задания:
Результат выполнения третьего задания:
Число столбцов нечётно - был произведён сдвиг «вниз»
Результат выполнения четвёртого задания:
Матрица, «развёрнутая» против часовой стрелки: 4490; -27459; 23701; -15721; -27932; -16794; 30727; -16762; -24472; -12309; 26284; 20788; -21316; -25044; -22009; -25295; 23140; -11281; -19302; 21020; -20739; -30502; -6046; 20330; -12901; 6540; -22256; -11502; -14704; 7054; -24715; 18102; -1303; 27091; -6385; -13002; 21065; -32373; -2485; -28698; -23934; -14325; 14852; 26705; -30162; 17504; -30557; 28069; 20673; 5821
Результат выполнения пятого задания:
Строки отсортированы в невозрастающем порядке сумм:
Тест 4: матрица с большими по модулю числами.
0 -2000000000 -2100000000 -2000000000 1
1000000000 -800000000 400000000 3 15
0 -2000000000 -2000000000 -2000000000 1
1000000000 -800000000 400000000 3 15
0 -2000000000 -2000000000 -2000000000 1
1000000000 -800000000 400000000 3 15
0 -2000000000 -1900000000 -200000000 1
Результат выполнения первого задания:
Максимальные элементы по строкам: 1; 1000000000; 1; 1000000000; 1; 1000000000; 1
Столбцы с максимальными элементами: 5; 1; 5; 1; 5; 1; 5
Результат выполнения второго задания:
0 -2000000000 -1900000000 -2000000000 1
1000000000 -800000000 400000000 3 15
0 -2000000000 -2000000000 -2000000000 1
1000000000 -800000000 400000000 3 15
0 -2000000000 -2000000000 -2000000000 1
1000000000 -800000000 400000000 3 15
0 -2000000000 -2100000000 -2000000000 1
Результат выполнения третьего задания:
Число столбцов нечётно - был произведён сдвиг «вниз»
0 -2000000000 -1900000000 -2000000000 1
0 -2000000000 -2100000000 -2000000000 1
1000000000 -800000000 400000000 3 15
0 -2000000000 -2000000000 -2000000000 1
1000000000 -800000000 400000000 3 15
0 -2000000000 -2000000000 -2000000000 1
1000000000 -800000000 400000000 3 15
Результат выполнения четвёртого задания:
Матрица, «развёрнутая» против часовой стрелки: 0; 1000000000; 0; 1000000000; 0; 1000000000; 0; -2000000000; -1900000000; -2000000000; 1; 15; 1; 15; 1; 15; 1; -2000000000; -2100000000; -2000000000; -800000000; -2000000000; -800000000; -2000000000; -800000000; 400000000; 3; -2000000000; 3; -2000000000; 3; 400000000; -2000000000; 400000000; -2000000000
Результат выполнения пятого задания:
Строки отсортированы в невозрастающем порядке сумм:
1000000000 -800000000 400000000 3 15
1000000000 -800000000 400000000 3 15
1000000000 -800000000 400000000 3 15
0 -2000000000 -1900000000 -2000000000 1
0 -2000000000 -2000000000 -2000000000 1
0 -2000000000 -2000000000 -2000000000 1
0 -2000000000 -2100000000 -2000000000 1
Внутри программы такая матрица будет интерпретирована следующим образом:
Результат выполнения первого задания:
Максимальные элементы по строкам: 123; 456; 1234567890; 15; 0; 915; 1111111111
Столбцы с максимальными элементами: 2; 1; 1; 2; 1; 1; 3
Результат выполнения второго задания:
Результат выполнения третьего задания:
Число столбцов нечётно - был произведён сдвиг «вниз»
Результат выполнения четвёртого задания:
Матрица, «развёрнутая» против часовой стрелки
Работа с двумерными числовыми массивами курсовая работа. Программирование, компьютеры и кибернетика.
Волшебные Сочинение 5 Класс
Алгебра 7 Класс Контрольная Работа Дорофеев Ответы
Отчет по практике по теме Оказание квалифицированной юридической помощи физическим и юридическим лицам
Реферат: Бухгалтерский учет финансовых результатов хозяйственной деятельности предприятия
Курсовая На Тему Договор Займа
Семейный Портрет Простаковых Сочинение 8 Класс
Реферат по теме Роль семьи в формировании и развитии личности. Особенности личности ребенка
Курсовая работа по теме Проблемы безработицы в Восточной Европе
Реферат по теме Экотуризм
Физкультура Реферат Кратко
Назовите Основные Жанры Школьных Сочинений
Реферат по теме Анкета по социологии. Выявление потребительского спроса жителей города N на алкогольную продукцию
Курсовая работа по теме Конструкция и техническое обслуживание сканеров
Курсовая Работа На Тему Анализ Финансового Состояния Предприятия Ооо "Автосервис"
Сочинение На Тему Любовная Лирика Есенина
Отчет по практике по теме Анализ финансового состояния ОАО 'Белкамнефть'
Дипломная работа по теме Особенности перевода аббревиатур и сокращений с английского на русский язык
Реферат По Теме Простейшие Паразитические Амебы
Реферат по теме Византийский дар
Реферат: Клеточная теория и тайны жизни
Ориентирование на местности с помощью наземной навигационной аппаратуры - Военное дело и гражданская оборона реферат
Организация бухгалтерского учета в Государственном коммунальном учреждении "Ясли-сад №1 "Карлыгаш" - Бухгалтерский учет и аудит отчет по практике
Культура XVIII века - Культура и искусство реферат