16数字集

zzz19760225

1234567890a,;:.（小数点不在16数字集层面考虑，而是作为载体层面上，再次十进制表达十进制里表现。又或者增加小数点.和中文句号。）
全组合的内容。1名实相对关系里选择定义的制标准单元，2单元组合的排序排列全组合地图，3地图上的选择全组合，4选择全组合里的万物生物动物人类需求循环自转的各种规律选择集合。

zzz19760225

通义：linux mint22.2 C语言SDL2建立3X5点阵，二维数组代表，二维数组的15个值为单元全组合，依次显示每个组合内容的点阵效应。不用字符，每行中文注释。
修正一个SDL_CreateWindow 函数调用语法错误
直接使用 SDL_WINDOWPOS_CENTERED
文件dotmatrix.c

1. 
   
2. // 引入标准输入输出库
   
3. #include <stdio.h>
   
4. // 引入标准库（用于延时等）
   
5. #include <stdlib.h>
   
6. // 引入SDL2图形库
   
7. #include <SDL2/SDL.h>
   
8. 
   
9. // 定义点阵宽度（列数）
   
10. #define WIDTH 3
    
11. // 定义点阵高度（行数）
    
12. #define HEIGHT 5
    
13. // 定义每个点的像素大小（方便可视化）
    
14. #define DOT_SIZE 40
    
15. // 定义窗口宽度（含边距）
    
16. #define WINDOW_WIDTH (WIDTH * DOT_SIZE + 20)
    
17. // 定义窗口高度（含边距）
    
18. #define WINDOW_HEIGHT (HEIGHT * DOT_SIZE + 20)
    
19. // 定义每帧显示时间（毫秒）
    
20. #define FRAME_DELAY 100
    
21. 
    
22. // 主函数
    
23. int main(int argc, char* argv[])
    
24. {
    
25.     // 初始化SDL系统
    
26.     if (SDL_Init(SDL_INIT_VIDEO) != 0) {
    
27.         printf("无法初始化SDL：%s\n", SDL_GetError());
    
28.         return -1;
    
29.     }
    
30. 
    
31.     // 创建窗口
    
32.     SDL_Window* window = SDL_CreateWindow(
    
33.         "3x5点阵全组合演示",               // 窗口标题
    
34.         SDL_WINDOWPOS_CENTERED,          // 横向居中
    
35.         SDL_WINDOWPOS_CENTERED,          // 纵向居中
    
36.         WINDOW_WIDTH,                    // 窗口宽度
    
37.         WINDOW_HEIGHT,                   // 窗口高度
    
38.         SDL_WINDOW_SHOWN                 // 显示窗口
    
39.     );
    
40.     if (!window) {
    
41.         printf("无法创建窗口：%s\n", SDL_GetError());
    
42.         SDL_Quit();
    
43.         return -1;
    
44.     }
    
45. 
    
46.     // 创建渲染器
    
47.     SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
    
48.     if (!renderer) {
    
49.         printf("无法创建渲染器：%s\n", SDL_GetError());
    
50.         SDL_DestroyWindow(window);
    
51.         SDL_Quit();
    
52.         return -1;
    
53.     }
    
54. 
    
55.     // 定义点阵二维数组（初始为0）
    
56.     int dot[HEIGHT][WIDTH] = {0};
    
57. 
    
58.     // 总组合数：2的15次方
    
59.     const int total = 1 << (WIDTH * HEIGHT); // 即32768
    
60. 
    
61.     // 遍历所有组合（从0到32767）
    
62.     for (int combo = 0; combo < total; combo++) {
    
63.         // 清空屏幕为白色背景
    
64.         SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
    
65.         SDL_RenderClear(renderer);
    
66. 
    
67.         // 将当前组合编号转换为点阵状态
    
68.         int temp = combo;
    
69.         for (int y = 0; y < HEIGHT; y++) {
    
70.             for (int x = 0; x < WIDTH; x++) {
    
71.                 dot[y][x] = temp & 1;      // 取最低位作为该点状态（0或1）
    
72.                 temp >>= 1;                // 右移一位处理下一点
    
73.             }
    
74.         }
    
75. 
    
76.         // 绘制点阵
    
77.         for (int y = 0; y < HEIGHT; y++) {
    
78.             for (int x = 0; x < WIDTH; x++) {
    
79.                 if (dot[y][x]) {
    
80.                     // 若该点为1，则绘制黑色实心矩形
    
81.                     SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
    
82.                 } else {
    
83.                     // 若该点为0，则绘制浅灰色填充（可清晰看到灭点）
    
84.                     SDL_SetRenderDrawColor(renderer, 220, 220, 220, 255);
    
85.                 }
    
86.                 // 计算矩形位置（加边距10像素）
    
87.                 SDL_Rect rect = {
    
88.                     10 + x * DOT_SIZE,
    
89.                     10 + y * DOT_SIZE,
    
90.                     DOT_SIZE - 2,  // 留1像素间隙
    
91.                     DOT_SIZE - 2
    
92.                 };
    
93.                 SDL_RenderFillRect(renderer, &rect);
    
94.             }
    
95.         }
    
96. 
    
97.         // 更新屏幕显示
    
98.         SDL_RenderPresent(renderer);
    
99. 
    
100.         // 处理退出事件（如点击关闭按钮）
     
101.         SDL_Event event;
     
102.         while (SDL_PollEvent(&event)) {
     
103.             if (event.type == SDL_QUIT) {
     
104.                 goto cleanup; // 跳出循环并清理资源
     
105.             }
     
106.         }
     
107. 
     
108.         // 延迟一段时间以便观察
     
109.         SDL_Delay(FRAME_DELAY);
     
110.     }
     
111. 
     
112. cleanup:
     
113.     // 释放渲染器资源
     
114.     SDL_DestroyRenderer(renderer);
     
115.     // 释放窗口资源
     
116.     SDL_DestroyWindow(window);
     
117.     // 关闭SDL系统
     
118.     SDL_Quit();
     
119. 
     
120.     // 程序正常结束
     
121.     return 0;
     
122. }
     

复制代码

