标题说明了一切。您的目标是编写一个形成aw×h矩形字符的程序，该程序可以旋转并重新运行以输出已完成的90°逆时针（CCW）旋转数。

例如，如果3×2程序

abc
def

解决了该问题，它最初将输出0，并且连续旋转90°CCW

cf    fed    da
be    cba    eb
ad           fc

将分别输出1、2和3。

对于大多数语言而言，使用注释使这项工作变得微不足道。以Ruby为例，它可以在7×7矩形中完成：

###p###
### ###
###1###
p 0#2 p
###3###
### ###
###p###

面临的挑战是在没有任何评论的情况下做到这一点。

计分

您的分数是w * h，即矩形的面积。换行符不包括在内。换句话说，不包括代码高尔夫球，换行符。

Ruby示例的得分为49（尽管由于带有注释，所以当然是无效的）。

笔记

• 您的代码必须真正是矩形的，行尾不能缺少任何字符。
• 如果您愿意，可以输出其他合法的“ mod 90°”值而不是0 1 23。因此8可以代替0，而-1可以代替3，依此类推。
• 输出可能会进入控制台或进入文件。
• 有标准漏洞。

我希望这是我的第一个问题，确实引起了某些人的兴趣。请享用！

APL（1x3 = 3）

5!3

此解决方案使用额外的规则，即任何正确的mod 4输出都可以工作。

在APL中，x!y是从中选择x元素的方法的数量y，通常称为binom(y,x)或choose(y,x)。让我们检查一下每个旋转是否给出正确的答案。

0转

5!3

无法从3中选择5个元素，所以我们得到0，它会自动打印出来。

1逆时针旋转

3
!
5

APL会很高兴地评估每一行，先得到number 3，operator !，再得到number 5，仅输出这些（5）的最后一个，即1 mod 4。

2逆时针旋转

3!5

这是binom(5,3)，即(5*4*3*2*1)/(3*2*1)/(2*1) = 102 mod 4。

3逆时针旋转

5
!
3

和以前一样，只有的最后评估值为3打印机。

我实际上并不了解APL，因此请告诉我是否有任何错误的解释。我通过反复试验发现它是该网站上的第一语言：

1. 自动打印表达式的结果
2. 给定多行表达式，仅输出最后一个
3. 操作员独自站在一条线上没有问题
4. 带运算符中缀
5. 具有非对称的单字符算术二进制运算符（aRb！= bRa），并且足够灵活以返回各种数字。

对于（5），我在APL 二进位函数列表中未列出。我的第一个候选操作是/C和Python 2 的整数除法，但是APL除法÷给出浮点数。求幂是很诱人的，但失败的原因是a和a^b具有相同的奇偶性，但都是通过连续旋转获得的（除非b=0，然后b^a=0）。布尔运算符，例如<Give 0和1180度，这是行不通的。最终，我找到了二项式运算符!并尝试了数字运算，直到得到一些可行的运算为止。

感谢Quincunx的信心，他认为解决方案比2x2小。

红宝石，7×9（63）

 30;p  
0||p=p 
0|0;p;p
;p;p|p;
p=p ||0
;p   p;
2||p =p
 00;1  
     p 

比其他解决方案长一点，但至少此解决方案不依赖于任何隐式打印或规则滥用。对于所有四个旋转，将解析完整的代码，并且除了某些短路以外，所有代码都将执行。令人惊讶的是，代码中绝对没有对称性

该解决方案依赖于以下事实：p即使已经定义了具有相同名称的变量，仍然可以调用该函数（用于打印数字）。例如，类似使用变量作为参数p p调用函数p的操作p（因此，输出的值p）。

代码中使用的一些常见表达式的解释：

• p：如上所述，这可以是函数调用或变量。当未定义变量时，这将调用p不带参数的函数，该函数不执行任何操作并返回nil。
• p p：打印变量p。
• p|x：当p函数是时，与相同nil|x，后者根据的值返回true / false x。如果p是整数，则按位或。无论哪种方式，该声明都没有副作用。
• p=p||x：与p||=x（条件赋值）有效相同，其语法有效，并且在反转时不操作。

