C 以一种时尚的方式并排排列字符矩阵

我试图使C代码与著名的

bigdigits.py

类似

为了实现这个结果，我已经尝试将

串联到

循环

这是我能找到的最接近的结果

scanf("%s", nums);

system("cls");

printf("\n");

x = strlen(nums);

for(int i = 0; i < x; i++){
    if(nums[i] == '1'){
        printf("%s",n[1].number);
    }else if(nums[i] == '2'){
        printf("%s",n[2].number);
    }else if(nums[i] == '3'){
        printf("%s",n[3].number);
    }else if(nums[i] == '4'){
        printf("%s",n[4].number);
    }else if(nums[i] == '5'){
        printf("%s",n[5].number);
    }else if(nums[i] == '6'){
        printf("%s",n[6].number);
    }else if(nums[i] == '7'){
        printf("%s",n[7].number);
    }else if(nums[i] == '8'){
        printf("%s",n[8].number);
    }else if(nums[i] == '9'){
        printf("%s",n[9].number);
    }else if(nums[i] == '0'){
        printf("%s",n[0].number);
        }
}

输入类似于“12”，输出（我想要实现的）类似于

 *     ***
**    *   *
 *       *
 *      *
 *    *
 *    *
***   *****

但目前我的输出是这样的

 *     
**    
 *    
 *    
 * 
 * 
***

 ***
*   *
   *
  *
*
*
*****

---

让我们回溯一下，在编写代码之前先看看一般逻辑

很明显，你有一个大数字数组，比如

#define  DIGITS  10
#define  ROWS    5

const char *const bigdigit[ROWS][DIGITS] = {
    { " 0 ", " 1 ", "22 ", "33 ", "  4", "555", " 66", "777", " 8 ", " 9 " },
    { "0 0", " 1 ", "  2", "  3", " 44", "5  ", "6  ", "  7", "8 8", "9 9" },
    { "0 0", " 1 ", " 2 ", " 3 ", "444", "55 ", "66 ", " 7 ", " 8 ", " 99" },
    { "0 0", " 1 ", "2  ", "  3", "  4", "  5", "6 6", " 7 ", "8 8", "  9" },
    { " 0 ", " 1 ", "222", "33 ", "  4", "55 ", " 6 ", " 7 ", " 8 ", "99 " }
};

因此，

bigdigit[row][digit]

描述了digit

digit

（0..9）的行

row

（0..4）。上面，每个数字都有3个字符宽，但这并不重要，只要任何特定字符的行都具有相同的宽度（即，

“

对齐！）

假设您希望使用这些大数字打印

251

因为

printf（）

从上到下、从左到右输出，我们需要先打印

2

的顶行，然后打印

5

的顶行，然后打印

1

的顶行，最后打印新行，直到打印其余行

所以，循环显然是

/* char *message;                    or 
   char  message[MAXSIZE];           contains the digits to be printed
   int   columns = strlen(message);  is the number of digits */

for (row = 0; row < ROWS; row++) {

    for (column = 0; column < columns; column++) {
        switch (message[column]) {
            case '0': fputs(bigdigit[row][0], stdout); break;
            case '1': fputs(bigdigit[row][1], stdout); break;
            case '2': fputs(bigdigit[row][2], stdout); break;
            case '3': fputs(bigdigit[row][3], stdout); break;
            case '4': fputs(bigdigit[row][4], stdout); break;
            case '5': fputs(bigdigit[row][5], stdout); break;
            case '6': fputs(bigdigit[row][6], stdout); break;
            case '7': fputs(bigdigit[row][7], stdout); break;
            case '8': fputs(bigdigit[row][8], stdout); break;
            case '9': fputs(bigdigit[row][9], stdout); break;
        }
    }

    fputc('\n', stdout);
}

bigdigit

是一个字符串文本的二维数组。外部（左）维度是行（0到

行

-1），内部（右）维度是数字（0到9）。这允许我们以良好的可读形式定义数组，如您所见

消息

字符数组限制为100个字符，包括字符串nul字节的结尾，

'\0'

，因此转换说明符将输入转换限制为99个字符。转换为

[0-9]

，表示包含ASCII数字0到9的字符串

函数返回成功转换的次数。

scanf（“%99[0-9]”，消息）

如果转换由十进制数字组成的字符串，则返回1，否则返回0或EOF。转换前的空格表示首先跳过任何空格（制表符、空格、换行符）