gcc -o dotmatrix dotmatrix.c -lSDL2
./dotmatrix
或鼠标双击dotmatrix
可以运行，产生一个页面黑色和灰色相对的快速组合递增，类似二进制有序堆积。
下面需要抽出这些组合，排序，在排序的序数序号中，提取使用4位01的16个点阵字符对应组合数组。（要不要过一百遍呢？）
所有 32768 种亮灭组合，只要其中的16种。余下的作为点阵牌使用，人怎么调用点阵牌呢。
通过指针，将3万组合里的16个提出来，怎么使用。
并行一个15点阵的线条，三个点阵为一线段，点阵需求的位置，可以相对二进制数量算出来。不需要自己算，让自动信息安排这个程序功能，点击点阵，就汇总出二进制数量。
需要手工点击点阵尝试点阵组合的各种样子，找个人认为不错的组合，然后获取对应显示的序数序号，在另一个输入框里输入，就可以调用。手工寻找，输入框再现点阵组合。

zzz19760225

通义：在上面的程序继续修改，鼠标左键点击点阵就变黑，再点击就变白，汇总显示黑色点阵所代表的数。

dotmatrix5.c

1. 
   
2. // 引入标准输入输出库
   
3. #include <stdio.h>
   
4. // 引入标准库（用于字符串等）
   
5. #include <stdlib.h>
   
6. // 引入SDL2图形库
   
7. #include <SDL2/SDL.h>
   
8. 
   
9. // 定义点阵宽度（列数）
   
10. #define WIDTH 3
    
11. // 定义点阵高度（行数）
    
12. #define HEIGHT 5
    
13. // 定义每个点的像素大小
    
14. #define DOT_SIZE 60
    
15. // 定义边距
    
16. #define MARGIN 20
    
17. // 定义窗口宽度
    
18. #define WINDOW_WIDTH (WIDTH * DOT_SIZE + 2 * MARGIN)
    
19. // 定义窗口高度
    
20. #define WINDOW_HEIGHT (HEIGHT * DOT_SIZE + 2 * MARGIN)
    
21. // 定义每帧刷新间隔（毫秒）
    
22. #define FRAME_DELAY 50
    
23. 
    
24. // 主函数
    
25. int main(int argc, char* argv[])
    
26. {
    
27.     // 初始化SDL系统
    
28.     if (SDL_Init(SDL_INIT_VIDEO) != 0) {
    
29.         printf("无法初始化SDL：%s\n", SDL_GetError());
    
30.         return -1;
    
31.     }
    
32. 
    
33.     // 创建窗口（初始标题）
    
34.     SDL_Window* window = SDL_CreateWindow(
    
35.         "数值: 0",
    
36.         SDL_WINDOWPOS_CENTERED,
    
37.         SDL_WINDOWPOS_CENTERED,
    
38.         WINDOW_WIDTH,
    
39.         WINDOW_HEIGHT,
    
40.         SDL_WINDOW_SHOWN
    
41.     );
    
42.     if (!window) {
    
43.         printf("无法创建窗口：%s\n", SDL_GetError());
    
44.         SDL_Quit();
    
45.         return -1;
    
46.     }
    
47. 
    
48.     // 创建渲染器
    
49.     SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
    
50.     if (!renderer) {
    
51.         printf("无法创建渲染器：%s\n", SDL_GetError());
    
52.         SDL_DestroyWindow(window);
    
53.         SDL_Quit();
    
54.         return -1;
    
55.     }
    
56. 
    
57.     // 点阵状态数组（0=灭，1=亮）
    
58.     int dot[HEIGHT][WIDTH] = {0};
    
59. 
    
60.     // 主循环标志
    
61.     int running = 1;
    
62. 
    
63.     // 事件结构体
    
64.     SDL_Event event;
    
65. 
    
66.     while (running) {
    
67.         // 处理所有待处理事件
    
68.         while (SDL_PollEvent(&event)) {
    
69.             if (event.type == SDL_QUIT) {
    
70.                 running = 0;
    
71.             }
    
72.             // 处理鼠标左键点击
    
73.             else if (event.type == SDL_MOUSEBUTTONDOWN && event.button.button == SDL_BUTTON_LEFT) {
    
74.                 int mouse_x = event.button.x;
    
75.                 int mouse_y = event.button.y;
    
76. 
    
77.                 // 转换为点阵坐标（减去边距）
    
78.                 int grid_x = (mouse_x - MARGIN) / DOT_SIZE;
    
79.                 int grid_y = (mouse_y - MARGIN) / DOT_SIZE;
    
80. 
    
81.                 // 检查是否在有效范围内
    
82.                 if (grid_x >= 0 && grid_x < WIDTH && grid_y >= 0 && grid_y < HEIGHT) {
    
83.                     // 切换该点状态
    
84.                     dot[grid_y][grid_x] = 1 - dot[grid_y][grid_x];
    
85.                 }
    
86.             }
    
87.         }
    
88. 
    
89.         // 计算当前点阵对应的整数值
    
90.         unsigned int value = 0;
    
91.         int bit_index = 0;
    
92.         for (int y = 0; y < HEIGHT; y++) {
    
93.             for (int x = 0; x < WIDTH; x++) {
    
94.                 if (dot[y][x]) {
    
95.                     value |= (1U << bit_index);  // 设置第 bit_index 位
    
96.                 }
    
97.                 bit_index++;
    
98.             }
    
99.         }
    
100. 
     
101.         // 更新窗口标题（显示当前数值）
     
102.         char title[64];
     
103.         snprintf(title, sizeof(title), "数值: %u", value);
     
104.         SDL_SetWindowTitle(window, title);
     
105. 
     
106.         // 清屏（白色背景）
     
107.         SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
     
108.         SDL_RenderClear(renderer);
     
109. 
     
110.         // 绘制点阵
     
111.         for (int y = 0; y < HEIGHT; y++) {
     
112.             for (int x = 0; x < WIDTH; x++) {
     
113.                 if (dot[y][x]) {
     
114.                     SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);   // 黑色（亮）
     
115.                 } else {
     
116.                     SDL_SetRenderDrawColor(renderer, 220, 220, 220, 255); // 浅灰（灭）
     
117.                 }
     
118.                 SDL_Rect rect = {
     
119.                     MARGIN + x * DOT_SIZE,
     
120.                     MARGIN + y * DOT_SIZE,
     
121.                     DOT_SIZE - 2,
     
122.                     DOT_SIZE - 2
     
123.                 };
     
124.                 SDL_RenderFillRect(renderer, &rect);
     
125.             }
     
126.         }
     
127. 
     
128.         // 更新画面
     
129.         SDL_RenderPresent(renderer);
     
130. 
     
131.         // 控制刷新率
     
132.         SDL_Delay(FRAME_DELAY);
     
133.     }
     
134. 
     