对称版本（9×10 = 90）

    p    

  0 * 0  
  00100  
  0||2* p
p *0||0  
  00300  
  0 * 0  

    p    

这是我能想到的最短的对称解（当忽略要打印的数字时为C ₂）。

测试脚本

这是一个测试脚本，用于验证上面的代码（已#在行尾添加了代码，以使空格不会被剥离，并在执行前将其删除）：

rotate=->s{s.split($/).map{|i|i.chars.reverse}.transpose.map(&:join).join($/)}

s=<<EOD.gsub(?#,"")
 30;p  #
0||p=p #
0|0;p;p#
;p;p|p;#
p=p ||0#
;p   p;#
2||p =p#
 00;1  #
     p #
EOD


puts ">>> 0°"
eval s
puts ">>> 90°"
eval rotate[s]
puts ">>> 180°"
eval rotate[rotate[s]]
puts ">>> 270°"
eval rotate[rotate[rotate[s]]]

GolfScript，4个（2x2）

43
12

打印4312为0（mod 4）。旋转打印3241（1 mod 4），2134（2 mod 4）和1423（3 mod 4）。

提示：

如果您愿意，可以输出其他合法的“ mod 90°”值而不是0 1 23。因此8可以代替0，而-1可以代替3，依此类推。

实际上，有许多数字可以使用。我在此Python程序中找到了这些：

def f(a,b,c,d):
    return int("%i%i%i%i"%(a,b,c,d))
for a in range(10):
    for b in range(10):
        for c in range(10):
            for d in range(10):
                candidate = f(a,b,c,d) % 4 == 0
                candidate &= f(b,d,a,c) % 4 == 1
                candidate &= f(d,c,b,a) % 4 == 2
                candidate &= f(c,a,d,b) % 4 == 3
                if candidate:
                    print("%i, %i, %i, %i"%(a,b,c,d))

尽管程序输出0s（可能不起作用），但有效的解决方案采用以下形式

ab
cd

其中a∈{4,8}，b∈{3,7}，c∈{1,5,9}，d∈{2,6}。IE浏览器(a,b,c,d)∈{4,8}×{3,7}×{1,5,9}×{2,6}是24个解决方案。

巨蟒-23 x 23 = 529

好的，这个问题已经解决了，但是还没有Python解决方案。所以我考虑了-很重！-并找到了一种使笨重的print命令在任何方向上运行的方法，当从其他方向之一进行解析时，不会产生错误。

突破是以下几行：

'"\'';forward_code;"';backward_code;""\'"''

当forward_code执行时，则backward_code是字符串的一部分，因此不会被打印。向后阅读时，这恰恰是另一种方式。

因此，再结合两个方向并进行微调以使所有引号正确匹配，我得到以下解决方案：

''"''""''"''"''"'"''""'
"  ""                 "
"  \\                 "
'"\'';print 1;"'""\'"''
'"\''"';3 tnirp;""\'"''
"  ;""                "
"  p'                 "
'  r;                 '
'  i2                 '
"  n                  "
"  tt                 "
'   n                 '
'  4i                 '
"  ;r     .-=<>=-.    "
' \"p    /__----__\   '
"  ';'  |/ (')(') \|  "
"  ""    \   __   /   "
'  ""    .`--__--`.   '
"  \\   /    :|    \  "
'  ''  (_)   :|   (_) '
'  ""    |___:|____|  '
"  ''    |_________|  "
''"''""''"''"''"'"''""'

编辑：我找到了一种处理所有空白的方法。;）

BASIC，64岁

不会赢，但是无论如何这里还是赢。（在Chipmunk Basic中测试）

?0:END:?
:::::::1
D:::::::
N::::::E
E::::::N
:::::::D
3:::::::
?:DNE:2?

注意：?是PRINTBASIC的各种方言的缩写。尽管代码中存在许多语法错误，但END第一行中的语句阻止了解释器看到它们。

Pyth，9个字符（3x3）

0 1

3 2

在pyth中，默认情况下将打印所有内容，除非前面带有空格。第一行之后的行供用户输入，在此程序中不进行评估。

获取9个字符的另一种方法：

"0"
3 1
"2"

Pyth 1.0.5，4个字符

尽管最近对pyth的更改使2位数字的生成更加困难（我正在考虑恢复的更改），但较旧版本的Pyth却易于生成两位数的数字，这与隐式打印以及除第一行外的所有行这一事实结合在一起被忽略，给出以下解决方案：

32
41

打印32、21、14、43。

Befunge，16岁

0.@1
@@@.
.@@@
3@.2

说明：从位数0到9相应的数字压入堆栈，.从堆栈中弹出的值并打印它作为一个整数，并且@结束程序。

（在这里测试）

彼得49岁

我只想使用黄色和红色，并试图使其大致对称。旋转后，它将打印0、1、2或3。不幸的是，在Piet中退出该程序很困难，并且占据了图片中大约一半的空间。

GNU直流，6（3x2）

我认为这是不要求“ mod 90°”规则松弛的最短答案：

3z1
0p2

输出0，1，2或3每个旋转。

对于0，2和3旋转，p只需弹出并打印要压入堆栈的最后一个数字文字。对于1旋转，z将当前堆栈深度（1）推入堆栈，然后p弹出并打印。

GolfScript，9（3x3）

0}1
} }
3}2

