您的任务是实现在分数与代码大小之间取得平衡的Tetris策略。

在此版本的游戏中，四面体旋转并从上方掉入20行10列的网格中。跌落时，它们无法水平旋转或移动。像往常一样，当下落的碎片到达网格底部时，或者当进一步的向下运动会导致与已经占据的正方形发生碰撞时，下落的碎片就会停止。

当n水平线完全填满时，它们同时塌陷，网格n顶部重新填充了空线，并且分数增加了2 ⁿ -1点。对于n= 1,2,3,4，分别是1,3,7,15点。线条消失后，某些块可能仍漂浮在空中（没有“ 重力链反应 ”）。

如果当前棋子没有足够的空间显示在所需位置，网格将被清除，当前棋子将被忽略，并且游戏将当前的下一棋子继续。对此没有任何惩罚。

您应该阅读样片流，并决定如何旋转它们以及将它们放到哪里。前瞻的下一块（只有一个）是正确的：你可以看看一块i+1回应之前i，但你必须决定命运的i看着面前i+2。除了输入的最后一部分之外，没有其他可用的预读功能。

Tetromino类型及其旋转按照下表进行编码：

        type 0    1    2    3    4    5    6
             O    I    Z    J    L    S    T
            ┌────┬────┬────┬────┬────┬────┬────┐
 rotation 0 │##  │#   │##  │ #  │#   │ ## │### │
            │##  │#   │ ## │ #  │#   │##  │ #  │
            │    │#   │    │##  │##  │    │    │
            │    │#   │    │    │    │    │    │
            ├────┼────┼────┼────┼────┼────┼────┤
          1 │##  │####│ #  │### │  # │#   │#   │
            │##  │    │##  │  # │### │##  │##  │
            │    │    │#   │    │    │ #  │#   │
            │    │    │    │    │    │    │    │
            ├────┼────┼────┼────┼────┼────┼────┤
          2 │##  │#   │##  │##  │##  │ ## │ #  │
            │##  │#   │ ## │#   │ #  │##  │### │
            │    │#   │    │#   │ #  │    │    │
            │    │#   │    │    │    │    │    │
            ├────┼────┼────┼────┼────┼────┼────┤
          3 │##  │####│ #  │#   │### │#   │ #  │
            │##  │    │##  │### │#   │##  │##  │
            │    │    │#   │    │    │ #  │ #  │
            │    │    │    │    │    │    │    │
            └────┴────┴────┴────┴────┴────┴────┘

输入是二进制的-字节序列，其余数除以7时应解释为OIZJLST四位数。它们的发生概率大致相同（但由于256不是7的倍数，因此前几种类型可能会更频繁地出现，但是这可以忽略不计）。输入可以来自标准输入或来自名为“ i”的文件，也可以作为参数传递。只要确保遵守先行限制，就可以一次读取所有输入。

输出也是二进制的-与输入长度相同的字节序列。它可以是stdout或名为“ o”的文件，也可以是函数的结果。每个字节编码r*16 + x，其中r是所需的旋转数，并且x是已旋转的tetromino的最左边的方块应从该列开始的从0开始的索引。这些r和x必须是有效的，即0 ≤ r ≤ 3和0 ≤ x ≤ 10-w，其中w是相应块的宽度。

您的程序必须具有确定性-给定相同的输入，它必须产生完全相同的输出。只要是常量播种，就可以使用PRNG。

总分是游戏得分减去代码大小（以字节为单位）。请使用以下文件（伪随机噪声的64kiB）作为输入：https ://gist.github.com/ngn/857bf2c99bfafc649b8eaa1e489e75e4/raw/880f29bd790638aa17f51229c105e726bce60235/i

以下python2 / python3脚本从当前目录读取文件“ i”和“ o”，重播游戏并打印分数（请记住从分数中减去代码大小）：

a = [0] * 23 # grid (1square=1bit, 1row=1int, LSB is left, 3 empty rows on top)
#      O     I         Z       J       L       S       T        tetrominoes
t = [[[3,3],[1,1,1,1],[3,6],  [2,2,3],[1,1,3],[6,3],  [7,2]  ],
     [[3,3],[15],     [2,3,1],[7,4],  [4,7],  [1,3,2],[1,3,1]],
     [[3,3],[1,1,1,1],[3,6],  [3,1,1],[3,2,2],[6,3],  [2,7]  ],
     [[3,3],[15],     [2,3,1],[1,7],  [7,1],  [1,3,2],[2,3,2]]]