135.     // 清理资源
     
136.     SDL_DestroyRenderer(renderer);
     
137.     SDL_DestroyWindow(window);
     
138.     SDL_Quit();
     
139. 
     
140.     return 0;
     
141. }
     

复制代码

gcc -o dotmatrix5 dotmatrix5.c -lSDL2
./dotmatrix5
可以鼠标点击点阵，页面眉头显示对应十进制数字。

zzz19760225

以十进制为主，
是否应该修改为11个单元的排序全组合，另外一个信息间隔的逗号，一共12个单元的12元集合，12集。
0，1，2，3，4，5，6，7，8，9，
a(10)，
，(逗号专门的间隔单元)
8        4，0320        ×8
9        36，2880        ×9
10        362，8800        ×10
11        3991，6800        ×11
12        4，7900，1600        ×12
11位的排序全组合总数，可以覆盖24位颜色的1677万。
人耳可听的声波20赫兹～20000赫兹，2万的1，9980。

39916800-16777216-19980=2311，9604
空闲2311万可以自由发挥。

双逗号，，为一个信息条结束或更大层面的间隔。

类似16进制去表达二进制，用相对大的数量代表数字字符集，去表达太大的排序全组合空间，量化为文字和数字代表，对接八卦64卦等排序全组合。

zzz19760225

9数字亿进制点阵1
可以显示两竖，每竖4个数字，八个点阵阿拉伯数字，但是没有适度的间隔开来。

1. 
   
2. #include <SDL2/SDL.h>
   
3. #include <stdio.h>
   
4. #include <stdbool.h>  // 必须包含！
   
5. 
   
6. #define DOT_SIZE 20
   
7. #define PADDING 4   // 点与点之间，以及数字块之间的间隔
   
8. 
   
9. // 3x5 点阵数字图案：0~9（这里只用前8个）
   
10. const bool digits[10][5][3] = {
    
11.     {{true, true, true}, {true, false, true}, {true, false, true}, {true, false, true}, {true, true, true}}, // 0
    
12.     {{false, true, false}, {false, true, false}, {false, true, false}, {false, true, false}, {false, true, false}}, // 1
    
13.     {{true, true, true}, {false, false, true}, {true, true, true}, {true, false, false}, {true, true, true}}, // 2
    
14.     {{true, true, true}, {false, false, true}, {true, true, true}, {false, false, true}, {true, true, true}}, // 3
    
15.     {{true, false, true}, {true, false, true}, {true, true, true}, {false, false, true}, {false, false, true}}, // 4
    
16.     {{true, true, true}, {true, false, false}, {true, true, true}, {false, false, true}, {true, true, true}}, // 5
    
17.     {{true, true, true}, {true, false, false}, {true, true, true}, {true, false, true}, {true, true, true}}, // 6
    
18.     {{true, true, true}, {false, false, true}, {false, false, true}, {false, false, true}, {false, false, true}}, // 7
    
19.     {{true, true, true}, {true, false, true}, {true, true, true}, {true, false, true}, {true, true, true}}, // 8
    
20.     {{true, true, true}, {true, false, true}, {true, true, true}, {false, false, true}, {true, true, true}}  // 9
    
21. };
    
22. 
    
23. int main(int argc, char* argv[]) {
    
24.     if (SDL_Init(SDL_INIT_VIDEO) != 0) {
    
25.         fprintf(stderr, "SDL_Init Error: %s\n", SDL_GetError());
    
26.         return 1;
    
27.     }
    
28. 
    
29.     const int grid_cols = 2;  // 横向 2 个数字
    
30.     const int grid_rows = 4;  // 竖向 4 个数字
    
31.     const int num_digits = 8; // 显示 0~7
    
32. 
    
33.     // 单个数字块的尺寸（含内部点阵间隙）
    
34.     const int block_width  = 3 * DOT_SIZE + 2 * PADDING;
    
35.     const int block_height = 5 * DOT_SIZE + 4 * PADDING;
    
36. 
    
37.     // 整体窗口尺寸：每个块之间再加 PADDING 作为块间距
    
38.     int win_width  = grid_cols * block_width  + (grid_cols - 1) * PADDING;
    
39.     int win_height = grid_rows * block_height + (grid_rows - 1) * PADDING;
    
40. 
    
41.     SDL_Window* window = SDL_CreateWindow("2x4 3x5 Digit Matrix",
    
42.                                           SDL_WINDOWPOS_CENTERED,
    
43.                                           SDL_WINDOWPOS_CENTERED,
    
44.                                           win_width, win_height,
    
45.                                           SDL_WINDOW_SHOWN);
    
46.     if (!window) {
    
47.         fprintf(stderr, "SDL_CreateWindow Error: %s\n", SDL_GetError());
    
48.         SDL_Quit();
    
49.         return 1;
    
50.     }
    
51. 
    
52.     SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
    
53.     if (!renderer) {
    
54.         fprintf(stderr, "SDL_CreateRenderer Error: %s\n", SDL_GetError());
    
55.         SDL_DestroyWindow(window);
    
56.         SDL_Quit();
    
57.         return 1;
    
58.     }
    
59. 
    
60.     bool quit = false;
    
61.     SDL_Event e;
    
62. 
    
63.     while (!quit) {
    
64.         while (SDL_PollEvent(&e)) {
    
65.             if (e.type == SDL_QUIT) {
    
66.                 quit = true;
    
67.             }
    
68.         }
    
69. 
    
70.         // 白色背景
    
71.         SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
    
72.         SDL_RenderClear(renderer);
    
73. 
    
74.         // 绘制每个数字块
    
75.         for (int idx = 0; idx < num_digits; ++idx) {
    
76.             int row = idx / grid_cols;   // 当前数字在网格中的行
    
77.             int col = idx % grid_cols;   // 当前数字在网格中的列
    
78. 
    
79.             // 计算该数字块左上角坐标
    
80.             int block_x = col * (block_width + PADDING);
    
81.             int block_y = row * (block_height + PADDING);
    
82. 
    
83.             // 绘制该数字的 3x5 点阵
    
84.             for (int y = 0; y < 5; ++y) {
    
85.                 for (int x = 0; x < 3; ++x) {
    
86.                     if (digits[idx][y][x]) {
    
87.                         int px = block_x + x * (DOT_SIZE + PADDING);
    
88.                         int py = block_y + y * (DOT_SIZE + PADDING);
    
89.                         SDL_Rect r = {px, py, DOT_SIZE, DOT_SIZE};
    
90.                         SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255); // 黑色点亮
    
91.                         SDL_RenderFillRect(renderer, &r);
    
92.                     }
    
93.                 }
    
94.             }
    
95.         }
    
96. 
    
97.         SDL_RenderPresent(renderer);
    
98.         SDL_Delay(16);
    
99.     }
    
100. 
     
101.     SDL_DestroyRenderer(renderer);
     
102.     SDL_DestroyWindow(window);
     
103.     SDL_Quit();
     
104.     return 0;
     
105. }
     

复制代码

zzz19760225

1. 
   
2. #include <SDL2/SDL.h>
   
3. #include <stdio.h>
   
4. #include <stdlib.h>
   
5. #include <string.h>
   
6. #include <sys/stat.h>
   
7. #include <unistd.h> // for usleep
   
8. 
   
9. #define GRID_SIZE 16
   
10. #define CELL_SIZE 20
    
11. #define WINDOW_WIDTH  (GRID_SIZE * CELL_SIZE)
    
12. #define WINDOW_HEIGHT (GRID_SIZE * CELL_SIZE)
    
13. 
    
14. const char* filename = "16x16_1.txt";
    
15. 
    
16. int grid[GRID_SIZE][GRID_SIZE] = {0};
    
17. time_t last_mtime = 0;
    
18. 
    
19. // 创建默认文件（全0）
    
20. void create_default_file() {
    
21.     FILE* fp = fopen(filename, "w");
    
22.     if (!fp) {
    
23.         fprintf(stderr, "Cannot create default file %s\n", filename);
    
24.         return;
    
25.     }
    
26.     for (int y = 0; y < GRID_SIZE; y++) {
    
27.         for (int x = 0; x < GRID_SIZE; x++) {
    
28.             fputc('0', fp);
    
29.         }
    
30.         fputc('\n', fp);
    
31.     }
    
32.     fclose(fp);
    
33.     printf("Created default %s (all zeros).\n", filename);
    
34. }
    
35. 
    
36. // 加载位图文件到 grid
    
37. int load_bitmap() {
    
38.     FILE* fp = fopen(filename, "r");
    
39.     if (!fp) {
    
40.         printf("File %s not found.\n", filename);
    
41.         create_default_file();
    
42.         fp = fopen(filename, "r");
    
43.         if (!fp) return -1;
    
44.     }
    
45. 
    
46.     char line[32];
    
47.     int y = 0;
    
48.     while (fgets(line, sizeof(line), fp) && y < GRID_SIZE) {
    
49.         for (int x = 0; x < GRID_SIZE && line[x]; x++) {
    
50.             grid[y][x] = (line[x] == '1') ? 1 : 0;
    
51.         }
    
52.         y++;
    
53.     }
    
54.     fclose(fp);
    
55. 
    
56.     // 补全不足16行的情况（安全处理）
    
57.     for (; y < GRID_SIZE; y++) {
    
58.         for (int x = 0; x < GRID_SIZE; x++) {
    
59.             grid[y][x] = 0;
    
60.         }
    
61.     }
    
62. 
    
63.     // 获取当前修改时间
    
64.     struct stat st;
    
65.     if (stat(filename, &st) == 0) {
    
66.         last_mtime = st.st_mtime;
    
67.     }
    
68.     return 0;
    
69. }
    
70. 
    
71. // 渲染点阵
    
72. void render(SDL_Renderer* renderer) {
    
73.     SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
    
74.     SDL_RenderClear(renderer);
    
75. 
    
76.     for (int y = 0; y < GRID_SIZE; y++) {
    
77.         for (int x = 0; x < GRID_SIZE; x++) {
    
78.             SDL_Rect rect = { x * CELL_SIZE, y * CELL_SIZE, CELL_SIZE, CELL_SIZE };
    
79.             SDL_SetRenderDrawColor(renderer,
    
80.                 grid[y][x] ? 0 : 255,
    
81.                 grid[y][x] ? 0 : 255,
    
82.                 grid[y][x] ? 0 : 255,
    
83.                 255
    
84.             );
    
85.             SDL_RenderFillRect(renderer, &rect);
    
86.         }
    
87.     }
    
88. 
    
89.     // 可选：网格线
    
90.     SDL_SetRenderDrawColor(renderer, 200, 200, 200, 255);
    
91.     for (int i = 0; i <= GRID_SIZE; i++) {
    
92.         SDL_RenderDrawLine(renderer, i * CELL_SIZE, 0, i * CELL_SIZE, WINDOW_HEIGHT);
    
93.         SDL_RenderDrawLine(renderer, 0, i * CELL_SIZE, WINDOW_WIDTH, i * CELL_SIZE);
    
94.     }
    
95. 
    
96.     SDL_RenderPresent(renderer);
    
97. }
    
98. 
    
99. // 检查文件是否被修改
    
100. int file_modified() {
     
101.     struct stat st;
     
102.     if (stat(filename, &st) != 0) {
     
103.         // 文件被删除？当作已修改（下次加载会重建）
     
104.         return 1;
     
105.     }
     
106.     return (st.st_mtime != last_mtime);
     
107. }
     
108. 
     
109. int main(int argc, char* argv[]) {
     
110.     if (SDL_Init(SDL_INIT_VIDEO) != 0) {
     
111.         fprintf(stderr, "SDL_Init Error: %s\n", SDL_GetError());
     
112.         return 1;
     
113.     }
     
114. 
     
115.     SDL_Window* window = SDL_CreateWindow(
     
116.         "16x16 Dot Matrix Auto-Refresh Viewer",
     
117.         SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
     
118.         WINDOW_WIDTH, WINDOW_HEIGHT,
     
119.         SDL_WINDOW_SHOWN
     
120.     );
     
121.     if (!window) {
     
122.         fprintf(stderr, "SDL_CreateWindow Error: %s\n", SDL_GetError());
     
123.         SDL_Quit();
     
124.         return 1;
     
125.     }
     
126. 
     
127.     SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
     
128.     if (!renderer) {
     
129.         fprintf(stderr, "SDL_CreateRenderer Error: %s\n", SDL_GetError());
     
130.         SDL_DestroyWindow(window);
     
131.         SDL_Quit();
     
132.         return 1;
     
133.     }
     
134. 
     
135.     // 初次加载
     
136.     if (load_bitmap() != 0) {
     
137.         fprintf(stderr, "Failed to load bitmap.\n");
     
138.         SDL_DestroyRenderer(renderer);
     
139.         SDL_DestroyWindow(window);
     
140.         SDL_Quit();
     
141.         return 1;
     
142.     }
     
143.     render(renderer);
     
144. 
     
145.     int running = 1;
     
146.     SDL_Event e;
     
147.     const Uint32 CHECK_INTERVAL_MS = 500; // 每500毫秒检查一次
     
148.     Uint32 last_check = SDL_GetTicks();
     
149. 
     
150.     while (running) {
     
151.         while (SDL_PollEvent(&e)) {
     
152.             if (e.type == SDL_QUIT) {
     
153.                 running = 0;
     
154.             } else if (e.type == SDL_KEYDOWN) {
     
155.                 if (e.key.keysym.sym == SDLK_r) {
     
156.                     printf("Manual reload triggered.\n");
     
157.                     if (load_bitmap() == 0) render(renderer);
     
158.                 } else if (e.key.keysym.sym == SDLK_ESCAPE) {
     
159.                     running = 0;
     
160.                 }
     
161.             }
     
162.         }
     
163. 
     
164.         // 自动检查文件是否被外部修改
     
165.         Uint32 now = SDL_GetTicks();
     
166.         if (now - last_check >= CHECK_INTERVAL_MS) {
     
167.             last_check = now;
     
168.             if (file_modified()) {
     
169.                 printf("Detected change in %s, reloading...\n", filename);
     
170.                 if (load_bitmap() == 0) {
     
171.                     render(renderer);
     
172.                 }
     
173.             }
     
174.         }
     
175. 
     
176.         SDL_Delay(16); // ~60 FPS
     
177.     }
     
178. 
     
179.     SDL_DestroyRenderer(renderer);
     
180.     SDL_DestroyWindow(window);
     
181.     SDL_Quit();
     
182.     return 0;
     
183. }
     
184. 
     
185. //gcc -o 16x16点阵刷新1 16x16点阵刷新1.c -lSDL2
     

复制代码

编译后生成执行文件，运行执行文件会生成16x16_1.txt文本。
用nano修改16x16_1.txt，保存修改后，会对应点阵显示出变化。达到显存效应的需求

zzz19760225

16x16点阵全组合的鼠标点击自定义点阵选择，输出数值信息。

1. 
   
2. //gcc -o dotmatrix dotmatrix.c -lSDL2
   
3. 
   
4. #include <stdio.h>
   
5. #include <stdlib.h>
   
6. #include <SDL2/SDL.h>
   
7. 
   
8. #define WIDTH 16
   
9. #define HEIGHT 16
   
10. #define DOT_SIZE 30
    
11. #define MARGIN 20
    
12. #define WINDOW_WIDTH (WIDTH * DOT_SIZE + 2 * MARGIN)
    
13. #define WINDOW_HEIGHT (HEIGHT * DOT_SIZE + 2 * MARGIN)
    
14. #define FRAME_DELAY 50
    
15. 
    
16. // 自定义16进制字符映射（0~15）
    
17. const char* hex_map[16] = {
    
18.     "一", "二", "三", "四", "五", "六", "七", "八",
    
19.     "九", "十", "壹", "贰", "叁", "肆", "伍", "陆"
    
20. };
    
21. 
    
22. // 将点阵写入 2.txt
    
23. void save_dot_to_file(int dot[HEIGHT][WIDTH]) {
    
24.     FILE* fp = fopen("2.txt", "w");
    
25.     if (!fp) {
    
26.         fprintf(stderr, "无法创建文件 2.txt\n");
    
27.         return;
    
28.     }
    
29. 
    
30.     // 设置UTF-8编码（可选，Linux/macOS默认UTF-8）
    
31.     // Windows可能需要额外处理，但fopen默认ANSI；若需UTF-8可加BOM或用_setmode，此处简化
    
32.     // 我们直接写UTF-8字符串
    
33. 
    
34.     // 遍历256位，生成64个hex字符（从左上到右下，高位在前）
    
35.     for (int i = 0; i < 64; i++) {
    
36.         // 每个hex字符由4个bit组成
    
37.         int nibble = 0;
    
38.         for (int b = 0; b < 4; b++) {
    
39.             int bit_index = i * 4 + b; // 0 ~ 255
    
40.             int y = bit_index / WIDTH;
    
41.             int x = bit_index % WIDTH;
    
42.             if (y < HEIGHT && x < WIDTH && dot[y][x]) {
    
43.                 nibble |= (1 << (3 - b)); // 高位在前（bit0是最高位）
    
44.             }
    
45.         }
    
46.         fputs(hex_map[nibble], fp);
    
47.     }
    
48.     fputc('\n', fp);
    
49.     fclose(fp);
    
50. }
    
51. 
    
