Для общего развития.

1. Написать программу, которая объединяет два упорядоченных по возрастанию массива в один, также упорядоченный по возрастанию массив. Рекомендуемый вид экрана во время работы программы приведен ниже.

  1. количество чисел в первом масиве->5
  2. первый масив ->1 3 5 7 9
  3. количество чисел во втором масиве->5
  4. второй масив -> 2 4 6 8 10
  5. результат 1 2 3 4 5 6 7 8 9 10

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

  1. Введите матрицу второго порядка.
  2. -> 5 -7
  3. -> 1 3
  4. Определитель матрицы |A|= 22.00

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

  1. Введите матрицу третьего порядка.
  2. -> -9   1   3
  3. -> -13 3   5
  4. -> -5   5  -1
  5. Определитель матрицы |A|= -86.00

Несколько задач.

2 и 3 задачи нам близки.

Вопрос... В первой задаче

Вопрос... В первой задаче оператор procedure можно использовать?

Хорошо, Александр

Давайте решать предложенные Вами задачи. Вот только 2,3 простые слишком (формульные вычисления ?). Да и многомерные массивы мы ещё не рассматривали. А вот задача 1 нормальная (только, конечно, никаких процедур, Дима!).

Написать программу, которая

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

  1. program Sovmeshenie;
  2. type R1 = array[1..100]of integer;
  3. var A, B, C : R1;
  4.     j, M, N : integer;
  5.     _a, _b : integer;
  6. begin
  7.     write('Vvedite razmernost A = ');
  8.      readln(N);
  9.       write('Vvedite massiv A = ');
  10.        for j:=1 to N do
  11.         read(A[j]);
  12.        readln;    
  13.     write('vvedite razmernost B = ');
  14.      readln(M);    
  15.       write('Vvedite massiv B = ');
  16.        for j:=1 to M do
  17.         read(B[j]);
  18.        readln;
  19.     writeln('Massiv C = ');
  20.      for j := 1 to N+M do write(C[j],' ');
  21.       readln;
  22.   end;
  23.     _a := 0;
  24.     _b := 0;
  25.         if _a = an then
  26.         begin
  27.           inc(_b);
  28.             C[_a + _b] := B[_b];
  29.              end else if _b = bn then
  30.         begin
  31.           inc(_a);
  32.             C[_a + _b] := A[_a];
  33.              end else if A[_a + 1] <= B[_b + 1] then
  34.         begin
  35.           inc(_a);
  36.             C[_a + _b] := A[_a];
  37.              end else if A[_a + 1] >= B[_b + 1] then
  38.         begin
  39.           inc(_b);
  40.             C[_a + _b] := B[_b];
  41.         end;
  42.     end;          
  43. end.

Ну вот как-то так. прошу прокомментировать.

Начну с главного, зачем

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

Ну ведь можно и без

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

Задача 1

  1. Program SortTwoArray;
  2.  
  3. const lim = 100;
  4. type my_T = 1..lim;
  5. var a, b, c: array[my_T] of integer;
  6. var i, j, n, m: my_T;
  7. t: integer;
  8.  
  9. begin
  10.   write('количество чисел в первом масиве->');
  11.   readln(n);
  12.  
  13.   write('первый масив ->');
  14.  
  15.   //Вообще можно было обойтись сразу одним массивом, но я решил сохранить исходные
  16.   for i := 1 to n do begin
  17.     read(a[i]);
  18.     c[i] := a[i];
  19.   end;
  20.  
  21.   writeln;
  22.  
  23.   write('количество чисел во втором массиве->');
  24.   readln(m);
  25.  
  26.   write('второй массив ->');
  27.  
  28.   for i := 1 to m do begin
  29.     read(b[i]);
  30.     c[n+i] := b[i];
  31.   end;
  32.  
  33.   writeln;
  34.  
  35.   //Квадратичная сортировка, сложность - О(n^2)
  36.   for i := 1 to n+m do begin
  37.     for j := i + 1 to n+m do begin
  38.       if c[i] > c[j] then begin
  39.         t := c[i];
  40.         c[i] := c[j];
  41.         c[j] := t;
  42.       end;
  43.     end;
  44.   end;
  45.  
  46.   write('Результат ');
  47.  
  48.   for i := 1 to n+m do
  49.     write(c[i], ' ');
  50.  
  51. end.

Да можно было обойтись и

Да можно было обойтись и одним масивом, но теперь кто нибудь может попробывать это сделать.

Вот еще одна задача.

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

  1. количество чисел в последовательности->10
  2. -1 2 3 -7 -8 0 2 3 2 -1
  3. Кол-во последовательностей -> 2
  4. Наибольшая-> 2 3 2
  5. <\pre>

На счет первой задачи,

На счет первой задачи, запускал ее, проверял, все работает. И я вроде ввожу 2 массива и из них получаю третий.