有点违反规则。的}恰好结束该程序，如果没有匹配的{，并且堆叠中的内容在节目结束打印。

JavaScript，4

03
12

当您在javaScript控制台中执行该程序（或该程序的旋转）时，仅对最后一行进行评估并在控制台中回显。

所以：

12 modulo 4 == 0
01 modulo 4 == 1
30 modulo 4 == 2
23 modulo 4 == 3

这也是所有类似的2x2程序也可以使用：

03
12

03
16

03
52

03
56

03
92

03
96

07
12

07
16

07
52

07
56

07
92

07
96

43
12

43
16

43
52

43
56

43
92

43
96

47
12

47
16

47
52

47
56

47
92

47
96

83
12

83
16

83
52

83
56

83
92

83
96

87
12

87
16

87
52

87
56

87
92

87
96

换句话说

ab
cd

其中a在[0,4,8]中，b在[3,7]中，c在[1,5,9]中，而d在[2,6]中

CJam / GolfScript-3 * 3

2;3
;7;
1;0

分号弹出先前的数字，因此仅打印右下角。

阿海 8 岁

바몽희뷸
뷷희몽반

由于Aheui没有将1压入堆栈的字母，因此我决定打印0、5、2和3。

说明：바和반分别将0和2压入堆栈，并将光标向右移动一个字符。뷸和뷷分别将5和3压入堆栈，并将光标向下移动两个字符。s弹出并打印堆栈中的数字，并将光标向上移动一个字符。s终止​​程序。

的JavaScript

（在浏览器控制台，shell或另一个REPL中输入，因此打印结果）

1+2
-3-
4+5

应该适用于带有表达式，无效换行符和自动打印结果的任何其他语言。

MATLAB /倍频程- 144 100

打高尔夫球：10 x 10 = 100

....d.....
....i.....
....s.....
... p2 ...
disp  1...
...3  psid
... 4p ...
.....s....
.....i....
.....d....

替代解决方案：15 x 15 = 225

.......d.......
.......i.......
.......s.......
...    p    ...
...         ...
...    4    ...
...    .    ...
disp 1...3 psid
...    .    ...
...    2    ...
...         ...
...    p    ...
.......s.......
.......i.......
.......d.......

Perl 5x7（35）

1+p+t+1
-print+
1+i+i+1
+tnirp+
1+t+p+1

晚会晚了一点。单独-决定打印哪个号码。

JavaScript，3

2
1
4

它在基础7。

Base 9版本：

2
7
0

说明

当以交互方式运行时（例如，从调试控制台运行），将输出最后一条语句/表达式的值。

4 ₇ = 4 ₁₀ ≣ 0（模4）
412 ₇ = 205 ₁₀ ≣ 1（模4）
2 ₇ = 2 ₁₀ ≣ 2（MOD 4）
214 ₇ = 109 ₁₀ ≣ 3（MOD 4）

对于任何奇数基数，都可以找到类似的解决方案。

Befunge，12岁（6x2）

通过设法充分利用Befunge的二维特性并使代码路径在两个方向上垂直运行，我设法对现有的Befunge答案进行了些微改进。

0.@.1v
v3.@.2

在线尝试：开始0， 旋转1， 旋转2， 旋转3。

Marbelous，7 * 14 = 98

.. \/ \/ .. ..
.. 31 \\ 32 \/
\/ \\ \/ \\ \/
\/ 30 \\ 33 ..
.. .. \/ \/ ..

啊！/啊！（4 * 4 = 16）

使用正确的工具完成工作意味着什么？没有评论（一般语言）。

整个程序系列（在J：((|.@:|:) ^: (i. 4)) >'hpqh';'q01p';'p32q';'hqph'或中生成((|.@:|:) ^: (i. 4)) 4 4 $ 'hpqhq01pp32qhqph'）

hpqh
q01p
p32q
hqph

旋转一次：

hpqh
q12p
p03q
hqph

旋转两次：

hpqh
q23p
p10q
hqph

旋转三遍：

hpqh
q30p
p21q
hqph

为了解释这一点，最好查看一个“缩进”版本（这也适用于所有旋转）：

hhpq h
  0  h
q   1p
p3   q
h  2  
h qphh

此版本显示该程序包含4个单独的部分，每个单独的旋转一个。

• h -设置控制流向左

• p -在下面的数据/代码栅格中打印项目

• q -退出程序

漂浮物 -9×5 = 45

打印4、1、2或3到控制台。

请注意，“ Black”是有效指令（NOP），是语法。没有它，它就找不到起始位置。因此，矩形中的所有位置均被占用。

元素2x3 = 6

1*
`2
3 

这是对3x3天真解决方案的改进，该解决方案`的中间是a，每边都有一个数字。上面显示的0情况是最有趣的，因为*使用了3乘以3而不得到0。除此之外，它并不那么复杂。

如果您觉得该空格很尴尬，可以将其替换为几乎所有其他字符（不包括）[]{}`_。

供参考，以下是其他三个旋转：

case 1
*2 
1`3

case 2
 3
2`
*1

case 3
3`1
 2*

芯片（2x5）10

b~
+a
~t
e*
 f

*激活所有相邻元素：北，东，南，西（源）
~如果不是从西边激活，激活东邻（NOT门）（这里从来没有激活）
t终止打印当前字节后执行
a设置位0x01输出的
b套比特0x02的输出的
e设置位0x10输出的
f设置位0x20输出的
+，如果被任何邻居激活，激活所有其他邻居（电线）

芯片需要-w标志（允许无输入执行）或一些输入才能运行。

版画0，1，2，或3在ASCII。如果码点0x00到0x03期望，删除e和f，然后移动空间，以填补该间隙。

Japt，3 * 1 = 3个字节

5zB

在线试用：原样， 旋转一次， 两次， 三次。

分别输出0、5、2、11。

该变量B的值是11，并且Number.z(other)是底数划分（每个人显然都在寻找：p）。对于多行代码，最后一行将传递到输出，这里只是一个常数。

2 * 2 = 4字节

2J
1T

在线试用：原样， 旋转一次， 两次， 三次。

分别输出0、21、2，-1。

T保持0，J保持-1。

诀窍是，如果两个文字或变量并排放置，则会插入逗号，而输出仅是最后一个。

2 * 2 JS解决方案也可以在Japt中使用。