52. int main(int argc, char* argv[]) {
    
53.     if (SDL_Init(SDL_INIT_VIDEO) != 0) {
    
54.         printf("无法初始化SDL：%s\n", SDL_GetError());
    
55.         return -1;
    
56.     }
    
57. 
    
58.     SDL_Window* window = SDL_CreateWindow(
    
59.         "16x16 点阵编辑器（状态已保存至 2.txt）",
    
60.         SDL_WINDOWPOS_CENTERED,
    
61.         SDL_WINDOWPOS_CENTERED,
    
62.         WINDOW_WIDTH,
    
63.         WINDOW_HEIGHT,
    
64.         SDL_WINDOW_SHOWN
    
65.     );
    
66.     if (!window) {
    
67.         printf("无法创建窗口：%s\n", SDL_GetError());
    
68.         SDL_Quit();
    
69.         return -1;
    
70.     }
    
71. 
    
72.     SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
    
73.     if (!renderer) {
    
74.         printf("无法创建渲染器：%s\n", SDL_GetError());
    
75.         SDL_DestroyWindow(window);
    
76.         SDL_Quit();
    
77.         return -1;
    
78.     }
    
79. 
    
80.     int dot[HEIGHT][WIDTH] = {0};
    
81.     int running = 1;
    
82.     SDL_Event event;
    
83. 
    
84.     // 初始保存一次（全0）
    
85.     save_dot_to_file(dot);
    
86. 
    
87.     while (running) {
    
88.         while (SDL_PollEvent(&event)) {
    
89.             if (event.type == SDL_QUIT) {
    
90.                 running = 0;
    
91.             }
    
92.             else if (event.type == SDL_MOUSEBUTTONDOWN && event.button.button == SDL_BUTTON_LEFT) {
    
93.                 int mouse_x = event.button.x;
    
94.                 int mouse_y = event.button.y;
    
95. 
    
96.                 int grid_x = (mouse_x - MARGIN) / DOT_SIZE;
    
97.                 int grid_y = (mouse_y - MARGIN) / DOT_SIZE;
    
98. 
    
99.                 if (grid_x >= 0 && grid_x < WIDTH && grid_y >= 0 && grid_y < HEIGHT) {
    
100.                     dot[grid_y][grid_x] = 1 - dot[grid_y][grid_x];
     
101.                     // 状态改变，立即保存
     
102.                     save_dot_to_file(dot);
     
103.                 }
     
104.             }
     
105.         }
     
106. 
     
107.         // 清屏
     
108.         SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
     
109.         SDL_RenderClear(renderer);
     
110. 
     
111.         // 绘制点阵
     
112.         for (int y = 0; y < HEIGHT; y++) {
     
113.             for (int x = 0; x < WIDTH; x++) {
     
114.                 SDL_SetRenderDrawColor(renderer,
     
115.                     dot[y][x] ? 0 : 220,
     
116.                     dot[y][x] ? 0 : 220,
     
117.                     dot[y][x] ? 0 : 220,
     
118.                     255
     
119.                 );
     
120.                 SDL_Rect rect = {
     
121.                     MARGIN + x * DOT_SIZE,
     
122.                     MARGIN + y * DOT_SIZE,
     
123.                     DOT_SIZE - 2,
     
124.                     DOT_SIZE - 2
     
125.                 };
     
126.                 SDL_RenderFillRect(renderer, &rect);
     
127.             }
     
128.         }
     
129. 
     
130.         SDL_RenderPresent(renderer);
     
131.         SDL_Delay(FRAME_DELAY);
     
132.     }
     
133. 
     
134.     SDL_DestroyRenderer(renderer);
     
135.     SDL_DestroyWindow(window);
     
136.     SDL_Quit();
     
137.     return 0;
     
138. }
     

复制代码

可以鼠标点击图形输出，可以使用中文代表为对应16进制输出为2.txt，用cat 2.txt，可以查看。

1. 
   
2. 0=一，1=二，2=三，3=四，4=五，5=六，6=七，7=八，8=九，9=十，a=壹,b=贰,c=叁,d=肆,e=伍,f=陆,
   
3. 一一一一一一一一一一一一一一一一一一一一一三一一一三九一一伍九一一贰九一一壹一一一四九一一三九一一伍九一一一一一一一一一一一一一
   

复制代码

zzz19760225

两个程序，一个程序鼠标点击16x16点阵的自定义01字符16行，输出到2.txt，另一个程序读取2.txt，读取显示到16x16图形页面，是可以直接显示对接的。
鼠标点击的程序
16x16点阵点击输出二进制16行.c

1. 
   
2. //编译命令 gcc -o 16x16点阵点击输出二进制16行 16x16点阵点击输出二进制16行.c -lSDL2
   
3. #include <stdio.h>
   
4. #include <stdlib.h>
   
5. #include <SDL2/SDL.h>
   
6. 
   
7. #define WIDTH 16
   
8. #define HEIGHT 16
   
9. #define DOT_SIZE 30
   
10. #define MARGIN 20
    
11. #define WINDOW_WIDTH (WIDTH * DOT_SIZE + 2 * MARGIN)
    
12. #define WINDOW_HEIGHT (HEIGHT * DOT_SIZE + 2 * MARGIN)
    
13. #define FRAME_DELAY 50
    
14. 
    
15. // 将点阵以分行二进制形式（每行16个0/1）写入 2.txt
    
16. void save_dot_to_file(int dot[HEIGHT][WIDTH]) {
    
17.     FILE* fp = fopen("2.txt", "w");
    
18.     if (!fp) {
    
19.         fprintf(stderr, "无法创建文件 2.txt\n");
    
20.         return;
    
21.     }
    
22. 
    
23.     for (int y = 0; y < HEIGHT; y++) {
    
24.         for (int x = 0; x < WIDTH; x++) {
    
25.             fputc(dot[y][x] ? '1' : '0', fp);
    
26.         }
    
27.         fputc('\n', fp); // 每行结束后换行
    
28.     }
    
29.     fclose(fp);
    
30. }
    
31. 
    
32. int main(int argc, char* argv[]) {
    
33.     if (SDL_Init(SDL_INIT_VIDEO) != 0) {
    
34.         printf("无法初始化SDL：%s\n", SDL_GetError());
    
35.         return -1;
    
36.     }
    
37. 
    
38.     SDL_Window* window = SDL_CreateWindow(
    
39.         "16x16 点阵编辑器（二进制已保存至 2.txt，每行16位）",
    
40.         SDL_WINDOWPOS_CENTERED,
    
41.         SDL_WINDOWPOS_CENTERED,
    
42.         WINDOW_WIDTH,
    
43.         WINDOW_HEIGHT,
    
44.         SDL_WINDOW_SHOWN
    
45.     );
    
46.     if (!window) {
    
47.         printf("无法创建窗口：%s\n", SDL_GetError());
    
48.         SDL_Quit();
    
49.         return -1;
    
50.     }
    
51. 
    
52.     SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
    
53.     if (!renderer) {
    
54.         printf("无法创建渲染器：%s\n", SDL_GetError());
    
55.         SDL_DestroyWindow(window);
    
56.         SDL_Quit();
    
57.         return -1;
    
58.     }
    
59. 
    
60.     int dot[HEIGHT][WIDTH] = {0}; // 初始化全灭
    
61.     int running = 1;
    
62.     SDL_Event event;
    
63. 
    
64.     // 初始保存（全0）
    
65.     save_dot_to_file(dot);
    
66. 
    
67.     while (running) {
    
68.         while (SDL_PollEvent(&event)) {
    
69.             if (event.type == SDL_QUIT) {
    
70.                 running = 0;
    
71.             }
    
72.             else if (event.type == SDL_MOUSEBUTTONDOWN && event.button.button == SDL_BUTTON_LEFT) {
    
73.                 int mouse_x = event.button.x;
    
74.                 int mouse_y = event.button.y;
    
75. 
    
76.                 int grid_x = (mouse_x - MARGIN) / DOT_SIZE;
    
77.                 int grid_y = (mouse_y - MARGIN) / DOT_SIZE;
    
78. 
    
79.                 if (grid_x >= 0 && grid_x < WIDTH && grid_y >= 0 && grid_y < HEIGHT) {
    
80.                     dot[grid_y][grid_x] = 1 - dot[grid_y][grid_x];
    
81.                     save_dot_to_file(dot); // 状态改变，立即保存
    
82.                 }
    
83.             }
    
84.         }
    
85. 
    
86.         // 渲染画面
    
87.         SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255); // 白色背景
    
88.         SDL_RenderClear(renderer);
    
89. 
    
90.         for (int y = 0; y < HEIGHT; y++) {
    
91.             for (int x = 0; x < WIDTH; x++) {
    
92.                 // 亮：黑色；灭：浅灰色
    
93.                 Uint8 color = dot[y][x] ? 0 : 220;
    
94.                 SDL_SetRenderDrawColor(renderer, color, color, color, 255);
    
95.                 SDL_Rect rect = {
    
96.                     MARGIN + x * DOT_SIZE,
    
97.                     MARGIN + y * DOT_SIZE,
    
98.                     DOT_SIZE - 2,
    
99.                     DOT_SIZE - 2
    
100.                 };
     
101.                 SDL_RenderFillRect(renderer, &rect);
     
102.             }
     
103.         }
     
104. 
     
105.         SDL_RenderPresent(renderer);
     
106.         SDL_Delay(FRAME_DELAY);
     
107.     }
     
