Реверсивный двумерный массив в C ++ - PullRequest
2 голосов
/ 27 марта 2020

Итак, я пытаюсь взять массив 10x10 со случайными числами и в определенном формате, а затем отобразить его обратную версию (позиция [0] [0] теперь будет [9] [9] и т. Д.) и так далее, но я получаю ошибку C6385 в части, которая должна создать обратный массив. (проблемная c часть, заключенная в \\)

#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
    const int ROW = 10;
    const int COLUMN = 10;
    srand(time(NULL));

    int array[ROW][COLUMN] = {};
    int transposed[ROW][COLUMN] = {};

    for (int i = 0; i < ROW; i++)
    {
        for (int j = 0; j < COLUMN; j++)
        {
            array[i][j] = rand() % 10;

        }
    }
\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
    for (int i = 0; i < ROW; i++)
    {
        for (int j = 0; j < COLUMN; j++)
        {
            int it = ROW - i;
            int jt = COLUMN - j;
            transposed[i][j] = array[it][jt];
        }
    }
\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\

    cout << "     ORIGINAL" << endl;
    for (int i = 0; i < ROW; i++)
    {
        if (i == 0)
        {
            cout << "     1   2   3   4   5   6   7   8   8   10" << endl;
            cout << "   +---+---+---+---+---+---+---+---+---+---+" << endl;
        }
        for (int j = 0; j < COLUMN; j++)
        {
            if (((j > 0) && (j < 9)) && (i < 10))
            {
                cout << " | " << array[i][j];
            }
            else if (j == 9)
            {
                cout << " | " << array[i][j] << " |";
            }
            else if ((j == 0) && (i == 9))
            {
                cout << i + 1 << " | " << array[i][j];
            }
            else if ((j == 0) && (i < 9))
            {
                cout << i+1 << "  | " << array[i][j];
            }

        }
        cout << endl;
        if (i < 10)
        {
            cout << "   +---+---+---+---+---+---+---+---+---+---+" << endl;
        }
    }

    cout << "     Transposed" << endl;
    for (int i = 0; i < ROW; i++)
    {
        if (i == 0)
        {
            cout << "     1   2   3   4   5   6   7   8   8   10" << endl;
            cout << "   +---+---+---+---+---+---+---+---+---+---+" << endl;
        }
        for (int j = 0; j < COLUMN; j++)
        {
            if (((j > 0) && (j < 9)) && (i < 10))
            {
                cout << " | " << transposed[i][j];
            }
            else if (j == 9)
            {
                cout << " | " << transposed[i][j] << " |";
            }
            else if ((j == 0) && (i == 9))
            {
                cout << i + 1 << " | " << transposed[i][j];
            }
            else if ((j == 0) && (i < 9))
            {
                cout << i + 1 << "  | " << transposed[i][j];
            }

        }
        cout << endl;
        if (i < 10)
        {
            cout << "   +---+---+---+---+---+---+---+---+---+---+" << endl;
        }
    }
    return (0);
}

Ответы [ 3 ]

2 голосов
/ 27 марта 2020

Это проблематично c:

            int it = ROW - i;
            int jt = COLUMN - j;

Когда i равно 0, тогда it равно 10. То же самое для jt Помните, [0,0] отображается на [9,9], потому что массивы всегда начинаются с индекса 0. Последний допустимый элемент в массиве размером N равен [N-1], а не N.

Итак, когда эта строка выполняется:

        transposed[i][j] = array[it][jt];

Упс. transposed[0][0] = array[10][10]. Это не то, что вы хотите.

Следовательно, вы хотите это:

            int it = ROW - i - 1;
            int jt = COLUMN - j - 1;

Следовательно, в этот момент ваш код работает довольно хорошо:

     ORIGINAL
     1   2   3   4   5   6   7   8   8   10
   +---+---+---+---+---+---+---+---+---+---+
1  | 6 | 6 | 8 | 8 | 6 | 6 | 7 | 9 | 6 | 5 |
   +---+---+---+---+---+---+---+---+---+---+
2  | 4 | 2 | 9 | 6 | 0 | 2 | 8 | 9 | 4 | 6 |
   +---+---+---+---+---+---+---+---+---+---+
3  | 4 | 8 | 0 | 3 | 0 | 3 | 2 | 5 | 8 | 0 |
   +---+---+---+---+---+---+---+---+---+---+
4  | 7 | 0 | 5 | 5 | 3 | 0 | 3 | 5 | 7 | 3 |
   +---+---+---+---+---+---+---+---+---+---+
5  | 8 | 3 | 4 | 5 | 4 | 1 | 9 | 7 | 9 | 9 |
   +---+---+---+---+---+---+---+---+---+---+
6  | 6 | 7 | 2 | 2 | 3 | 3 | 3 | 8 | 2 | 8 |
   +---+---+---+---+---+---+---+---+---+---+
