请帮助改动一下代码

bmne

哪位大牛有点时间？麻烦给改一下下面的代码

现在的下面代码是：只输出指定混合后的不重复字符的行

./floor42C dlup 8 200
SIZE  =    37619853.69 G
RANGE =    0 .. 201065
PARTX =    187.10 G



要求：改变成，输出指定混合后的所有字符的混合的行。（其中里面的，指定位数、预设数据大小及文件个数。不动，保持原样）


floor42C.c

1. # include <stdio.h>
   
2. # include <stdlib.h>
   
3. # include <string.h>
   
4. 
   
5. typedef char kar;
   
6. typedef char *str;
   
7. typedef double dub;
   
8. typedef unsigned long long Int;
   
9. 
   
10. int COLLECT;
    
11. int SIZE;
    
12. int LENDIT;
    
13. int LENSTR;
    
14. int HEAD;
    
15. int *HAS;
    
16. Int FINISH;
    
17. Int MEKS;
    
18. Int GLOB;
    
19. str DAT;
    
20. str DIT;
    
21. str STR;
    
22. 
    
23. void gene (int);
    
24. void telle (int);
    
25. void test (void);
    
26. void explore (str);
    
27. void help (str);
    
28. void floor42 (int);
    
29. void init (str *);
    
30. void quit (int);
    
31. /* ____________________ MAIN ____________________ */
    
32. 
    
33. int main (int numa, str *para){
    
34.     if (numa < 4 || numa > 5) help (para[0]);
    
35.     init (para);
    
36.     if (numa == 4) test ();
    
37.     explore (para[4]);
    
38. }
    
39. 
    
40. /* _____________________ SUB _____________________ */
    
41. void init (str *para){
    
42.     COLLECT = atoi (para[2]);
    
43.     SIZE    = atoi (para[3]);
    
44.     LENDIT  = COLLECT + 1;
    
45.     str this      = para[1];
    
46.     int lenstr    = strlen (this);
    
47.     str it        = "dlup";
    
48.     int lenchar[] = { 10, 26, 26, 32 };
    
49.     int len       = 0;
    
50.     int pos       = 0;
    
51.     str CHAR[]    = {
    
52.         "0123456789",
    
53.         "abcdefghijklmnopqrstuvwxyz",
    
54.         "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
    
55.         "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~"
    
56.     };
    
57.     int indes[4];
    
58. 
    
59.     for (int i = 0; i < 4; i++) {
    
60.         for (int j = 0; j < lenstr; j++) {
    
61.             if (it[i] == this[j]) {
    
62.                 len         += lenchar[i];
    
63.                 indes[pos++] = i;
    
64.                 break;
    
65.             }
    
66.         }
    
67.     }
    
68. 
    
69.     LENSTR = len;
    
70.     STR = calloc (LENSTR + 1, sizeof(kar));
    
71.     for (int i = 0; i < pos; i++)
    
72.         strcat (STR, CHAR[indes[i]]);
    
73. } /* init */
    
74. 
    
75. void test (){
    
76.     telle (1);
    
77.     quit (0);
    
78. }
    
79. 
    
80. void quit (int n){
    
81.     free (STR);
    
82.     exit (n);
    
83. }
    
84. 
    
85. void explore (str part){
    
86.     telle (0);
    
87.     int n = atoi (part);
    
88.     if (n < 0 || n > MEKS) {
    
89.         printf ("ERROR: N = %d\t[N: 0 .. %llu]\n", n, MEKS);
    
90.         quit (1);
    
91.     }
    
92. 
    
93.     kar dit[LENDIT];
    
94.     dit[LENDIT - 1] = 0;
    
95.     DIT             = dit;
    
96.     int has[LENSTR];
    
97.     HAS = has;
    
98.     kar dat[LENSTR];
    
99.     DAT = dat;
    
100.     Int begin = GLOB * n;
     
101.     Int end   = begin + GLOB;
     
102.     if (end >= FINISH) end = FINISH + 1;
     
103. 
     
104.     for (Int i = begin; i < end; i++) {
     
105.         memset (has, 0, LENSTR * sizeof(int));
     
106.         gene (i);
     
107.         floor42 (HEAD);
     
108.     }
     
109. 
     
110.     free (STR);
     
111. 
     
112. } /* explore */
     