Определитель матрицы второго порядка

  1. Program Opredelitel2;
  2.  
  3. type my_T = 1..2;
  4. var a: array[my_T] of array[my_T] of real;
  5. i, j: my_T;
  6. otvet: real;
  7.  
  8. begin
  9.   writeln('Введите матрицу второго порядка:');
  10.  
  11.   for i := 1 to 2 do
  12.     for j := 1 to 2 do
  13.       read(a[i][j]);
  14.  
  15.   otvet := a[1][1] * a[2][2] - a[1][2] * a[2][1];
  16.  
  17.   write('Определитель матрицы: ', otvet : 6 : 2);
  18.  
  19. end.

Определитель третьего порядка мне лень писать, т. к. аналогично, а перечислять много.

Согласен.

Согласен.

Задачи №1 и №3

Задача №1:

  1. program SortArrayOfTwo;
  2.  
  3. const
  4.   Lim = 100;
  5.  
  6. type
  7.   ind100 = 1..Lim;
  8.  
  9. var
  10.   A: array[ind100] of integer;
  11.   n, m, i, j: ind100;
  12.   c: integer;
  13.  
  14. begin
  15.   read(n, m); // считываем длины исходных массивов
  16.   for i := 1 to n + m do read(A[i]); // производим конкатенацию массивов прямо во время чтения
  17.   for i := 1 to n + m - 1 do // используем пузырьковую сортировку
  18.     for j := n + m - 1 downto i do
  19.       if A[j] > A[j + 1] then begin
  20.         c := A[j];
  21.         A[j] := A[j + 1];
  22.         A[j + 1] := c
  23.       end;
  24.   for i := 1 to n * 2 do write(A[i], ' ') // выводим результат
  25. end.

Задача №3:
  1. program Det3x3Matrix;
  2.  
  3. var
  4.   A: array[1..9] of real; // будем использовать одномерный массив
  5.   i: byte;
  6.   r: real;
  7.  
  8. begin
  9.   for i := 1 to 9 do read(A[i]); // ввод матрицы третьего порядка
  10.   // чтобы работать с элементом A[i,j] нужно к j прибавить (i - 1) * k,
  11.   // где k - количество столбцов в данной матрице
  12.   r := A[0 + 1] * A[3 + 2] * A[6 + 3] + A[3 + 1] * A[6 + 2] * A[0 + 3] + A[6 + 1] * A[0 + 2] * A[3 + 3]
  13.      - A[0 + 3] * A[3 + 2] * A[6 + 1] - A[3 + 3] * A[6 + 2] * A[0 + 1] - A[6 + 3] * A[0 + 2] * A[3 + 1];
  14.   writeln(r:4:2) // форматированный вывод
  15. end.

Насчет первой задачи, там

Насчет первой задачи, там самое интересное было в том чтобы из 2 масивов собрать 3.

По представленным решениям...

1. Повторяю, задачи с определителями 2-го, 3-го порядка с точки зрения техники программирования неинтересны. И вообще говоря, никаких массивов для их решения не требуется. Ввести переменные вида a11,a12,a13,a21, ... , затем посчитать по формуле. Иное дело, определитель N-го порядка (N - ограниченное, но в рамках ограничений произвольное). Здесь то и возникнут (если не писать совсем уж убогий код!) двумерные массивы - это задача наших дальнейших рассмотрений.

2. Ни одно из представленных здесь решений задачи о слиянии упорядоченных массивов нельзя считать удовлетворительным. Сортировка абсолютно неуместна, ибо задача решается за линейное время ( O(n) ) и именно сборкой результирующего массива из уже отсортированных, а не пересортировкой.

Дружественно задаче № 8 по обработке односвязных списков