因此，这个示例程序一次转换一个数字，直到不再提供输入，或者输入包含空格或数字以外的内容。例如，任何字母都将结束程序

重要的是要认识到，当任何

scanf（）

函数系列遇到无法按要求转换的输入时，该输入将留在输入缓冲区中。不可转换的数据不会被丢弃。如果需要，您需要丢弃该数据。（

scanf（%*[\n]”）如果转换模式以空格开头，则可以使用

丢弃此类数据。它基本上会丢弃输入行的其余部分，不包括行尾的换行符。

*

表示跳过转换；结果不会存储在任何位置，并且没有与该转换对应的参数。）

行循环与本答案开头所解释的相同

列循环有两个不同的特性：不是从

0

循环到

message

中小于字符串长度的一个，而是从

0

循环到

message

中字符串的结尾。记住，在C中，字符串以nul字符

'\0'

（

strlen（）结尾）

只计算非nul字符的数量，直到它看到nul字符。）

列循环也会在每个数字之间打印一个空格。这样您就不需要在

bigdigit[][]

数组本身中有字母空格

bigdigit[row][message[col]-“0']

表达式中的“棘手”部分是

message[col]-“0”

部分。你看，字符串中的单个字符实际上只是整数，通常称为代码或代码点。在基本上所有的字符集中，

0

到

9

都有连续的代码集，因此

message[col]-“0”

如果消息[]中的第列字符计算为零是零位数，如果是一位数，则为一位数，依此类推，最多为九位数

第二个

fputc（'\n'，stdout）；

在每个大数字字符串后打印一个空行。这就是程序的空行

如果编译上述程序，并输入

1237543

，程序将输出

 1  22  333  7777 
11 2  2    3    7 
 1    2    3   7  
 1   2   33   7   
 1  2      3  7   
 1 2       3  7   
 1 2222 333   7   

5555   44  333  
5     4 4     3 
5    4  4     3 
555  44444  33  
   5    4     3 
5  5    4     3 
 55     4  333  

请注意，在C语言中，标准输入是行缓冲的（也就是说，当您键入输入时，程序实际上会一次看到整行，但只有当您按Enter键时才会看到整行）。因为大数字打印是在一个循环中完成的，一次从输入中获取一个数字字符串，所以这两个字符串打印在单独的行上

如果要按行中指定的方式打印输入，则需要读取整行（例如使用

fgets（）

），并至少实现空格字符（我的意思是在

bigdigit[][]

）中），并更改

fput（bigdigit[row][message col]-'0'，stdout）

返回到switch语句，以便可以输出空格。例如：

#include <stdlib.h>
#include <string.h>
#include <stdio.h>

#define  DIGITS  10
#define  ROWS    7

const char *const bigdigit[ROWS][DIGITS] = {
    { " 00 ", " 1", " 22 ", "333 ", "  44 ", "5555", " 666", "7777", " 88 ", " 99 " },
    { "0  0", "11", "2  2", "   3", " 4 4 ", "5   ", "6   ", "   7", "8  8", "9  9" },
    { "0  0", " 1", "   2", "   3", "4  4 ", "5   ", "6   ", "  7 ", "8  8", "9  9" },
    { "0  0", " 1", "  2 ", " 33 ", "44444", "555 ", "666 ", " 7  ", " 88 ", " 999" },
    { "0  0", " 1", " 2  ", "   3", "   4 ", "   5", "6  6", " 7  ", "8  8", "   9" },
    { "0  0", " 1", "2   ", "   3", "   4 ", "5  5", "6  6", " 7  ", "8  8", "   9" },
    { " 00 ", " 1", "2222", "333 ", "   4 ", " 55 ", " 66 ", " 7  ", " 88 ", "999 " }
};

int main(void)
{
    char  message[100], *line;
    int   row, col;

    while (1) {

        line = fgets(message, sizeof message, stdin);
        if (line == NULL)
            break;

        if (strcspn(line, "\r\n") < 1)
            break;

        for (row = 0; row < ROWS; row++) {

            for (col = 0; line[col] != '\0'; col++) {
                switch (line[col]) {
                case '0': fputs(bigdigit[row][0], stdout); fputc(' ', stdout); break;
                case '1': fputs(bigdigit[row][1], stdout); fputc(' ', stdout); break;
                case '2': fputs(bigdigit[row][2], stdout); fputc(' ', stdout); break;
                case '3': fputs(bigdigit[row][3], stdout); fputc(' ', stdout); break;
                case '4': fputs(bigdigit[row][4], stdout); fputc(' ', stdout); break;
                case '5': fputs(bigdigit[row][5], stdout); fputc(' ', stdout); break;
                case '6': fputs(bigdigit[row][6], stdout); fputc(' ', stdout); break;
                case '7': fputs(bigdigit[row][7], stdout); fputc(' ', stdout); break;
                case '8': fputs(bigdigit[row][8], stdout); fputc(' ', stdout); break;
                case '9': fputs(bigdigit[row][9], stdout); fputc(' ', stdout); break;
                case ' ': fputs("     ", stdout); break;
                }
            }

            fputc('\n', stdout);
        }

        fputc('\n', stdout);

    }

    return EXIT_SUCCESS;
}

与前一个程序相比，这个程序只有两个真正的新功能：第一，整个输入行不是

scanf（）

，而是读入

message[]

缓冲区（长度限制为小于

message[]

大小的一个字符）.message的表达式

sizeof计算为
message
数组中的字符数，包括为字符串末尾nul字符保留的字符数。它仅在
message
是数组时有效，而不是在它是指针时有效

（如果为
char*消息动态分配内存<
 1  22  333  7777 
11 2  2    3    7 
 1    2    3   7  
 1   2   33   7   
 1  2      3  7   
 1 2       3  7   
 1 2222 333   7   

5555   44  333  
5     4 4     3 
5    4  4     3 
555  44444  33  
   5    4     3 
5  5    4     3 
 55     4  333  

#include <stdlib.h>
#include <string.h>
#include <stdio.h>

#define  DIGITS  10
#define  ROWS    7

const char *const bigdigit[ROWS][DIGITS] = {
    { " 00 ", " 1", " 22 ", "333 ", "  44 ", "5555", " 666", "7777", " 88 ", " 99 " },
    { "0  0", "11", "2  2", "   3", " 4 4 ", "5   ", "6   ", "   7", "8  8", "9  9" },
    { "0  0", " 1", "   2", "   3", "4  4 ", "5   ", "6   ", "  7 ", "8  8", "9  9" },
    { "0  0", " 1", "  2 ", " 33 ", "44444", "555 ", "666 ", " 7  ", " 88 ", " 999" },
    { "0  0", " 1", " 2  ", "   3", "   4 ", "   5", "6  6", " 7  ", "8  8", "   9" },
    { "0  0", " 1", "2   ", "   3", "   4 ", "5  5", "6  6", " 7  ", "8  8", "   9" },
    { " 00 ", " 1", "2222", "333 ", "   4 ", " 55 ", " 66 ", " 7  ", " 88 ", "999 " }
};

int main(void)
{
    char  message[100], *line;
    int   row, col;

    while (1) {

        line = fgets(message, sizeof message, stdin);
        if (line == NULL)
            break;

        if (strcspn(line, "\r\n") < 1)
            break;

        for (row = 0; row < ROWS; row++) {

            for (col = 0; line[col] != '\0'; col++) {
                switch (line[col]) {
                case '0': fputs(bigdigit[row][0], stdout); fputc(' ', stdout); break;
                case '1': fputs(bigdigit[row][1], stdout); fputc(' ', stdout); break;
                case '2': fputs(bigdigit[row][2], stdout); fputc(' ', stdout); break;
                case '3': fputs(bigdigit[row][3], stdout); fputc(' ', stdout); break;
                case '4': fputs(bigdigit[row][4], stdout); fputc(' ', stdout); break;
                case '5': fputs(bigdigit[row][5], stdout); fputc(' ', stdout); break;
                case '6': fputs(bigdigit[row][6], stdout); fputc(' ', stdout); break;
                case '7': fputs(bigdigit[row][7], stdout); fputc(' ', stdout); break;
                case '8': fputs(bigdigit[row][8], stdout); fputc(' ', stdout); break;
                case '9': fputs(bigdigit[row][9], stdout); fputc(' ', stdout); break;
                case ' ': fputs("     ", stdout); break;
                }
            }

            fputc('\n', stdout);
        }

        fputc('\n', stdout);

    }

    return EXIT_SUCCESS;
}

 1  22  333  7777      5555   44  333  
11 2  2    3    7      5     4 4     3 
 1    2    3   7       5    4  4     3 
 1   2   33   7        555  44444  33  
 1  2      3  7           5    4     3 
 1 2       3  7        5  5    4     3 
 1 2222 333   7         55     4  333