108. 
     
109.     // 清理资源
     
110.     SDL_DestroyRenderer(renderer);
     
111.     SDL_DestroyWindow(window);
     
112.     SDL_Quit();
     
113.     return 0;
     
114. }
     

复制代码

zzz19760225

第二个程序读取2.txt内容
16x16点阵点击输出二进制16行.c

1. 
   
2. #include <SDL2/SDL.h>
   
3. #include <stdio.h>
   
4. #include <stdlib.h>
   
5. #include <string.h>
   
6. #include <sys/stat.h>
   
7. #include <unistd.h> // for usleep
   
8. 
   
9. #define GRID_SIZE 16
   
10. #define CELL_SIZE 20
    
11. #define WINDOW_WIDTH  (GRID_SIZE * CELL_SIZE)
    
12. #define WINDOW_HEIGHT (GRID_SIZE * CELL_SIZE)
    
13. 
    
14. const char* filename = "2.txt";
    
15. 
    
16. int grid[GRID_SIZE][GRID_SIZE] = {0};
    
17. time_t last_mtime = 0;
    
18. 
    
19. // 创建默认文件（全0）
    
20. void create_default_file() {
    
21.     FILE* fp = fopen(filename, "w");
    
22.     if (!fp) {
    
23.         fprintf(stderr, "Cannot create default file %s\n", filename);
    
24.         return;
    
25.     }
    
26.     for (int y = 0; y < GRID_SIZE; y++) {
    
27.         for (int x = 0; x < GRID_SIZE; x++) {
    
28.             fputc('0', fp);
    
29.         }
    
30.         fputc('\n', fp);
    
31.     }
    
32.     fclose(fp);
    
33.     printf("Created default %s (all zeros).\n", filename);
    
34. }
    
35. 
    
36. // 加载位图文件到 grid
    
37. int load_bitmap() {
    
38.     FILE* fp = fopen(filename, "r");
    
39.     if (!fp) {
    
40.         printf("File %s not found.\n", filename);
    
41.         create_default_file();
    
42.         fp = fopen(filename, "r");
    
43.         if (!fp) return -1;
    
44.     }
    
45. 
    
46.     char line[32];
    
47.     int y = 0;
    
48.     while (fgets(line, sizeof(line), fp) && y < GRID_SIZE) {
    
49.         for (int x = 0; x < GRID_SIZE && line[x]; x++) {
    
50.             grid[y][x] = (line[x] == '1') ? 1 : 0;
    
51.         }
    
52.         y++;
    
53.     }
    
54.     fclose(fp);
    
55. 
    
56.     // 补全不足16行的情况（安全处理）
    
57.     for (; y < GRID_SIZE; y++) {
    
58.         for (int x = 0; x < GRID_SIZE; x++) {
    
59.             grid[y][x] = 0;
    
60.         }
    
61.     }
    
62. 
    
63.     // 获取当前修改时间
    
64.     struct stat st;
    
65.     if (stat(filename, &st) == 0) {
    
66.         last_mtime = st.st_mtime;
    
67.     }
    
68.     return 0;
    
69. }
    
70. 
    
71. // 渲染点阵
    
72. void render(SDL_Renderer* renderer) {
    
73.     SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
    
74.     SDL_RenderClear(renderer);
    
75. 
    
76.     for (int y = 0; y < GRID_SIZE; y++) {
    
77.         for (int x = 0; x < GRID_SIZE; x++) {
    
78.             SDL_Rect rect = { x * CELL_SIZE, y * CELL_SIZE, CELL_SIZE, CELL_SIZE };
    
79.             SDL_SetRenderDrawColor(renderer,
    
80.                 grid[y][x] ? 0 : 255,
    
81.                 grid[y][x] ? 0 : 255,
    
82.                 grid[y][x] ? 0 : 255,
    
83.                 255
    
84.             );
    
85.             SDL_RenderFillRect(renderer, &rect);
    
86.         }
    
87.     }
    
88. 
    
89.     // 可选：网格线
    
90.     SDL_SetRenderDrawColor(renderer, 200, 200, 200, 255);
    
91.     for (int i = 0; i <= GRID_SIZE; i++) {
    
92.         SDL_RenderDrawLine(renderer, i * CELL_SIZE, 0, i * CELL_SIZE, WINDOW_HEIGHT);
    
93.         SDL_RenderDrawLine(renderer, 0, i * CELL_SIZE, WINDOW_WIDTH, i * CELL_SIZE);
    
94.     }
    
95. 
    
96.     SDL_RenderPresent(renderer);
    
97. }
    
98. 
    
99. // 检查文件是否被修改
    
100. int file_modified() {
     
101.     struct stat st;
     
102.     if (stat(filename, &st) != 0) {
     
103.         // 文件被删除？当作已修改（下次加载会重建）
     
104.         return 1;
     
105.     }
     
106.     return (st.st_mtime != last_mtime);
     
107. }
     
108. 
     
