Most Pointed Reaction

もっとも集中した反応

受賞者：Don Yang

Line wrap

Highlight

                                           #define r(R) R"()"
                          /*[*/#include  /**/<stdio.h>
                      #include<math.h>/*!![crc=0f527cd2]*/
                   float I,bu,k,i,F,u,U,K,O;char o[5200];int
              #define R(U) (sizeof('U')==1||sizeof(U"1"[0])==1)
            h=0,t=-1,m=80,n=26,d,g,p=0,q=0,v=0,y=112,x=40;  float
           N(float/*x*/_){g=1<<30;d=-~d*1103515245&--g;return  d*_
          /g;}void/**/w(int/**/_){if(t<0){for(g=0;g<5200;o[g++   ]=
          0);for(;g;o[g+79]=10)g-=80;for(t=37;g<62;o[80+g++]=32)   ;
         }if(m&&o[h*80+m-1]==10){for(g=0;g<79;o[t*80+g++]=0){}o[t
         ++*80+g]=10;t%=64;n+=2;I=N(70)+5;if(n>30&&(I-x)*(I-x)+n*
        n>1600&&R()){O=0;F=(x=0x1!=sizeof(' '))?k=1+N(2),i=12-k+N(
        8),N(4):(k=17+N(5),i=0,r()[0]?O=.1:  0);for(u=U=-.05;u<32;
        U=k+i+i*.5*sin((u+=.05)+F))for( K=0   ;K< U;K+=.1)if((bu=K*
       sin(u/5),g=I+cos( u/5) *K)>=0&&g  <     79  )o[g+(int)(t+44+
       bu*(.5-(bu>0?3*O:  O)   ) )%64*  80      ]  =32;x*=02//* */2
      -1;n=O+x?n=I+(x?0   :N     (k)-   k           /2),g=(t+42  )%
      64,m=-~g%64,x?g=m          =-~        m%64:0  ,n>5?o[g*80   +
     n-3]=o[m*80+n-3]=       0:   0              ,n <75?o[g*80+n
     +2]=o[m*80+n+2]=0   :0:0;                      x=I;}h=-~h%64
    ;m=0;}putchar((g=o [h*                          80+m++])?g:_);
   if(g){w(_);}}void W                               (const char*_
  ){for(;*_;w(*_++));}                               int main(int a
  ,char**_){while(a--)d              +=_[a          ]-(char*)0;W( \
 "#include<stdio.h>typed"             "e"         "f\40int\40O;v"
 "oid o(O _){putchar(_);}O"                    "\40main(){O"  ""
"*_[512],**p=_,**d,b,q;for(b=0;b"        "++<512;p=_+q)_[q"    \
"=(p-_+1)*9%512]=(O*)p;") ;      for(;(g= getchar())-EOF;p=
q){q=p;for(v=512;p-q-g&&q-p-              g;  v--)q=-~q*9%512
;W("o(");if(p>q)w(y),w(45);w(                      40);w(y^=20
);w(075);for(a=0;a<v;a++)w(42);                      for(W("(O**"
 );a--;w(42)){}w(41);w(y^024);w(                      41);if(p<=q)w(
   45),w(y^20);W(");");}for(a=7;a-6                      ;W(a<6?"{;}":""
      ))for(a  =0;a  <6 &&   !o[h*80+m                       +a];a++){}W("r"
         "etu"  /*J   */       "rn+0;}\n"                             );return
             /*                      "#*/0                                   ;}

引用元：https://www.ioccc.org/2015/yang/prog.c

審査員・作者による説明：https://www.ioccc.org/2015/yang/hint.html

動作

メッセージを標準入力に与えると、アスキーアートなC言語コードを出力する。

$ gcc -std=c90 -o prog prog.c -lm

$ echo Hello | ./prog
                                                              #include<stdio.h>