113. void telle (int TEST){
     
114.     Int size = COLLECT + 1;
     
115.     Int G    = 1024 * 1024 * 1024ULL;
     
116.     Int max  = SIZE * G / size; // B
     
117.     Int part = 1;
     
118.     dub toto;
     
119. 
     
120.     for (int i = LENSTR; i >= 0; i--) {
     
121.         part *= i;
     
122.         Int s = 1;
     
123.         for (int j = i; j > LENSTR - COLLECT; j--) s *= j;
     
124.         if (i == LENSTR) {
     
125.             toto = s * size / (dub)G;
     
126.             if (TEST) printf ("SIZE  =\t%.2f G\n", toto);
     
127.         }
     
128.         if (s <= max) {
     
129.             HEAD   = LENSTR - i;
     
130.             FINISH = part / i - 1;
     
131.             dub partX = s * size / (dub)G;
     
132.             GLOB = SIZE > toto ? 0 : SIZE / partX;
     
133.             dub M1 = toto / (partX * GLOB);
     
134.             Int M2 = M1;
     
135.             MEKS = SIZE > toto ? FINISH : M2 - (M1 == M2);
     
136. 
     
137.             if (GLOB) partX *= GLOB;
     
138.             if (TEST) {
     
139.                 printf ("RANGE =\t0 .. %llu\n", MEKS);
     
140.                 printf ("PARTX =\t%.2f G\n", partX);
     
141.             }
     
142. 
     
143.             break;
     
144.         }
     
145.     }
     
146. } /* telle */
     
147. 
     
148. void gene (int n){
     
149.     int low = LENSTR - HEAD + 1;
     
150.     int mod[HEAD];
     
151. 
     
152.     for (int i = 1; i <= HEAD; i++) {
     
153.         int val = 1;
     
154.         for (int j = low; j <= LENSTR - i; j++) val *= j;
     
155.         mod[i - 1] = val;
     
156.     }
     
157.     int head[HEAD];
     
158.     int posi[LENSTR];
     
159. 
     
160.     memset (posi, 0, LENSTR * sizeof(int));
     
161. 
     
162.     for (int i = 0; i < HEAD; i++) {
     
163.         int val = n / mod[i];
     
164.         int k   = 0;
     
165.         for (int j = 0; j < LENSTR; j++) {
     
166.             if (posi[j]) continue;
     
167.             if (k++ == val) {
     
168.                 posi[j] = 1;
     
169.                 head[i] = j;
     
170.                 DIT[i]  = STR[j];
     
171.             }
     
172.         }
     
173.         n %= mod[i];
     
174.     }
     
175. 
     
176.     int h = HEAD;
     
177.     for (int i = 0; i < LENSTR; i++) {
     
178.         int ok = 1;
     
179.         for (int j = 0; j < HEAD; j++)
     
180.             if (i == head[j]) {
     
181.                 ok--; break;
     
182.             }
     
183. 
     
184.         if (ok) DAT[h++] = STR[i];
     
185.     }
     
186. 
     
187. } /* gene */
     
188. 
     
189. void floor42 (int indes){
     
190.     if (indes == COLLECT) {
     
191.         puts (DIT);
     
192.         return;
     
193.     }
     
194. 
     
195.     for (int i = HEAD; i < LENSTR; i++) {
     
196.         if (HAS[i]) continue;
     
197.         HAS[i]     = 1;
     
198.         DIT[indes] = DAT[i];
     
199.         floor42 (indes + 1);
     
200.         HAS[i] = 0;
     
201.     }
     
202. }
     
203. 
     