109. int main(int argc, char* argv[]) {
     
110.     if (SDL_Init(SDL_INIT_VIDEO) != 0) {
     
111.         fprintf(stderr, "SDL_Init Error: %s\n", SDL_GetError());
     
112.         return 1;
     
113.     }
     
114. 
     
115.     SDL_Window* window = SDL_CreateWindow(
     
116.         "16x16 Dot Matrix Auto-Refresh Viewer",
     
117.         SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
     
118.         WINDOW_WIDTH, WINDOW_HEIGHT,
     
119.         SDL_WINDOW_SHOWN
     
120.     );
     
121.     if (!window) {
     
122.         fprintf(stderr, "SDL_CreateWindow Error: %s\n", SDL_GetError());
     
123.         SDL_Quit();
     
124.         return 1;
     
125.     }
     
126. 
     
127.     SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
     
128.     if (!renderer) {
     
129.         fprintf(stderr, "SDL_CreateRenderer Error: %s\n", SDL_GetError());
     
130.         SDL_DestroyWindow(window);
     
131.         SDL_Quit();
     
132.         return 1;
     
133.     }
     
134. 
     
135.     // 初次加载
     
136.     if (load_bitmap() != 0) {
     
137.         fprintf(stderr, "Failed to load bitmap.\n");
     
138.         SDL_DestroyRenderer(renderer);
     
139.         SDL_DestroyWindow(window);
     
140.         SDL_Quit();
     
141.         return 1;
     
142.     }
     
143.     render(renderer);
     
144. 
     
145.     int running = 1;
     
146.     SDL_Event e;
     
147.     const Uint32 CHECK_INTERVAL_MS = 500; // 每500毫秒检查一次
     
148.     Uint32 last_check = SDL_GetTicks();
     
149. 
     
150.     while (running) {
     
151.         while (SDL_PollEvent(&e)) {
     
152.             if (e.type == SDL_QUIT) {
     
153.                 running = 0;
     
154.             } else if (e.type == SDL_KEYDOWN) {
     
155.                 if (e.key.keysym.sym == SDLK_r) {
     
156.                     printf("Manual reload triggered.\n");
     
157.                     if (load_bitmap() == 0) render(renderer);
     
158.                 } else if (e.key.keysym.sym == SDLK_ESCAPE) {
     
159.                     running = 0;
     
160.                 }
     
161.             }
     
162.         }
     
163. 
     
164.         // 自动检查文件是否被外部修改
     
165.         Uint32 now = SDL_GetTicks();
     
166.         if (now - last_check >= CHECK_INTERVAL_MS) {
     
167.             last_check = now;
     
168.             if (file_modified()) {
     
169.                 printf("Detected change in %s, reloading...\n", filename);
     
170.                 if (load_bitmap() == 0) {
     
171.                     render(renderer);
     
172.                 }
     
173.             }
     
174.         }
     
175. 
     
176.         SDL_Delay(16); // ~60 FPS
     
177.     }
     
178. 
     
179.     SDL_DestroyRenderer(renderer);
     
180.     SDL_DestroyWindow(window);
     
181.     SDL_Quit();
     
182.     return 0;
     
183. }
     
184. 
     
185. //gcc -o 16x16点阵刷新1 16x16点阵刷新1.c -lSDL2
     

复制代码

运行编译后的执行程序，就可以对应电器开关一样，这边点击，那边对应显示。（好像没有什么意义！）

zzz19760225

linux mint22.2下，nasm汇编+SDL2的C语言图形库，做点阵位图的数字集，八进制无文字颜色代表集=八卦排序全组合，满编全十进制，阿拉伯数字，汉字数字，麻将，苏州数字，天干地支十二进制挪用等多十进制，百进制，千字文的千进制，阿拉伯数字组成的万进制和亿进制可能。

zzz19760225

寒夜孤星的6个bat批处理，通过AI自动信息通义千问，转为perl版。
6
第六种
han6.pl

1. 
   
2. #!/usr/bin/perl
   
3. use strict;      # 启用严格模式，强制声明变量
   
4. use warnings;    # 启用警告，帮助发现潜在错误
   
5. 
   
6. # 定义要排列的四个汉字
   
7. my @chars = ('寒', '夜', '孤', '星');
   
8. 
   
9. # 用于存储所有排列结果的数组
   
10. my @results;
    
11. 
    
12. # 递归函数：生成全排列
    
13. # 参数：
    
14. #    $ prefix     —— 当前已拼接的字符串（前缀）
    
15. #    $ remaining  —— 剩余可选字符的数组引用
    
16. sub permute {
    
17.     my ( $prefix, $remaining) = @_;
    
18. 
    
19.     # 如果剩余字符为空，说明已形成一个完整排列
    
20.     if (@$remaining == 0) {
    
21.         push @results, $prefix;   # 将结果保存到数组
    
22.         print " $prefix\n";        # 输出该排列（注意：原脚本前面有空格，这里已去除）
    
23.         return;
    
24.     }
    
25. 
    
26.     # 遍历剩余字符中的每一个位置
    
27.     for my $i (0 ..  $#{ $remaining}) {
    
28.         my @new_remaining = @$remaining;           # 复制剩余字符列表
    
29.         my $char = splice(@new_remaining, $i, 1);  # 取出第 i 个字符
    
30.         permute( $prefix . $char, \@new_remaining); # 递归：前缀加上该字符，剩余列表更新
    
31.     }
    
32. }
    
33. 
    
34. # 从空前缀和完整字符列表开始递归
    
35. permute("", \@chars);
    
36. 
    
37. # 输出总共有多少种排列方式（4! = 24）
    
38. print scalar(@results) . "种组合方式\n";
    
39. 
    
40. # 暂停程序，等待用户按回车（类似 Windows 的 pause）
    
41. <>;
    

复制代码

第六种输出结果

1. 
   
2. 寒夜孤星
   
3. 寒夜星孤
   
4. 寒孤夜星
   
5. 寒孤星夜
   
6. 寒星夜孤
   
7. 寒星孤夜
   
8. 夜寒孤星
   
9. 夜寒星孤
   
10. 夜孤寒星
    
11. 夜孤星寒
    
12. 夜星寒孤
    
13. 夜星孤寒
    
14. 孤寒夜星
    
15. 孤寒星夜
    
16. 孤夜寒星
    
17. 孤夜星寒
    
18. 孤星寒夜
    
19. 孤星夜寒
    
20. 星寒夜孤
    
21. 星寒孤夜
    
22. 星夜寒孤
    
23. 星夜孤寒
    
24. 星孤寒夜
    
25. 星孤夜寒
    
26. 24种组合方式
    

复制代码