typedef int O;void o(O _){putchar(_);}O main(){O*_[512],**p=_,**d,b,q;for(b=0;b
++<512;p=_+q)_[q=(p-_+1)*9%512]=(O*)p;o((d=************************************
****************************************************(O*************************
*****************************************************************)p)-p);o((p=**
*******************************************************************************
*******************************************************************************
*******************************************************************************
      ******************         **********************************************
        **************            *********************************************
          **********              *********************************************
            ******                ************(O*******************************
             ****                **********************************************
              *                 ***********************************************
                                ***********************************************
                              *************************************************
*                            **************************************************
**                         ****************************************************
                             **************************************************
                                   ********************************************
                                       *************)d)-d);o(p-(d=*************
                                         **************************************
                                          *************************************
                                           ***********    *********************
                                           *******          *******************
     ***                                  ******            *******************
********                              ********              *******************
********                              *******               *******************
********                               ****                 *******************
********              *                 **                 ********************
********             ***                                  *********************
*********            *****                              ***********************
*********           *******                            ************************
**********         **********                        **************************
************     ****(O****                            ************************
*********************                                        ******************
*****************                                                **************
**************                                                      ***********
*************                                                        **********
************                                                          *********
************                                                          *********
 ************                  ***              ****                 **********
   **************            *****              **********       **************
     **********              *****              *******************************
       ******                *****              *******************************
        ****                ******              *******************************
         **                 *******             *******************************
                           ********            ********************************
                         *********)            p));o((p=***********************
                        ************          *(O******************************
                      ********)d)-d);o      ((d=*******************************
                         ******************************************************
                              *************************************************
                                  *********************************************
                                    *******************************************
                                     ******************************************
                                      ****************    *********************
                                      ************          ****************(O*
 **              ***                 ***********            *******************
***              *****              **********              *******************
***              *****                *******               *******************
***              *****                 ****                 *******************
***              ******                 **                 ********************
***             ********                                  *********************
****            **********                              ***********************
*****          ************                            ************************
******        ***************                        **************************
*****)p     )-p);o(d-(p=***                            ************************
*********************                                        ******************
*****************                                                **************
**************                                                      ***********
*************                                                        **********
************                                                          *********
************                                                          *********
 ************                  ***              ****                 ****(O****
   **************            *****              **********       **************
     **********              *****              *******************************
       ******                *****              *******************************
        ****                ******              *******************************
         **                 *******             ***************************)d))
                           ;return+            0;}

これを保存してコンパイル・実行すると、元のメッセージが出てくる。

$ echo Hello | ./prog > tmp.c

$ gcc -o tmp tmp.c

$ ./tmp
Hello

アスキーアートは、どういうC/C++の仕様としてコンパイルしたかに依存して変わる。

C89/C90としてコンパイルした場合は、上記と同じ、ヒトデの形。

$ gcc -std=c90 -o prog_c90 prog.c -lm

$ echo A | ./prog_c90
                                                              #include<stdio.h>
typedef int O;void o(O _){putchar(_);}O main(){O*_[512],**p=_,**d,b,q;for(b=0;b
++<512;p=_+q)_[q=(p-_+1)*9%512]=(O*)p;o((d=************************************
*******************************************************************************
*******************************************************************************
*******************************************************************************
*******************************************************************************
*******************************************************************************
******************************************** ************(O*************** ****
*****************************************         *******************         *
****************************************            **************            *
****************************************              **********              *
****************************************                *******               *
*****************************************                ****                 *
******************************************                 *                 **
*******************************************                                 ***
********************************************                               ****
*********************************************                            ******
*******************)p)-p);o((p=****************                         *******
*********************************************                             *****
***************************************
***********************************
*********************************
********************************
*******************************
*******************************
 ************(O****         ****                 ****             ****
   **************            *******      ***********             ***********
     **********              ************************             *************
       ******                ************************             *************
        ****                *************************             *************
         **                 *************************             *************
                           **************************            **************
                         *****************)d)-d);{;}{;           }return+0;}

C99の場合は、ヒトデに目が入る。

$ gcc -std=c99 -o prog_c99 prog.c -lm

$ echo A | ./prog_c99
                                                              #include<stdio.h>
typedef int O;void o(O _){putchar(_);}O main(){O*_[512],**p=_,**d,b,q;for(b=0;b
++<512;p=_+q)_[q=(p-_+1)*9%512]=(O*)p;o((d=************************************
*******************************************************************************
*******************************************************************************
*******************************************************************************
*************************************************   ***************************
***********************************************         ******************
**********************************************            **************
*************(O*******************************              **********
**********************************************                *******
***********************************************                *****
************************************************                **
*************************************************
**************************************************
***************************************************
*****************************************************                         *
***************************************************
**************************************)p)-p);
o((p=************************************                     *    *
***************************************
**************************************
*************************************
*************************************
 ******************         **********                 ****             ****
   **************            *************      ***********             *******
     **********              ******(O**********************             *******
       ******                ******************************             *******
        ****                *******************************             *******
         **                 *******************************             *******
                           ********************************            ********
                         ***********************************           ********
                        *************************************         *********
                      *****)d)-d);return+0;}

C++98の場合は、団子の形。

$ g++ -O3 -std=c++98 -o prog_cpp98 prog.c -lm

$ echo A | ./prog_cpp98
                                                              #include<stdio.h>
typedef int O;void o(O _){putchar(_);}O main(){O*_[512],**p=_,**d,b,q;for(b=0;b
++<512;p=_+q)_[q=(p-_+1)*9%512]=(O*)p;o((d=************************************
*******************************************************************************
*******************************************************************************
*******************************************************************************
*******************************************************************************
*******************************************************************************
********************************************************(O*********************
*******************************************************************************
*******************************************************************************
*******************************************************************************
*******************************************************************************
*******************************************************************************
********************************                  *****************************
************)p)-p);o((p=***                           *************************
************************                                 **********************
**********************                                     ********************
*********************                                        ******************
********************                                          *****************
*******************                                            ****************
*******************                             *    *         ****************
******************                              *    *         **(O************
******************                                             ****************
*******************                                            ****************
*********************                                        ******************
*************************                                **********************
*******************************                   *****************************
*************************************************************)d)-d);return+0;}