204. void help (str app){
     
205.     printf ("USE:\ntest:\n%s str chars size[G]\n", app);
     
206.     printf ("%s dlu 8 6\n", app);
     
207.     printf ("run:\n%s str chars size[G] part > partX\n", app);
     
208.     printf ("%s dlu 8 6 0 > part0\n", app);
     
209.     exit (1);
     
210. }
     

复制代码

辛苦！

bmne

回复 1# rubyish



大牛

实在没法，只好打扰下，不礼貌请理解，谢谢！

好几天了，没人来回复（本不想打扰你的）。我不知道什么原因。猜想是难度大

请大牛有点功夫的时候，帮助

实在没时间就算了

又要辛苦一下！

bruceteen

回复 2# bmne

你连程序要干什么都不肯讲？（只说了要怎么改）
就是肯花5元钱去街边找个算命的瞎子，也猜不出来呀

bmne

回复 3# bruceteen


谢谢回复

原来你没看明白啊（仔细看，应该是能明白的）。不好意思，抱歉

二楼的大牛，只是我不好意思打扰人家(实属无奈，才提人家的名字的)。他肯定能看明白的，因为一楼的代码是他写的

rubyish

回复 1# bmne
KBD ~~
maybe:

1. USE:        ./catalunya CHARS SIZE [PARTX]
   
2. TEST:        ./catalunya 8 200
   
3. RUN:        ./catalunya 8 200 0
   

复制代码

shishi ~~
catalunya.c:

1. # include <stdio.h>
   
2. # include <stdlib.h>
   
3. 
   
4. typedef char MY;
   
5. typedef unsigned My;
   
6. typedef unsigned long long my;
   
7. typedef struct { my glob, split, last; } our;
   
8. 
   
9. My KARA, SIZE;
   
10. our gimme (My);
    
11. void explore (MY**);
    
12. void pick (my, MY*);
    
13. void help (MY*);
    
14. 
    
15. # define TEST  (numa == 3)
    
16. # define BAD(N) (atoi (para[N]) <= 0)
    
17. # define ERROR (numa < 3) || BAD (1) || BAD (2)
    
18. 
    
19. int main (int numa, MY **para){
    
20.     if (ERROR) help (para[0]);
    
21.     KARA = atoi (para[1]);
    
22.     SIZE = atoi (para[2]);
    
23.     if (TEST) gimme (5);
    
24.     else explore (para);
    
25. }
    
26. /* _____________________ SUB _____________________ */
    
27. 
    
28. # define SHRIEK  33
    
29. # define TWIDDLE 126
    
30. # define ELEM    94
    
31. 
    
32. our gimme (My test){
    
33.     my last = 1;
    
34. 
    
35.     for (My i = 0; i < KARA; i++) last *= ELEM;
    
36.     my sizeB = (KARA + 1) * last;
    
37.     my sizeG = sizeB / (1024 * 1024 * 1024);
    
38.     my glob  = SIZE * 1024 * 1024 * 1024LLU / (KARA + 1);
    
39.     my split = sizeB / (glob * (KARA + 1));
    
40.     if (SIZE >= sizeG) SIZE = sizeG, glob = last, split = 0;
    
41. 
    
42.     if (test) {
    
43.         printf ("\nSIZE  = %llu G\n", sizeG);
    
44.         printf ("LINES = %llu\n", last);
    
45.         printf ("RANGE = 0 .. %llu\n", split);
    
46.         printf ("PARTX = %d G\n", SIZE);
    
47.         printf ("LINE  = %llu\n\n", glob);
    
48.     }
    
49.     return (our) {glob, split, last };
    
50. } /* gimme */
    
51. 
    
52. void explore (MY **para){
    
53.     if (atoi (para[3]) < 0) help (para[0]);
    
54.     our dat  = gimme (0);
    
55.     my split = atoi (para[3]);  // OK
    
56. 
    
57.     if (split > dat.split) return;
    
58. 
    
59.     my start = dat.glob * split;
    
60.     MY this[KARA + 1];
    
61.     pick (start, this);
    
62. 
    
63.     My tail = KARA - 1;
    
64.     my stop = start + dat.glob;
    
65.     if (stop > dat.last) stop = dat.last;
    
66. 
    
67.     for (my i = start; i < stop; i++) {
    
68.         puts (this);
    
69.         if (this[tail]++ < TWIDDLE) continue;
    
70.         for (int j = tail; j >= 0; j--) {
    
71.             if (this[j]++ < TWIDDLE) break;
    
72.             else this[j] = SHRIEK;
    
73.         }
    
74.     }
    
75. } /* explore */
    
76. 
    
77. void pick (my indes, MY *kara){
    
78.     my var[KARA];
    
79. 
    
80.     var[KARA - 1] = 1;
    
81.     for (int i = KARA - 2; i >= 0; i--)
    
82.         var[i] = var[i + 1] * ELEM;
    
83.     kara[0]        = SHRIEK + indes / var[0];
    
84.     kara[KARA - 1] = SHRIEK + indes % ELEM;
    
85.     kara[KARA]     = 0;
    
86.     for (My i = 1; i < KARA - 1; i++)
    
87.         kara[i] = SHRIEK + indes / var[i] % ELEM;
    
88. 
    
89. }
    
90. 
    
91. void help (MY *app){
    
92.     printf ("\n[ CHARS > 0, SIZE > 0, PARTX >= 0 ]\n");
    
93.     printf ("USE:\t%s CHARS SIZE [PARTX]\n", app);
    
94.     printf ("TEST:\t%s 8 200\n", app);
    
95.     printf ("RUN:\t%s 8 200 0\n", app);
    
96.     exit (1);
    
97. }
    
98. 
    

复制代码

bmne

回复 5# rubyish



大牛

终于把你给盼来了

我的严重失误，让你辛苦了。我后悔中，对不起，对不起

是这样的：
必须人为按要求指定混合后的全部数据输出( 请注意，必须是按需要可以灵活指定混合   如   dl    du    dlu   lu   dlup   请参考floor42C.c中的第47行  )

假设我现在要求只有  纯数字+小写字母（ 简称 dl ）  的混合后的全部数据输出

你现在已有的 floor42C.c 实现不了我的要求
TEST:   ./floor42C dl 8 100
RUN:    ./floor42C dl 8 100 0      (这里只选单一    0    明白意思即可)
因为上面这个RUN，只是输出混合dl的不重复字符的8位的行


我现在的本帖子的要求是：输出8位混合后的全部数据的行，即，比如混合dl
TEST:   ./catalunya dl 8 100
RUN:    ./catalunya dl 8 100 0

请重新修改你现在的  catalunya.c    或  floor42C.c   来满足新的要求



（唉！我一楼想简单了，懊恼中）

rubyish

回复 6# bmne

zai shishi ~~

karachi.c

1. # include "karachi.h"
   
2. 
   
3. typedef struct { my glob, split, laast; } our;
   
4. 
   
5. MY *TEMPLATE[] = {
   
6.     "0123456789",                 
   
7.     "abcdefghijklmnopqrstuvwxyz",
   
8.     "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
   
9.     "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~"
   
10. };
    
11. My LENTEM[] = { 10, 26, 26, 32 };
    
12. My KARA, SIZE, ITEM;
    
13. 
    
14. our gimme (My);
    
15. sub explore ( MY**, My* );
    
16. sub pick ( my, MY*, My*, MY* );
    
17. sub help (MY*);
    
18. sub init ( MY**, My* );
    
19. 
    
20. # define TEST  ($numa == 4)
    
21. # define BAD(N) (atoi($para[N]) <= 0)
    
22. # define ERROR ($numa < 4) || BAD(2) || BAD(3)
    
23. 
    
24. int main( int $numa, MY **$para ) {
    
25.     if (ERROR) help( $para[0] );
    
26.     My $indes[4] = { 4, 4, 4, 4 };
    
27.     init( $para, $indes );
    
28.     if (TEST) gimme(5);
    
29.     else explore( $para, $indes );
    
30. }
    