Не думал, что смогу решить задачу соединения двух упорядоченных массивов только сейчас. Сегодня на занятии в подгруппе Валерия Шахамболетовича 1ПМ рассматривался алгоритм соединения двух упорядоченных линейных структур в одну, также упорядоченную. К сожалению, я далеко не сразу понял данный алгоритм и смог осуществить его только сейчас, причем лишь в случае одномерных массивов. Но теперь направление мысли задано, и работа над исходной задачей, как мне кажется, должна пройти проще.
Здесь же я хотел бы выложить решение задачи, упомянутой в первом предложении.
Для начала сделаю несколько комментариев по поводу используемых индексов и их целесообразности. Так как продвижение по исходным массивам не может быть заранее предугадано, нам необходимо ввести дополнительные индексы, указывающие на текущий элемент в каждом из них и изменять их значение только когда, когда данный элемент явно обработан, то есть внесен в массив-результат и больше нам не понадобится. При каждом новом добавлении в массив-результат индекс его текущего элемента также увеличивается.
Так как массивы имеют неоднородную структуру, и с какой-то позиции в одном из них могут пойти элементы, большие всех остальных элементов в другом массиве, то по выходе из цикла в этом массиве останется "хвост", который нужно будет прицепить к результирующему массиву, чему служит цикл по всем оставшимся необработанным элементам.
Собственно, вот код:

  1. program SortArrayOfTwo;
  2.  
  3. const
  4.   Lim = 100;
  5.  
  6. var
  7.   A, B: array[1..Lim] of integer;
  8.   C: array[byte] of integer;
  9.   acount, bcount, ccount: byte;
  10.   i, m, n: byte;
  11.  
  12. begin
  13.   acount := 1; // инициализация текущих индексов обрабатываемых элементов для каждого массива
  14.   bcount := 1;
  15.   ccount := 1;
  16.   readln(m, n); // ввод размерности исходных данных
  17.   for i := 1 to m do
  18.     read(A[i]); // ввод первого массива
  19.   for i := 1 to n do
  20.     read(B[i]); // ввод второго массива
  21.   while (acount <= m) and (bcount <= n) do begin // пока не вышли за границы первого или второго массива
  22.     if A[acount] > B[bcount] then begin // если рассматриваемый элемент первого массива больше элемента второго массива
  23.       C[ccount] := B[bcount]; // в результирующий массив записываем меньший из них
  24.       inc(bcount) // и продвигаемся на одну позицию по массиву, элемент которого уже обработали
  25.     end
  26.     else begin
  27.       if A[acount] < B[bcount] then begin // если рассматриваемый элемент первого массива меньше элемента второго массива
  28.         C[ccount] := A[acount]; // в результирующий массив записываем меньший из них
  29.         inc(acount) // и продвигаемся на одну позицию по массиву, элемент которого уже обработали
  30.       end
  31.       else begin // если рассматриваемые элементы обоих массивов равны
  32.         C[ccount] := A[acount]; // то в результирующий массив дважды записываем одинаковый элемент - на текущую позицию
  33.         C[ccount + 1] := B[bcount]; // и на следующую (при этом копирование именно из второго массива необязательно)
  34.         inc(acount); // продвигаемся на одну позицию в обоих массивах
  35.         inc(bcount);
  36.         inc(ccount) // продвижение на одну позицию по результирующему массиву обрабатываем отдельно
  37.       end
  38.     end;
  39.     inc(ccount) // продвигаемся на одну позицию по результирующему массиву
  40.   end;
  41.   if acount = m + 1 then begin // если первый массив пройден
  42.     for i := bcount to n do begin // то во втором могли остаться элементы, которые нужно добавить непрерывной последовательностью
  43.       C[ccount] := B[i]; // последовательно добавляем элементы
  44.       inc(ccount)
  45.     end
  46.   end
  47.   else begin // если первый массив не пройден
  48.     for i := acount to m do begin // то в нем остались элементы, которые нужно добавить непрерывной последовательностью
  49.       C[ccount] := A[i]; // последовательно добавляем элементы
  50.       inc(ccount)
  51.     end
  52.   end;
  53.   for i := 1 to m + n do begin // размерность результирующего массива - сумма размерностей исходных массивов
  54.     write(C[i], ' ') // вывод элементов результирующего массива
  55.   end
  56. end.

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

Аналогично изменениям в решении задачи, размещенной в соседней теме.

  1. program SortArrayOfTwo;
  2.  
  3. const
  4.   Lim = 100;
  5.  
  6. var
  7.   A, B: array[1..Lim] of integer;
  8.   C: array[byte] of integer;
  9.   acount, bcount, ccount: byte;
  10.   i, m, n: byte;
  11.  
  12. begi
  13.   acount := 1; // инициализация текущих индексов обрабатываемых элементов для каждого массива
  14.   bcount := 1;
  15.   ccount := 1;
  16.   readln(m, n); // ввод размерности исходных данных
  17.   for i := 1 to m do
  18.     read(A[i]); // ввод первого массива
  19.   for i := 1 to n do
  20.     read(B[i]); // ввод второго массива
  21.   while (acount <= m) and (bcount <= n) do begin // пока не вышли за границы первого или второго массива
  22.     if A[acount] > B[bcount] then begin // если рассматриваемый элемент второго массива меньше элемента первого массива
  23.       C[ccount] := B[bcount]; // добавляем его в результирующий массив
  24.       inc(bcount) // и продвигаемся во втором массиве на одну позицию
  25.     end
  26.     else begin // в противном случае меньшим или равным элементом будет элемент первого массива
  27.       C[ccount] := A[acount]; // добавляем его в результирующий массив
  28.       inc(acount) // и продвигаемся в первом массиве на одну позицию
  29.     end;
  30.     inc(ccount) // продвигаемся на одну позицию по результирующему массиву
  31.   end;
  32.   if acount = m + 1 then begin // если первый массив пройден
  33.     for i := bcount to n do begin // то во втором могли остаться элементы, которые нужно добавить непрерывной последовательностью
  34.       C[ccount] := B[i]; // последовательно добавляем элементы
  35.       inc(ccount)
  36.     end
  37.   end
  38.   else begin // если первый массив не пройден
  39.     for i := acount to m do begin // то в нем остались элементы, которые нужно добавить непрерывной последовательностью
  40.       C[ccount] := A[i]; // последовательно добавляем элементы
  41.       inc(ccount)
  42.     end
  43.   end;
  44.   for i := 1 to m + n do begin // размерность результирующего массива - сумма размерностей исходных массивов
  45.     write(C[i], ' ') // вывод элементов результирующего массива
  46.   end
  47. end.