C++11の場合は、ただの円。

$ g++ -O3 -std=c++11 -o prog_cpp11 prog.c -lm

$ echo A | ./prog_cpp11
                                                              #include<stdio.h>
typedef int O;void o(O _){putchar(_);}O main(){O*_[512],**p=_,**d,b,q;for(b=0;b
++<512;p=_+q)_[q=(p-_+1)*9%512]=(O*)p;o((d=************************************
*******************************************************************************
*******************************************************************************
*******************************************************************************
*******************************************************************************
*******************************************************************************
********************************************************(O*********************
*******************************************************************************
************              *****************************************************
********                      *************************************************
*****                            **********************************************
***                                ********************************************
*                                    ******************************************
                                      *****************************************
                                       ****************************************
                                        ***************************************
                                        ******)p)-p);o((p=*********************
                                        ***************************************
                                         **************************************
                                         **************************************
                                        ***************************************
                                        ***************************************
                                        ***************************************
                                       *********************************(O*****
                                      *****************************************
*                                    *****************************
***                                ***************************
*****                            **************************
********                      ****************************
************              ******************************
*******************************************************
******************)d)-d);return+0;}

C11の場合は、アスキーアートを消す。

$ gcc -std=c11 -o prog_c11 prog.c -lm

$ echo A | ./prog_c11
                                                              #include<stdio.h>
typedef int O;void o(O _){putchar(_);}O main(){O*_[512],**p=_,**d,b,q;for(b=0;b
++<512;p=_+q)_[q=(p-_+1)*9%512]=(O*)p;o((d=************************************
*******************************************************************************
*******************************************************************************
*******************************************************************************
*******************************************************************************
*******************************************************************************
********************************************************(O*********************
*******************************************************************************
*******************************************************************************
*******************************************************************************
*******************************************************************************
*******************************************************************************
*************************************************************************)p)-p)
;o((p=*************************************************************************
*******************************************************************************
*******************************************************************************
*******************************************************(O**********************
*******************************************************************************
*******************************************************************************
*******************************************************************************
*****************************)d)-d);return+0;}

解説

コード形状はCLANNADの伊吹風子。ヒトデが好きという設定のため、それに合わせて、ヒトデのアスキーアートが出力される。また、出力にポインタ参照の*が多数含まれているのは、sea star（ヒトデ）とC star（ポインタ参照）を掛けた洒落。

C/C++のバージョンを見分けるトリックは次の通り。

CとC++を見分けるには、sizeof('U')の値を調べる。Cでは'U'はint型なので、sizeof('U')は4や8になる。C++では'U'はchar型なので、sizeof('U')は1になる。
C++98とC++11を見分けるには、#define r(R) R"()"というマクロをr()[0]と呼び出したときの値を調べる。C++98ではマクロの引数が空なのでRが無視され、"()"という文字列の先頭の文字（開きカッコ）を取り出す。C++11ではR"()"がraw文字列リテラルとなり、()はデリミタとして無視されるので、空の文字列とみなされる。よってr()[0]はNUL文字の0を取り出す。
C90/C99とC11を見分けるには、#define R(U) sizeof(U"1"[0])==1というマクロをR()と呼び出したときの値を調べる。C90/C99では引数が空なのでUは無視され、sizeof("1"[0])==1となり、これはchar型のsizeofなので1。C11ではU"..."がconst char32_t`型の配列になるので、この式の値は4となる。
C90とC99を見分けるには、一行コメントの対応状況を使う。次の式は、一行コメントのないC90では2 / 2 - 1とみなされて0となり、一行コメントのあるC99では2 - 1なので1と解釈される。

2 //* */2
- 1

見落としがちだが、生成コードも実は結構興味深い。先頭の2行で、512要素のポインタの配列の中で、ポインタを512回たどると元の位置にもどる輪を作っている。文字ごとに***...*でポインタを何度もたどり、配列先頭からの差の整数をASCIIコードとして出力する、というコードになっている。

実行のたびにアスキーアートが変わるのは、time()をシードとした乱数ではなく、ASLRをシードとして使っているとのこと。賢い。cygwinではASLRが効かないので、コマンドライン引数でシードを指定することもできる。

同作者の慣習として、コードに自分自身のCRC32が埋め込まれている（3行目）。また、開発の様子を撮影したと称するspoiler.htmlも添付されている。

賞名は[[2015/endoh1]]と対称的になっている。