tw = [[2,1,3,2,2,3,3],[2,4,2,3,3,2,2],[2,1,3,2,2,3,3],[2,4,2,3,3,2,2]] # widths
th = [[2,4,2,3,3,2,2],[2,1,3,2,2,3,3],[2,4,2,3,3,2,2],[2,1,3,2,2,3,3]] # heights
score = 0
for p, rx in zip(bytearray(open('i', 'rb').read()),
                 bytearray(open('o', 'rb').read())):
    p %= 7; r = rx >> 4; x = rx & 15  # p:piece type, r:rotation, x:offset
    b = [u << x for u in t[r][p]]     # as a bit-matrix (list of ints)
    bw = tw[r][p]; bh = th[r][p]      # width and height
    y = 0                             # drop it
    while y <= 23 - bh and all((a[y + i] & b[i]) == 0 for i in range(bh)):
        y += 1
    y -= 1
    if y < 3:                         # no room?
        a = [0] * len(a)              # clear the grid and carry on
    else:
        for i in range(bh):           # add the piece to the grid
            a[y + i] |= b[i]
        n = 0
        for i in reversed(range(bh)): # collapse full lines
            if a[y + i] == (1 << 10) - 1:
                n += 1; del a[y + i]; a = [0] + a
        score += (1 << n) - 1
print(score)

以下更快的C程序也是如此，但保证只能在Linux上运行：

#include<stdio.h>
#include<fcntl.h>
#include<sys/mman.h>
#include<sys/stat.h>
#define F(i,n,b...)for(i=0;i<n;i++){b;}
typedef int I;typedef char C;
I a[23],t[]={
51,4369,99,802,785,54,39,51,15,306,71,116,561,305,
51,4369,99,275,547,54,114,51,15,306,113,23,561,562};
C*th="2423322213223324233222132233";
I main(){
 struct stat h;stat("i",&h);I i,j,k,l=h.st_size,z=0;
 C*mi=mmap(0,l,1,1,open("i",0,0),0),*mo=mmap(0,l,1,1,open("o",0,0),0);
 F(k,l,
  I p=(mi[k]&255)%7,r=3&mo[k]>>4,q=r*7+p,x=mo[k]&15,y=0,h=th[q]-'0',b[4];
  F(i,h,b[i]=(t[q]>>(4*i)&15)<<x)
  while(y<=23-h){I u=0;F(i,h,u|=a[y+i]&b[i])if(u)break;y++;}
  if(--y<3){F(i,23,a[i]=0)continue;}
  F(i,h,a[y+i]|=b[i])
  I n=0;F(i,23,n+=a[i]==1023)
  if(n){j=23;F(i,20,a[j]=a[22-i];j-=a[j]!=1023)F(i,j,a[i]=0);z+=(1<<n)-1;})
 printf("%d\n",z);return 0;}

最高总分获胜。禁止出现标准漏洞。

C，得分：4136（4290-154字节）

#include <stdio.h>
main(){int c,p=0,t[]={7,9,21,0,0,51,1,32,16,48,0,33,0,32,16,49};for(;(c=getchar())>=0;putchar(c)){c%=7;c=t[!c||!(10%c)?c:2*c+p++%4];}}

这个想法是，块S，Z，O，I使用固定的位置和旋转：

                  |
      s     z     |
      s s z z # # |
        s z   # # |
0 1 2 3 4 5 6 7 8 9

其余的-J，L，T-循环旋转地装入前三列。

非高尔夫版本：

#include <stdio.h>
int main() {
    int c,p=0,t[] = {7,9,21,51, 1,32,16,48, 16,48,0,33, 0,32,16,49 };
    while ((c=getchar())!=EOF) {
            switch(c%7) {
            case 0: c = t[0]; break;
            case 1: c = t[1]; break;
            case 2: c = t[2]; break;
            case 3: c = t[4+p++%4]; break;
            case 4: c = t[8+p++%4]; break;
            case 5: c = t[3]; break;
            case 6: c = t[12+p++%4]; break;
            }
            putchar(c);
    }
    return 0;
}