Question

我在第一行有3个整数，前两个是我的矩阵的N和M行和colomns，而X是我必须放大矩阵的次数。在接下来的N行中，我有M个元素，更确切地说是一个矩阵，我必须＆＃34;放大＆＃34;。

这项工作完成了四个for陈述，但我不知道该怎么做。

输入

2 2 3
1 2
3 4

输出

1 1 1 2 2 2
1 1 1 2 2 2 
1 1 1 2 2 2
3 3 3 4 4 4
3 3 3 4 4 4
3 3 3 4 4 4

输出是给定的矩阵，其大小增加了X.

我的代码

    void ZoomIn(int n, int m, int x, int a[][100], int aux[][100])
{
    int i, j, ind_i, I, J, ind_j;


    if (x == 0)
        return ;
        I = J = 0;
    for(i = 0; i < n; i++)
        {
        for(j = 0; j < n; j++)
            {

              for(ind_i = J; ind_i < x; ind_i++)
                for(ind_j = I; ind_j < x; ind_j++)
                    aux[ind_i][ind_j] = a[i][j]; // the first element in the smallest matrix
            I = I + x;
            }
}

如何正确增加I和J的值，以便创建较小的子矩阵？我看到这个过程的方式就是这样我必须创建

 1 1 1
 1 1 1
 1 1 1

并继续下一个小矩阵

 2 2 2
 2 2 2
 2 2 2

Answer 1

如果你可以使用C99（或C11）可变长度数组，这是最简单的。只要确保数组对于堆栈来说不是太大，就可以在main()中直接分配局部变量，然后将数组传递给ZoomIn()进行处理。

您建议您使用四个嵌套循环。这当然有效。外部嵌套循环对迭代基础（unzoomed）数组中的元素;内部嵌套循环对将基本数组的当前元素复制到缩放数组的相关子部分。

此代码使用stderr.h中声明并在stderr.c中定义的函数 - 可从https://github.com/jleffler/soq/tree/master/src/libsoq获得的代码。这些功能极大地简化了错误报告。

#include <stdio.h>
#include <string.h>
#include "stderr.h"

static void dump_array(const char *tag, int n, int m, int array[n][m])
{
    printf("%s (%dx%d):\n", tag, n, m);
    for (int i = 0; i < n; i++)
    {
        const char *pad = "";
        for (int j = 0; j < m; j++)
        {
            printf("%s%d", pad, array[i][j]);
            pad = " ";
        }
        putchar('\n');
    }
}

static void ZoomIn(int r, int c, int base[r][c], int z, int zoom[z * r][z * c])
{
    for (int i = 0; i < r; i++)
    {
        for (int j = 0; j < c; j++)
        {
            for (int k = z * i; k < z * (i + 1); k++)
            {
                for (int l = z * j; l < z * (j + 1); l++)
                    zoom[k][l] = base[i][j];
            }
        }
    }
}

int main(int argc, char **argv)
{
    err_setarg0(argv[0]);
    if (argc > 1)
        err_usage("");

    char buffer[4096];

    if (fgets(buffer, sizeof(buffer), stdin) == 0)
        err_error("Unexpected EOF\n");
    int r, c, z;
    buffer[strcspn(buffer, "\n")] = '\0';
    if (sscanf(buffer, "%d%d%d", &r, &c, &z) != 3)
        err_error("Expected 3 numbers on first line, not [%s]\n", buffer);
    if (r <= 0 || r > 100 || c <= 0 || c > 100 || z <= 0 || z > 100)
        err_error("Matrix size out of control (r = %d, c = %d, z = %d)\n", r, c, z);
    if (r * c * z * z > 1000000)
        err_error("Zoomed matrix too big (r = %d, c = %d, z = %d)\n", r, c, z);

    int base[r][c];
    for (int i = 0; i < r; i++)
    {
        if (fgets(buffer, sizeof(buffer), stdin) == 0)
            err_error("Unexpected EOF 2\n");
        buffer[strcspn(buffer, "\n")] = '\0';
        int offset = 0;
        for (int j = 0; j < c; j++)
        {
            int p;
            if (sscanf(buffer + offset, "%d%n", &base[i][j], &p) != 1)
                err_error("Format error on line [%s]\n", buffer);
            offset += p;
        }
    }
    dump_array("Base Array", r, c, base);

    int zoom[r*z][c*z];

    ZoomIn(r, c, base, z, zoom);

    dump_array("Zoomed Array", r * z, c * z, zoom);

    return 0;
}

给定数据文件：

2 2 3
1 2
3 4

输出是：

Base Array (2x2):
1 2
3 4
Zoomed Array (6x6):
1 1 1 2 2 2
1 1 1 2 2 2
1 1 1 2 2 2
3 3 3 4 4 4
3 3 3 4 4 4
3 3 3 4 4 4

给定数据文件：

输出是：

Base Array (4x5):
1 3 5 7 9
2 4 6 8 0
0 1 2 3 4
5 6 7 8 9
Zoomed Array (24x30):
1 1 1 1 1 1 3 3 3 3 3 3 5 5 5 5 5 5 7 7 7 7 7 7 9 9 9 9 9 9
1 1 1 1 1 1 3 3 3 3 3 3 5 5 5 5 5 5 7 7 7 7 7 7 9 9 9 9 9 9
1 1 1 1 1 1 3 3 3 3 3 3 5 5 5 5 5 5 7 7 7 7 7 7 9 9 9 9 9 9
1 1 1 1 1 1 3 3 3 3 3 3 5 5 5 5 5 5 7 7 7 7 7 7 9 9 9 9 9 9
1 1 1 1 1 1 3 3 3 3 3 3 5 5 5 5 5 5 7 7 7 7 7 7 9 9 9 9 9 9
1 1 1 1 1 1 3 3 3 3 3 3 5 5 5 5 5 5 7 7 7 7 7 7 9 9 9 9 9 9
2 2 2 2 2 2 4 4 4 4 4 4 6 6 6 6 6 6 8 8 8 8 8 8 0 0 0 0 0 0
2 2 2 2 2 2 4 4 4 4 4 4 6 6 6 6 6 6 8 8 8 8 8 8 0 0 0 0 0 0
2 2 2 2 2 2 4 4 4 4 4 4 6 6 6 6 6 6 8 8 8 8 8 8 0 0 0 0 0 0
2 2 2 2 2 2 4 4 4 4 4 4 6 6 6 6 6 6 8 8 8 8 8 8 0 0 0 0 0 0
2 2 2 2 2 2 4 4 4 4 4 4 6 6 6 6 6 6 8 8 8 8 8 8 0 0 0 0 0 0
2 2 2 2 2 2 4 4 4 4 4 4 6 6 6 6 6 6 8 8 8 8 8 8 0 0 0 0 0 0
0 0 0 0 0 0 1 1 1 1 1 1 2 2 2 2 2 2 3 3 3 3 3 3 4 4 4 4 4 4
0 0 0 0 0 0 1 1 1 1 1 1 2 2 2 2 2 2 3 3 3 3 3 3 4 4 4 4 4 4
0 0 0 0 0 0 1 1 1 1 1 1 2 2 2 2 2 2 3 3 3 3 3 3 4 4 4 4 4 4
0 0 0 0 0 0 1 1 1 1 1 1 2 2 2 2 2 2 3 3 3 3 3 3 4 4 4 4 4 4
0 0 0 0 0 0 1 1 1 1 1 1 2 2 2 2 2 2 3 3 3 3 3 3 4 4 4 4 4 4
0 0 0 0 0 0 1 1 1 1 1 1 2 2 2 2 2 2 3 3 3 3 3 3 4 4 4 4 4 4
5 5 5 5 5 5 6 6 6 6 6 6 7 7 7 7 7 7 8 8 8 8 8 8 9 9 9 9 9 9
5 5 5 5 5 5 6 6 6 6 6 6 7 7 7 7 7 7 8 8 8 8 8 8 9 9 9 9 9 9
5 5 5 5 5 5 6 6 6 6 6 6 7 7 7 7 7 7 8 8 8 8 8 8 9 9 9 9 9 9
5 5 5 5 5 5 6 6 6 6 6 6 7 7 7 7 7 7 8 8 8 8 8 8 9 9 9 9 9 9
5 5 5 5 5 5 6 6 6 6 6 6 7 7 7 7 7 7 8 8 8 8 8 8 9 9 9 9 9 9
5 5 5 5 5 5 6 6 6 6 6 6 7 7 7 7 7 7 8 8 8 8 8 8 9 9 9 9 9 9

您也可以使用2个循环编写缩放代码，每次迭代需要两个分区：

static void ZoomIn(int r, int c, int base[r][c], int z, int zoom[z * r][z * c])
{
    for (int k = 0; k < z * r; k++)
    {
        for (int l = 0; l < z * c; l++)
            zoom[k][l] = base[k/z][l/z];
    }
}

这产生与四重嵌套循环版本相同的输出。尽管代码更简洁，但不清楚它是否会比四重嵌套循环版本更快。

增加矩阵的大小

1 个答案: