අපැහැදිලි සී කේත තරගය 2006. කරුණාකර sykes2.c පැහැදිලි කරන්න

මෙම සී වැඩසටහන ක්‍රියාත්මක වන්නේ කෙසේද?

main(_){_^448&&main(-~_);putchar(--_%64?32|-~7[__TIME__-_/8%8][">'txiZ^(~z?"-48]>>";;;====~$::199"[_*2&8|_/64]/(_&2?1:8)%8&1:10);}

එය සම්පාදනය කර ඇති ආකාරයටම (පරීක්ෂා කර ඇත gcc 4.6.3). එය සම්පාදනය කරන කාලය මුද්‍රණය කරයි. මගේ පද්ධතියේ:

    !!  !!!!!!              !!  !!!!!!              !!  !!!!!! 
    !!  !!  !!              !!      !!              !!  !!  !! 
    !!  !!  !!              !!      !!              !!  !!  !! 
    !!  !!!!!!    !!        !!      !!    !!        !!  !!!!!! 
    !!      !!              !!      !!              !!  !!  !! 
    !!      !!              !!      !!              !!  !!  !! 
    !!  !!!!!!              !!      !!              !!  !!!!!!

මූලාශ්‍රය: සයික්ස් 2 - එක් පේළියක ඔරලෝසුවක් , සයික්ස් 2 කතෘ ඉඟි කරයි

සමහර ඉඟි: පෙරනිමියෙන් සම්පාදනය කිරීමේ අනතුරු ඇඟවීම් නොමැත. සම්පාදනය කර -Wall, පහත අනතුරු ඇඟවීම් විමෝචනය වේ:

sykes2.c:1:1: warning: return type defaults to ‘int’ [-Wreturn-type]
sykes2.c: In function ‘main’:
sykes2.c:1:14: warning: value computed is not used [-Wunused-value]
sykes2.c:1:1: warning: implicit declaration of function ‘putchar’ [-Wimplicit-function-declaration]
sykes2.c:1:1: warning: suggest parentheses around arithmetic in operand of ‘|’ [-Wparentheses]
sykes2.c:1:1: warning: suggest parentheses around arithmetic in operand of ‘|’ [-Wparentheses]
sykes2.c:1:1: warning: control reaches end of non-void function [-Wreturn-type]

අපි එය අපැහැදිලි කරමු.

ඉන්ඩෙන්ටින්:

main(_) {
    _^448 && main(-~_);
    putchar(--_%64
        ? 32 | -~7[__TIME__-_/8%8][">'txiZ^(~z?"-48] >> ";;;====~$::199"[_*2&8|_/64]/(_&2?1:8)%8&1
        : 10);
}

මෙම අවුල නිරාකරණය කිරීම සඳහා විචල්යයන් හඳුන්වා දීම:

main(int i) {
    if(i^448)
        main(-~i);
    if(--i % 64) {
        char a = -~7[__TIME__-i/8%8][">'txiZ^(~z?"-48];
        char b = a >> ";;;====~$::199"[i*2&8|i/64]/(i&2?1:8)%8;
        putchar(32 | (b & 1));
    } else {
        putchar(10); // newline
    }
}

-~i == i+1ද්වි-අනුපූරක නිසා බව සලකන්න . ඒ නිසා, අපට තිබේ

main(int i) {
    if(i != 448)
        main(i+1);
    i--;
    if(i % 64 == 0) {
        putchar('\n');
    } else {
        char a = -~7[__TIME__-i/8%8][">'txiZ^(~z?"-48];
        char b = a >> ";;;====~$::199"[i*2&8|i/64]/(i&2?1:8)%8;
        putchar(32 | (b & 1));
    }
}

දැන්, a[b]එය සමානb[a] බව සලකන්න , සහ -~ == 1+වෙනස නැවත යොදන්න :

main(int i) {
    if(i != 448)
        main(i+1);
    i--;
    if(i % 64 == 0) {
        putchar('\n');
    } else {
        char a = (">'txiZ^(~z?"-48)[(__TIME__-i/8%8)[7]] + 1;
        char b = a >> ";;;====~$::199"[(i*2&8)|i/64]/(i&2?1:8)%8;
        putchar(32 | (b & 1));
    }
}

පුනරාවර්තනය ලූපයක් බවට පරිවර්තනය කිරීම සහ තව ටිකක් සරල කිරීමකින් සොරකම් කිරීම:

// please don't pass any command-line arguments
main() {
    int i;
    for(i=447; i>=0; i--) {
        if(i % 64 == 0) {
            putchar('\n');
        } else {
            char t = __TIME__[7 - i/8%8];
            char a = ">'txiZ^(~z?"[t - 48] + 1;
            int shift = ";;;====~$::199"[(i*2&8) | (i/64)];
            if((i & 2) == 0)
                shift /= 8;
            shift = shift % 8;
            char b = a >> shift;
            putchar(32 | (b & 1));
        }
    }
}

මෙය පුනරාවර්තනයකට එක් අක්ෂරයක් ප්‍රතිදානය කරයි. සෑම 64 වන අක්‍ෂරයකින්ම එය නව රේඛාවක් ප්‍රතිදානය කරයි. එසේ නොමැති නම්, එය ප්‍රතිදානය කළ යුත්තේ කුමක් දැයි සොයා ගැනීමට දත්ත වගු යුගලයක් භාවිතා කරන අතර 32 (අකුරු අවකාශයක්) හෝ 33 (අ !) අක්‍ෂර ඇතුළත් කරයි . පළමු වගුව ( ">'txiZ^(~z?") යනු එක් එක් අක්ෂරවල පෙනුම විස්තර කරන බිට්මැප් 10 ක කට්ටලයක් වන අතර දෙවන වගුව ( ";;;====~$::199") බිට්මැප් වෙතින් පෙන්වීමට සුදුසු බිට් තෝරා ගනී.

දෙවන වගුව

දෙවන වගුව පරීක්ෂා කිරීමෙන් ආරම්භ කරමු int shift = ";;;====~$::199"[(i*2&8) | (i/64)];. i/64රේඛා අංකය (6 සිට 0 දක්වා) වන අතර i*2&8එය 8 iff i4, 5, 6 හෝ 7 mod 8 වේ.

if((i & 2) == 0) shift /= 8; shift = shift % 8i%8වගු අගයේ ඉහළ අෂ්ටක ඉලක්කම් ( = 0,1,4,5 සඳහා) හෝ අඩු අෂ්ටක ඉලක්කම් ( i%8= 2,3,6,7 සඳහා) තෝරා ගනී . මාරුවීමේ වගුව මේ ආකාරයෙන් පෙනේ:

row col val
6   6-7 0
6   4-5 0
6   2-3 5
6   0-1 7
5   6-7 1
5   4-5 7
5   2-3 5
5   0-1 7
4   6-7 1
4   4-5 7
4   2-3 5
4   0-1 7
3   6-7 1
3   4-5 6
3   2-3 5
3   0-1 7
2   6-7 2
2   4-5 7
2   2-3 3
2   0-1 7
1   6-7 2
1   4-5 7
1   2-3 3
1   0-1 7
0   6-7 4
0   4-5 4
0   2-3 3
0   0-1 7

හෝ වගු ආකාරයෙන්

00005577
11775577
11775577
11665577
22773377
22773377
44443377

කතුවරයා පළමු වගු ඇතුළත් කිරීම් දෙක සඳහා ශුන්‍ය ටර්මිනේටරය භාවිතා කළ බව සලකන්න (හොර රහසේ!).

මෙය සැලසුම් කර ඇත්තේ කොටස් හතක සංදර්ශනයකින් පසුව වන අතර 7s හිස්ව ඇත. එබැවින්, පළමු වගුවේ ඇතුළත් කිරීම් මඟින් දැල්වෙන කොටස් අර්ථ දැක්විය යුතුය.

පළමු වගුව

__TIME__යනු පෙර සැකසුම්කරු විසින් අර්ථ දක්වා ඇති විශේෂ සාර්ව ය. එය පෙර සැකසුම ක්‍රියාත්මක කළ වේලාව අඩංගු ස්වරූපයෙන් නියත නියතයක් දක්වා විහිදේ "HH:MM:SS". එහි හරියටම අක්ෂර 8 ක් ඇති බව නිරීක්ෂණය කරන්න. 0-9 ට ASCII අගයන් 48 සිට 57 දක්වා :ඇති අතර ASCII අගය 58 ක් ඇති බව සලකන්න. ප්‍රතිදානය එක් පේළියකට අක්ෂර 64 ක් වන අතර එමඟින් අක්ෂරයකට අක්ෂර 8 ක් ඉතිරි වේ __TIME__.

7 - i/8%8මේ අනුව එහි දර්ශකය __TIME__වර්තමානයේ ප්‍රතිදානය වේ ( 7-අවශ්‍ය වන්නේ අප iපහළට ගමන් කරන නිසාය ). ඉතින්, ප්‍රතිදානය වීමේ tස්වභාවය __TIME__.

aආදානය මත පදනම්ව ද්විමය වශයෙන් පහත සඳහන් දේ සමාන වේ t.

0 00111111
1 00101000
2 01110101
3 01111001
4 01101010
5 01011011
6 01011111
7 00101001
8 01111111
9 01111011
: 01000000

සෑම අංකයක්ම අපගේ කොටස් හතක සංදර්ශකය තුළ දැල්වෙන කොටස් විස්තර කරන බිටු සිතියමක් වේ. අක්ෂර සියල්ලම 7-බිට් ASCII බැවින්, ඉහළ බිට් සෑම විටම නිෂ්කාශනය වේ. මේ අනුව, 7කාණ්ඩ වගුවේ සෑම විටම හිස් ලෙස මුද්‍රණය වේ. දෙවන වගුව 7හිස් ලෙස s සමඟ පෙනේ :

000055  
11  55  
11  55  
116655  
22  33  
22  33  
444433  

ඒ නිසා, උදාහරණයක් විදිහට, 4ය 01101010(බිටු 1, 3, 5, 6 කට්ටලයක්), ලෙස මුද්රණය කරන

----!!--
!!--!!--
!!--!!--
!!!!!!--
----!!--
----!!--
----!!--

අපි කේතය සැබවින්ම තේරුම් ගෙන ඇති බව පෙන්වීමට, මෙම වගුව සමඟ ප්‍රතිදානය ටිකක් සකස් කරමු:

  00  
11  55
11  55
  66  
22  33
22  33
  44

මෙය කේතනය කර "?;;?==? '::799\x07"ඇත. කලාත්මක අරමුණු සඳහා, අපි අක්ෂර කිහිපයකට 64 ක් එකතු කරන්නෙමු (අඩු බිටු 6 පමණක් භාවිතා කරන බැවින් මෙය ප්‍රතිදානයට බලපාන්නේ නැත); මෙය ලබා දෙයි "?{{?}}?gg::799G"(8 වන අක්‍ෂරය භාවිතා නොකරන බව සලකන්න, එබැවින් අපට අවශ්‍ය ඕනෑම දෙයක් සෑදිය හැකිය). අපගේ නව වගුව මුල් කේතයට ඇතුළත් කිරීම:

main(_){_^448&&main(-~_);putchar(--_%64?32|-~7[__TIME__-_/8%8][">'txiZ^(~z?"-48]>>"?{{?}}?gg::799G"[_*2&8|_/64]/(_&2?1:8)%8&1:10);}

අපිට ලැබෙනවා

          !!              !!                              !!   
    !!  !!              !!  !!  !!  !!              !!  !!  !! 
    !!  !!              !!  !!  !!  !!              !!  !!  !! 
          !!      !!              !!      !!                   
    !!  !!  !!          !!  !!      !!              !!  !!  !! 
    !!  !!  !!          !!  !!      !!              !!  !!  !! 
          !!              !!                              !!   

අපි බලාපොරොත්තු වුනා වගේ. එය මුල් පිටපත තරම් solid න පෙනුමක් නොවේ, එය කතුවරයා තමා කළ වගුව භාවිතා කිරීමට තෝරාගත්තේ මන්දැයි පැහැදිලි කරයි.

පහසු කියවීම සඳහා මෙය සංයුති කරමු:

main(_){
  _^448&&main(-~_);
  putchar((--_%64) ? (32|-(~7[__TIME__-_/8%8])[">'txiZ^(~z?"-48]>>(";;;====~$::199")[_*2&8|_/64]/(_&2?1:8)%8&1):10);
}

එබැවින්, කිසිදු තර්කයකින් තොරව එය ධාවනය කිරීම, _ (සාම්ප්‍රදායිකව argc) වේ 1. (negative ණ බිට්වේස් නොට් ) හි ප්‍රති main()result -(~_)ලය පසුකරමින් පුනරාවර්තන ලෙස එය හඳුන්වනු ඇත, _එබැවින් සැබවින්ම එය පුනරාවර්තන 448 ක් (කොන්දේසියක් ඇති තැන පමණක් _^448 == 0) යයි.

එය ගතහොත්, එය අක්ෂර 7 64 ක පුළුල් රේඛා මුද්‍රණය කරනු ඇත (පිටත තෘතීය තත්වය සහ 448/64 == 7). එබැවින් එය ටිකක් පිරිසිදු කරන්නෙමු.

main(int argc) {
  if (argc^448) main(-(~argc));
  if (argc % 64) {
    putchar((32|-(~7[__TIME__-argc/8%8])[">'txiZ^(~z?"-48]>>(";;;====~$::199")[argc*2&8|argc/64]/(argc&2?1:8)%8&1));
  } else putchar('\n');
}

දැන්, 32ASCII අවකාශය සඳහා දශම වේ. එය එක්කෝ අවකාශයක් මුද්‍රණය කරයි හෝ '!' (33 යනු '!', එබැවින් අවසානයේ ' &1'). මැද ඇති පිපිරුම කෙරෙහි අවධානය යොමු කරමු:

-(~(7[__TIME__-argc/8%8][">'txiZ^(~z?"-48]) >>
     (";;;====~$::199"[argc*2&8|argc/64]) / (argc&2?1:8) % 8

තවත් පෝස්ටරයක් ​​පැවසූ පරිදි, __TIME__වැඩසටහන සඳහා සම්පාදනය කරන වේලාව වන අතර එය නූලකි, එබැවින් යම් සංඛ්‍යා අංක ගණිතයක් සිදුවෙමින් පවතී, මෙන්ම අරාව ග්‍රාහක ද්විපාර්ශවික වීමෙන් වාසි ලබා ගනී: a [b] යනු b [a] ට සමාන වේ. අක්ෂර අරා සඳහා.

7[__TIME__ - (argc/8)%8]

මෙය පළමු අක්ෂර 8 න් එකක් තෝරා ගනු ඇත __TIME__. මෙය පසුව සුචිගත කරනු ලැබේ [">'txiZ^(~z?"-48](අක්ෂර 0-9 අක්ෂර 48-57 දශම). මෙම නූලෙහි අක්ෂර ඔවුන්ගේ ASCII අගයන් සඳහා තෝරාගෙන තිබිය යුතුය. ASCII කේත හැසිරවීම මෙම ප්‍රකාශනය හරහා අඛණ්ඩව සිදු වන අතර එහි ප්‍රති ing ලයක් ලෙස '' හෝ '!' චරිතයේ ග්ලයිෆස් තුළ ඇති ස්ථානය අනුව.

අනෙක් විසඳුම් වලට එකතු කිරීම -~xසමාන වන්නේ x+1එයට ~xසමාන වන බැවිනි (0xffffffff-x). මෙය (-1-x)2s අනුපූරකය හා සමාන -~xවේ -(-1-x) = x+1.

මම හැකි තරම් මොඩියුලෝ අංක ගණිතය අවලංගු කර පුනරාවර්තනය ඉවත් කළෙමි

int pixelX, line, digit ;
for(line=6; line >= 0; line--){
  for (digit =0; digit<8; digit++){
    for(pixelX=7;pixelX > 0; pixelX--){ 
        putchar(' '| 1 + ">'txiZ^(~z?"["12:34:56"[digit]-'0'] >> 
          (";;;====~$::199"[pixel*2 & 8  | line] / (pixelX&2 ? 1 : 8) ) % 8 & 1);               
    }
  }
  putchar('\n');
}

එය තව ටිකක් පුළුල් කිරීම:

int pixelX, line, digit, shift;
char shiftChar;
for(line=6; line >= 0; line--){
    for (digit =0; digit<8; digit++){
        for(pixelX=7;pixelX >= 0; pixelX--){ 
            shiftChar = ";;;====~$::199"[pixelX*2 & 8 | line];
            if (pixelX & 2)
                shift = shiftChar & 7;
            else
                shift = shiftChar >> 3;     
            putchar(' '| (">'txiZ^(~z?"["12:34:56"[digit]-'0'] + 1) >> shift & 1 );
        }

    }
    putchar('\n');
}