7  | 6 | 2 | 3 | 9 | 6 | 7 | 0 | 5 | 1 | 6 |
   +---+---+---+---+---+---+---+---+---+---+
8  | 6 | 9 | 5 | 8 | 0 | 9 | 8 | 9 | 3 | 0 |
   +---+---+---+---+---+---+---+---+---+---+
9  | 5 | 5 | 0 | 8 | 3 | 3 | 2 | 6 | 4 | 8 |
   +---+---+---+---+---+---+---+---+---+---+
10 | 1 | 1 | 7 | 0 | 2 | 8 | 5 | 2 | 7 | 4 |
   +---+---+---+---+---+---+---+---+---+---+
     Transposed
     1   2   3   4   5   6   7   8   8   10
   +---+---+---+---+---+---+---+---+---+---+
1  | 4 | 7 | 2 | 5 | 8 | 2 | 0 | 7 | 1 | 1 |
   +---+---+---+---+---+---+---+---+---+---+
2  | 8 | 4 | 6 | 2 | 3 | 3 | 8 | 0 | 5 | 5 |
   +---+---+---+---+---+---+---+---+---+---+
3  | 0 | 3 | 9 | 8 | 9 | 0 | 8 | 5 | 9 | 6 |
   +---+---+---+---+---+---+---+---+---+---+
4  | 6 | 1 | 5 | 0 | 7 | 6 | 9 | 3 | 2 | 6 |
   +---+---+---+---+---+---+---+---+---+---+
5  | 8 | 2 | 8 | 3 | 3 | 3 | 2 | 2 | 7 | 6 |
   +---+---+---+---+---+---+---+---+---+---+
6  | 9 | 9 | 7 | 9 | 1 | 4 | 5 | 4 | 3 | 8 |
   +---+---+---+---+---+---+---+---+---+---+
7  | 3 | 7 | 5 | 3 | 0 | 3 | 5 | 5 | 0 | 7 |
   +---+---+---+---+---+---+---+---+---+---+
8  | 0 | 8 | 5 | 2 | 3 | 0 | 3 | 0 | 8 | 4 |
   +---+---+---+---+---+---+---+---+---+---+
9  | 6 | 4 | 9 | 8 | 2 | 0 | 6 | 9 | 2 | 4 |
   +---+---+---+---+---+---+---+---+---+---+
10 | 5 | 6 | 9 | 7 | 6 | 6 | 8 | 8 | 6 | 6 |
   +---+---+---+---+---+---+---+---+---+---+
1 голос
/ 27 марта 2020

В дополнение к ответу @ serb ie, решающему проблему индексации, вы можете упростить алгоритм обращения самого массива - на месте без использования второго массива. С вашим текущим алгоритмом вы не столько переворачиваете массив, сколько просто заполняете второй массив элементами первого в обратном порядке. Если бы вы попытались на самом деле обратить array на место, вы бы просто поменяли местами каждый элемент дважды и получили бы тот же массив, с которого начали. Кроме того, нечетное или четное количество строк может дать разные результаты.

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

#define ROW  3
#define COL ROW

void rev2d (int (*a)[COL])
{
    /* loop rows increment from 0 while row < end row decrementing from ROW-1 */
    for (int i = 0, j = ROW-1; i <= j; i++, j--) {
        /* loop cols 0->COL-1 and COL-1->0 while i != j or col < endcol */
        for (int k = 0, l = COL-1; i != j ? k < COL : k < l; k++, l--) {
            /* swap element */
            int n = a[i][k];
            a[i][k] = a[j][l];
            a[j][l] = n;
        }
    }
}

( примечание: вы можете изменить функцию, чтобы принимать значения row и col, если вы не используете константы)

Алгоритм будет работать для значений row и col, больших или равных 2 (вы можете добавить проверку для массива размером 1x1 и при необходимости выдать предупреждение, или просто позвольте вещам остаться неизменными, как это было бы в настоящее время).

Обработка нечетного / четного количества строк выполняется через троицу, используемую в условном выражении inner-l oop, например i != j ? k < COL : k < l, который инвертирует полные строки, если не существует нечетного числа строк, а затем, когда i = j, он просто обращается к среднему элементу

. Он обеспечивает полное обращение массива, например:

102 * Пример 8 *

$ ./bin/revarr2da
original array:
  1  2  3
  4  5  6
  7  8  9

reversed array:
  9  8  7
  6  5  4
  3  2  1

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

1 голос
/ 27 марта 2020

Он скомпилирован на мне без ошибок, но есть проблема с такими значениями, как this Я использую Clion v3.15 и c ++ 14

Добро пожаловать на сайт PullRequest, где вы можете задавать вопросы и получать ответы от других членов сообщества.
...