31. /* _____________________ SUB _____________________ */
    
32. 
    
33. sub init ( MY **$para, My *$indes ) {
    
34.     KARA           = atoi( $para[2] );
    
35.     SIZE           = atoi( $para[3] );
    
36.     MY *$template  = $para[1];
    
37.     My $lentem     = strlen($template);
    
38.     MY *$it        = "dlup";
    
39.     My $pos        = 0;
    
40. 
    
41.     for ( My $i = 0; $i < 4; $i++ ) {
    
42.         for ( My $j = 0; $j < $lentem; $j++ ) {
    
43.             if ( $it[$i] == $template[$j] ) {
    
44.                 ITEM += LENTEM[$i];
    
45.                 $indes[ $pos++ ] = $i;
    
46.                 last;
    
47.             }
    
48.         }
    
49.     }
    
50. }
    
51. /* init */
    
52. 
    
53. our gimme ( My $test ) {
    
54.     my $laast = 1;
    
55. 
    
56.     for ( My $i = 0; $i < KARA; $i++ ) $laast *= ITEM;
    
57.     my $sizeB = ( KARA + 1 ) * $laast;
    
58.     my $sizeG = $sizeB / ( 1024 * 1024 * 1024 );
    
59.     my $glob  = SIZE * 1024 * 1024 * 1024LLU / ( KARA + 1 );
    
60.     my $split = $sizeB / ( $glob * ( KARA + 1 ) );
    
61.     if ( SIZE >= $sizeG ) SIZE = $sizeG, $glob = $laast, $split = 0;
    
62. 
    
63.     if ($test) {
    
64.         printf( "\nSIZE  = %llu G\n",  $sizeG );
    
65.         printf( "LINES = %llu\n",      $laast );
    
66.         printf( "RANGE = 0 .. %llu\n", $split );
    
67.         printf( "PARTX = %d G\n",      SIZE );
    
68.         printf( "LINE  = %llu\n\n",    $glob );
    
69.     }
    
70.     return (our) { $glob, $split, $laast };
    
71. }
    
72. /* gimme */
    
73. 
    
74. sub explore ( MY **$para, My *$istr ) {
    
75.     if ( atoi( $para[4] ) < 0 ) help( $para[0] );
    
76.     our $dat = gimme(0);
    
77.     my $split = atoi( $para[4] ); // OK
    
78. 
    
79.     if ( $split > $dat.split ) return;
    
80.     MY $template[ ITEM + 1 ];
    
81.     $template[0] = 0;
    
82.     for ( My $i = 0; $i < 4; $i++ ) {
    
83.         if ( $istr[$i] == 4 ) last;
    
84.         strcat( $template, TEMPLATE[ $istr[$i] ] );
    
85.     }
    
86. 
    
87.     my $start = $dat.glob * $split;
    
88.     MY $this[ KARA + 1 ];
    
89.     My $posi[KARA];
    
90.     pick( $start, $this, $posi, $template );
    
91. 
    
92.     My $tail = KARA - 1;
    
93.     my $stop = $start + $dat.glob;
    
94.     if ( $stop > $dat.laast ) $stop = $dat.laast;
    
95.     My $end = ITEM - 1;
    
96.     for ( my $i = $start; $i < $stop; $i++ ) {
    
97.         say($this);
    
98.         if ( $posi[$tail]++ < $end ) {
    
99.             $this[$tail] = $template[ $posi[$tail] ];
    
100.             next;
     
101.         }
     
102.         for ( int $j = $tail; $j >= 0; $j-- ) {
     
103.             if ( $posi[$j]++ < $end ) {
     
104.                 $this[$j] = $template[ $posi[$j] ];
     
105.                 last;
     
106.             }
     
107.             else {
     
108.                 $posi[$j] = 0;
     
109.                 $this[$j] = $template[0];
     
110.             }
     
111.         }
     
112.     }
     
113. }
     
114. /* explore */
     
115. 
     
116. sub pick ( my $indes, MY *$kara, My *$posi, MY *$template ) {
     
117.     my $var[KARA];
     
118. 
     
119.     $var[ KARA - 1 ] = 1;
     
120.     for ( int $i = KARA - 2; $i >= 0; $i-- )
     
121.         $var[$i] = $var[ $i + 1 ] * ITEM;
     
122.     $posi[0] = $indes / $var[0];
     
123.     $posi[ KARA - 1 ] = $indes % ITEM;
     
124.     for ( My $i = 1; $i < KARA - 1; $i++ )
     
125.         $posi[$i] = $indes / $var[$i] % ITEM;
     
126.     for ( My $i = 0; $i < KARA; $i++ )
     
127.         $kara[$i] = $template[ $posi[$i] ];
     
128.     $kara[KARA] = 0;
     
129. }
     
130. 
     
131. sub help (MY *$app) {
     
132.     printf("\n[ CHARS > 0, SIZE > 0, PARTX >= 0 ]\n");
     
133.     printf( "USE:\t%s TYPE CHARS SIZE [PARTX]\n", $app );
     
134.     printf( "TEST:\t%s dlu 8 200\n",              $app );
     
135.     printf( "RUN:\t%s dlu 8 200 0\n",             $app );
     
136.     exit(1);
     
137. }
     
138. 
     

复制代码

karachi.h:

1. # include <stdio.h>
   
2. # include <stdlib.h>
   
3. # include <string.h>
   
4. typedef char MY;
   
5. typedef unsigned My;
   
6. typedef unsigned long long my;
   
7. # define last break
   
8. # define next continue
   
9. # define say  puts
   
10. # define sub  void
    

复制代码

karachi.c, karachi.h ==> same folder.

bmne

回复 7# rubyish



大牛

还是那句话，你牛气冲天啊。大智若愚，技术严谨，追求完美，贴近老百姓，绝不炫技！

我敢相信，这个帖子，肯定又是一个经典！

截了一张图给大牛看看效率，快的吓死人。效率是我的最爱！

感谢感谢

我不编辑成255（这样做有点自私），还是敞开让喜欢看的人，进来能够看到此贴，找到各自的需求吧


（另外，我在此版块重新另发一贴，再次重新求助一个新问题，请继续帮助下
           只求助这一次，我保证若不是把我逼疯了，决不再张口第二次。我清楚求人不易，求大牛更难）

rubyish

回复 8# bmne

duiyu d, l, u, dlup you jiasu.

palermo.c:

1. # include "palermo.h"
   
2. 
   
3. MY *TEMPLATE[] = {
   
4.     "0123456789",                 
   
5.     "abcdefghijklmnopqrstuvwxyz",
   
6.     "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
   
7.     "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~"
   
8. };
   
9. My LENTEM[] = { 10, 26, 26, 32 };
   
10. My KARA, SIZE, ITEM;
    
11. 
    
12. # define TEST  ($numa == 4)
    
13. # define BAD(N) (atoi ($para[N]) <= 0)
    
14. # define ERROR ($numa < 4) || BAD(2) || BAD(3)
    
15. 
    
16. int main( int $numa, MY **$para ) {
    
17.     if (ERROR) help( $para[0] );
    
18.     My $indes[] = { 4, 4, 4, 4 };
    
19.     init( $para, $indes );
    
20.     if (TEST) gimme(NULL);
    
21.     else explore( $para, $indes );
    
22. }
    
23. /* _____________________ SUB _____________________ */
    
24. 
    
25. sub init ( MY **$para, My *$indes ) {
    
26.     KARA           = atoi( $para[2] );
    
27.     SIZE           = atoi( $para[3] );
    
28.     MY *$template  = $para[1];
    
29.     My $lentem     = strlen($template);
    
30.     MY *$it        = "dlup";
    
31.     My $pos        = 0;
    
32. 
    
33.     for ( My $i = 0; $i < 4; $i++ ) {
    
34.         for ( My $j = 0; $j < $lentem; $j++ ) {
    
35.             if ( $it[$i] == $template[$j] ) {
    
36.                 ITEM += LENTEM [$i];
    
37.                 $indes[ $pos++ ] = $i;
    
38.                 last;
    
39.             }
    
40.         }
    
41.     }
    
42. }
    
43. /* init */
    
44. 
    
45. sub gimme (our *$dat) {
    
46.     my $laast = 1;
    
47. 
    
48.     for ( My $i = 0; $i < KARA; $i++ ) $laast *= ITEM;
    
49.     my $sizeB = ( KARA + 1 ) * $laast;
    
50.     my $sizeG = $sizeB / ( 1024 * 1024 * 1024 );
    
51.     my $glob  = SIZE * 1024 * 1024 * 1024LLU / ( KARA + 1 );
    
52.     my $split = $sizeB / ( $glob * ( KARA + 1 ) );
    
53.     if ( SIZE >= $sizeG )
    
54.         SIZE = $sizeG, $glob = $laast, $split = 0;
    
55. 
    
56.     if ( !$dat ) {
    
57.         printf( "\nSIZE  = %llu G\n",  $sizeG );
    
58.         printf( "LINES = %llu\n",      $laast );
    
59.         printf( "RANGE = 0 .. %llu\n", $split );
    
60.         printf( "PARTX = %d G\n",      SIZE );
    
61.         printf( "LINE  = %llu\n\n",    $glob );
    
62.         return;
    
63.     }
    
64.    
    
65.     *$dat = (our) { $glob, $split, $laast };
    
66. } /* gimme */
    
67. 
    
68. sub explore ( MY **$para, My *$istr ) {
    
69.     if ( atoll( $para[4] ) < 0 ) help( $para[0] );
    
70.     our $dat;
    
71.     gimme(&$dat);
    
72.     my $split = atoll( $para[4] ); // OK
    
73.    
    
74.     if ( $split > $dat.split ) return;
    
75. 
    
76.     My $item = 0;
    
77.     for ( My $i = 0; $i < 4; $i++ )
    
78.         if ( $istr[$i] < 4 ) $item++;
    
79. 
    
80.     my $start = $dat.glob * $split;
    
81.     my $stop  = $start + $dat.glob;
    
82.    
    
83.     if ( $stop > $dat.laast ) $stop = $dat.laast;
    
84.     Our $dit = { $start, $stop };
    
85.    
    
86.     if ( $item == 2 || $item == 3 || $istr[0] == 3 ) {
    
87.         sub1( $dit, $istr );
    
88.     }
    
89.     else {
    
90.         MY $head[] = { '0', 'a', 'A', '!' };
    
91.         My $i = $item == 1 ? $istr[0] : 3;
    
92.         sub2( $dit, $head[$i] );
    
93.     }
    
94. } /* explore */
    
95. 
    
96. sub sub1 ( Our $dat, My *$istr ) {
    
97.     MY $template[ ITEM + 1 ];
    
98. 
    
99.     $template[0] = 0;
    
100.     for ( My $i = 0; $i < 4; $i++ ) {
     
101.         if ( $istr[$i] == 4 ) last;
     
102.         strcat( $template, TEMPLATE[ $istr[$i] ] );
     
103.     }
     
104. 
     
105.     MY $this[ KARA + 1 ];
     
106.     My $posi[KARA];
     
107.     pick( $dat.start, $this, $posi, $template );
     
108. 
     
109.     My $end  = ITEM - 1;
     
110.     My $tail = KARA - 1;
     
111. 
     
112.     for ( my $i = $dat.start; $i < $dat.stop; $i++ ) {
     
113.         say($this);
     
114.         if ( $posi[$tail]++ < $end ) {
     
115.             $this[$tail] = $template[ $posi[$tail] ];
     
116.             next;
     
117.         }
     
118.         for ( int $j = $tail; $j >= 0; $j-- ) {
     
119.             if ( $posi[$j]++ < $end ) {
     
120.                 $this[$j] = $template[ $posi[$j] ];
     
121.                 last;
     
122.             }
     
123.             else {
     
124.                 $posi[$j] = 0;
     
125.                 $this[$j] = $template[0];
     
126.             }
     
127.         }
     
128.     }
     
129. } /* sub1 */
     
130. 
     
131. sub sub2 ( Our $dat, MY $A) {
     
132.     MY $template[ITEM];
     
133. 
     
134.     for ( My $i = 0; $i < ITEM; $i++ )
     
135.         $template[$i] = $A + $i;
     
136. 
     
137.     MY $this[ KARA + 1 ];
     
138.     My $posi[KARA];
     
139.     pick( $dat.start, $this, $posi, $template );
     
140.     MY $B    = $A + ITEM - 1;
     
141.     My $tail = KARA - 1;
     
142.     for ( my $i = $dat.start; $i < $dat.stop; $i++ ) {
     
143.         say($this);
     
144.         if ( $this[$tail]++ < $B ) next;
     
145.         for ( int $j = $tail; $j >= 0; $j-- ) {
     
146.             if ( $this[$j]++ < $B ) last;
     
147.             else $this[$j] = $A;
     
148.         }
     
149.     }
     
150. } /* sub2 */
     
151. 
     
152. sub pick ( my $indes, MY *$kara, My *$posi, MY *$template ) {
     
153.     my $var[KARA];
     
154. 
     
155.     $var[ KARA - 1 ] = 1;
     
156.     for ( int $i = KARA - 2; $i >= 0; $i-- )
     
157.         $var[$i] = $var[ $i + 1 ] * ITEM;
     
158. 
     
159.     $posi[0] = $indes / $var[0];
     
160.     $posi[ KARA - 1 ] = $indes % ITEM;
     
161. 
     
162.     for ( My $i = 1; $i < KARA - 1; $i++ )
     
163.         $posi[$i] = $indes / $var[$i] % ITEM;
     
164.     for ( My $i = 0; $i < KARA; $i++ )
     
165.         $kara[$i] = $template[ $posi[$i] ];
     
166.     $kara[KARA] = 0;
     
167. }
     
168. 
     
169. sub help (MY *$app) {
     
170.     printf( "\n[ CHARS > 0, SIZE > 0, PARTX >= 0 ] \n" );
     
171.     printf( "USE:\t%s TYPE CHARS SIZE [PARTX]\n", $app );
     
172.     printf( "TEST:\t%s dlu 8 200\n",              $app );
     
173.     printf( "RUN:\t%s dlu 8 200 0\n",             $app );
     
174.     exit(1);
     
175. }
     
176. 
     

复制代码

palermo.h:

1. # include <stdio.h>
   
2. # include <stdlib.h>
   
3. # include <string.h>
   
4. 
   
5. typedef char MY;
   
6. typedef unsigned My;
   
7. typedef unsigned long long my;
   
8. typedef struct { my glob, split, laast; } our;
   
9. typedef struct { my start, stop; } Our;
   
10. 
    
11. # define last break
    
12. # define next continue
    
13. # define say  puts
    
14. # define sub  void
    
15. 
    
16. sub gimme (our*);
    
17. sub explore (MY**, My*);
    
18. sub sub1 (Our, My*);
    
19. sub sub2 (Our, MY);
    
20. sub pick (my, MY*, My*, MY*);
    
21. sub help (MY*);
    
22. sub init (MY**, My*);
    
23. 
    
24. 
    

复制代码

bmne

回复 9# rubyish


谢谢大牛的完美

感动

刚试了下。仍然继续测试纯数字，估计硬件的限制，感觉提速不明显了。辛苦！

到此吧。这个速度效率已经打败我知道的所有各种形式的代码（包括收费的软件）  no.1

谢谢、谢谢！