[Question]
  [
The title says it all. Your goal is to write a program that forms a w×h rectangle of characters that can be rotated and re-run to output the number of 90° Counter-Clockwise (CCW) rotations that have been done.
For example, if the 3×2 program
```
abc
def
```
solved the problem, it would initially output 0, and successive rotations of 90° CCW
```
cf    fed    da
be    cba    eb
ad           fc
```
would output 1, 2, and 3 respectively.
Using comments makes this a trivial task is most languages. In Ruby for example, it can be done in a 7×7 rectangle:
```
###p###
### ###
###1###
p 0#2 p
###3###
### ###
###p###
```
The challenge is to do this **without** any sort of comments.
**Scoring**
Your score is w\*h, the area of your rectangle. Newlines are excluded. In other words, code-golf, newlines not counted.
The score for the Ruby example is 49 (though of course it is invalid since it has comments).
**Notes**
* Your code must really be rectangular with no missing characters at the end of lines.
* If you wish you may output other legal "mod 90°" values instead of 0 1 2 3. So 8 is fine instead of 0, and -1 is fine instead of 3, etc.
* The output may go to the console or into a file.
* Standard loopholes apply.
I hope this, my first question, really intrigues some people. Enjoy!
  
[Answer]
# APL (1x3 = 3)
```
5!3
```
This solution uses the extra rule that any output that is correct mod 4 works.
In APL, `x!y` is the number of way to choose `x` elements from `y`, commonly known as `binom(y,x)` or `choose(y,x)`. Let's check that each rotation gives the right answer.
**0 rotations**
```
5!3
```
There's no way to choose 5 elements from 3, so we get 0, which is automatically printed.
**1 CCW rotation**
```
3
!
5
```
APL happily evaluates each line, getting the number `3`, the operator `!`, and then the number `5`, printing only the last of these (`5`), which is 1 mod 4.
**2 CCW rotations**
```
3!5
```
This is `binom(5,3)`, which is `(5*4*3*2*1)/(3*2*1)/(2*1) = 10`, which is 2 mod 4.
**3 CCW rotations**
```
5
!
3
```
As before, only the last-evaluated value of `3` is printer.
I don't actually know APL, so please tell me if I got any of the explanation wrong. I found it by trial and error as the first language on [this site](http://compileonline.com/) that:
1. Automatically prints the result of an expression
2. Given multiple lines of expressions, only outputs the last one
3. Has no issue with an operator standing alone on a line
4. Takes operators infix
5. Has a single-character arithmetic binary operator that is asymmetric (aRb != bRa), and flexible enough to return a variety of numbers.
For (5), I went down the list of APL [dyadic functions](http://en.wikipedia.org/wiki/APL_syntax_and_symbols#dyadic_functions). My first candidate operation was the integer division `/` of C and Python 2, but APL division `÷` gives floats. Exponentiation is tempting, but fails because `a` and `a^b` have the same parity but are gotten by consecutive rotations (unless `b=0`, but then `b^a=0`). Boolean operators like `<` give `0` and `1` 180 degrees apart, which doesn't work. Finally, I found the binomial operator `!` and tried numbers until I got some that work.
Thanks to Quincunx for his confidence that there exists a smaller solution than 2x2.
[Answer]
## Ruby, 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 
```
A bit longer than the other solution, but at least this solution doesn't depend on any implicit printing or rule abuse. For all four rotations, the full code is parsed and other than some short-circuiting, all of it is executed. Surprisingly, there's absolutely no symmetry in the code
This solution relies on the fact that it's still possible to call the `p` function (which is used to print the numbers) even if a variable with the same name has already been defined. For example, something like `p p` calls the function `p` with the variable `p` as argument (thus, printing the value of `p`).
Explanation for some of the common expressions used in the code:
* `p`: As mentioned above, this is either a function call or a variable. When the variable is not defined, this calls the function `p` without arguments, which does nothing and returns `nil`.
* `p p`: Prints the variable `p`.
* `p|x`: When `p` is the function, this is identical to `nil|x`, which returns true/false depending on the value of `x`. If `p` is an integer, it's bitwise or. Either way, this statement has no side effect.
* `p=p||x`: Effectively the same as `p||=x` (conditional assignment) with the advantage of being syntactically valid and a no-op when reversed.
### Symmetric version (9×10 = 90)
```
    p    
  0 * 0  
  00100  
  0||2* p
p *0||0  
  00300  
  0 * 0  
    p    
```
This is the shortest symmetric solution (C2 when ignoring the numbers to print) I could come up with.
### Test script
Here's a test script to verify the code above (the `#` at the line ends have been added so that the whitespace doesn't get stripped and are removed before execution):
```
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]]]
```
[Answer]
# Python - 23 x 23 = 529
Ok, this question has already a winner, but there is no Python solution, yet. So I thought about it - heavily! - and found a way to make the bulky `print` command working in any direction without producing errors when parsed from one of the other directions.
The breakthrough was the following line:
```
'"\'';forward_code;"';backward_code;""\'"''
```
While the `forward_code` is executed, the `backward_code` is part of a string and thus not printed. This is exactly the other way around when reading backwards.
So combined with two more directions and fine-tuned to get all quotes matching correctly I end up with the following solution:
```
''"''""''"''"''"'"''""'
"  ""                 "
"  \\                 "
'"\'';print 1;"'""\'"''
'"\''"';3 tnirp;""\'"''
"  ;""                "
"  p'                 "
'  r;                 '
'  i2                 '
"  n                  "
"  tt                 "
'   n                 '
'  4i                 '
"  ;r     .-=<>=-.    "
' \"p    /__----__\   '
"  ';'  |/ (')(') \|  "
"  ""    \   __   /   "
'  ""    .`--__--`.   '
"  \\   /    :|    \  "
'  ''  (_)   :|   (_) '
'  ""    |___:|____|  '
"  ''    |_________|  "
''"''""''"''"''"'"''""'
```
**Edit:** I found a way to deal with all that whitespace. ;)
[Answer]
# GolfScript, 4 (2x2)
```
43
12
```
Prints `4312` which is `0` (mod 4). The rotations print `3241` (1 mod 4), `2134` (2 mod 4), and `1423` (3 mod 4).
Prompted by:
> 
> If you wish you may output other legal "mod 90°" values instead of 0 1 2 3. So 8 is fine instead of 0, and -1 is fine instead of 3, etc.
> 
> 
> 
There are actually many sets of numbers for which this works. I found these with this Python program:
```
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))
```
Although the program outputs `0`s (which probably wouldn't work), the valid solutions are of the form
```
ab
cd
```
Where `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}` which is 24 solutions.
[Answer]
# BASIC, 64
Won't win, but here it is anyway. (Tested in [Chipmunk Basic](http://www.nicholson.com/rhn/basic/))
```
?0:END:?
:::::::1
D:::::::
N::::::E
E::::::N
:::::::D
3:::::::
?:DNE:2?
```
Note: `?` is shorthand for `PRINT` in various dialects of BASIC. Although there are lots of syntax errors in the code, the `END` statement in the first line prevents them from being seen by the interpreter.
[Answer]
# [Pyth](https://github.com/isaacg1/pyth/blob/master/pyth.py), 9 characters (3x3)
```
0 1
3 2
```
In pyth, everything is printed by default, unless it is preceded by a space. Lines after the first line are for user input, and are not evaluated in this program.
Another way to get 9 characters:
```
"0"
3 1
"2"
```
---
# [Pyth 1.0.5](https://github.com/isaacg1/pyth/blob/0ca956532f9e720f208da6c419cc2ff8e69576d3/pyth.py), 4 characters
While recent changes to pyth have made 2 digit numbers harder to generate (A change that I am considering reverting), older versions of Pyth have easy two digit number generation, which, combined with the implicit printing and the fact that all lines but the first are ignored, gives the following solution:
```
32
41
```
Prints 32,21,14,43.
[Answer]
# Befunge, 16
```
0.@1
@@@.
.@@@
[[email protected]](/cdn-cgi/l/email-protection)
```
**Explanation:** Digits from `0` to `9` push the corresponding number onto the stack, `.` pops a value from the stack and prints it as an integer, and `@` ends the program.
(tested [here](http://www.compileonline.com/compile_befunge_online.php))
[Answer]
# Piet, 49
![A Piet Program](https://i.stack.imgur.com/qIMtF.png)
I made a point only to use yellow and red colors, and to try and make it roughly symmetrical. When rotated, it prints 0, 1, 2 or 3. Exiting the program in Piet is hard, and takes up around half the space in the picture, unfortunately.
[Answer]
# [GNU dc](http://www.gnu.org/software/bc/manual/dc-1.05/), 6 (3x2)
I think this is the shortest answer not to require the "mod 90°" rule-relaxation:
```
3z1
0p2
```
Outputs `0`, `1`, `2` or `3` for each rotation.
For the `0`, `2` and `3` rotations, the `p` simply pops and prints the last number literal to have been pushed to the stack. For the `1` rotation, the `z` pushes the current stack depth (1) to the stack, then the `p` pops and prints it.
[Answer]
# GolfScript, 9 (3x3)
```
0}1
} }
3}2
```
Sort of abusing the rules. The `}` happens to end the program if there is no matching `{`, and the contents of the stack are printed at program end.
[Answer]
## JavaScript, 4
```
03
12
```
When you execute this program (or a rotation of this program) in a javaScript console, only the last line is evaluated and echoed in the console.
So:
```
12 modulo 4 == 0
01 modulo 4 == 1
30 modulo 4 == 2
23 modulo 4 == 3
```
Here are all the similar 2x2 programs that work too:
```
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
```
In other terms,
```
ab
cd
```
where a is in [0,4,8], b is in [3,7], c is in [1,5,9], and d is in [2,6]
[Answer]
# CJam / GolfScript - 3\*3
```
2;3
;7;
1;0
```
The semicolon pops the previous number, thus only the bottom right corner is printed.
[Answer]
# [Aheui](http://esolangs.org/wiki/Aheui), 8
```
바몽희뷸
뷷희몽반
```
Since Aheui does not have a letter that pushes 1 onto the stack, I decided to print 0, 5, 2, and 3.
Explanation: 바 and 반 push 0 and 2, respectively, onto the stack and moves the cursor right by one character. 뷸 and 뷷 push 5 and 3, respectively, onto the stack and moves the cursor down by two characters. 몽 pops and prints the number in the stack and moves the cursor up by one character. 희 terminates the program.
[Answer]
## JavaScript
(Entered in browser console, shell or another REPL, so result is printed)
```
1+2
-3-
4+5
```
Should work for any other language with expressions, non-significant newlines and automatic printing of the result.
[Answer]
# Matlab/Octave - ~~144~~ 100
## Golfed: 10 x 10 = 100
```
....d.....
....i.....
....s.....
... p2 ...
disp  1...
...3  psid
... 4p ...
.....s....
.....i....
.....d....
```
## Alternative solution: 15 x 15 = 225
```
.......d.......
.......i.......
.......s.......
...    p    ...
...         ...
...    4    ...
...    .    ...
disp 1...3 psid
...    .    ...
...    2    ...
...         ...
...    p    ...
.......s.......
.......i.......
.......d.......
```
[Answer]
## Perl 5x7 (35)
```
1+p+t+1
-print+
1+i+i+1
+tnirp+
1+t+p+1
```
A bit late to the party. The solitary `-` determines which number is printed.
[Answer]
# Befunge, 12 (6x2)
I Managed to come up with a slight improvement on the existing Befunge answer by making the most of Befunge's two-dimensional nature and having the code path run vertically in two of the orientations. 
```
[[email protected]](/cdn-cgi/l/email-protection)
[[email protected]](/cdn-cgi/l/email-protection)
```
Try it online: [Starting 0](http://befunge.tryitonline.net/#code=MC5ALjF2CnYzLkAuMg&input=),
[Rotation 1](http://befunge.tryitonline.net/#code=djIKMS4KLkAKQC4KLjMKMHY&input=),
[Rotation 2](http://befunge.tryitonline.net/#code=Mi5ALjN2CnYxLkAuMA&input=),
[Rotation 3](http://befunge.tryitonline.net/#code=djAKMy4KLkAKQC4KLjEKMnY&input=).
[Answer]
# JavaScript, 3
```
2
1
4
```
It works... in base 7.
Base 9 version:
```
2
7
0
```
---
**Explanation** 
When run interactively, e.g. from a debugging console, the value of the last statement/expression will be output.
*47* = *410* ≣ *0* (mod *4*)  
*4127* = *20510* ≣ *1* (mod *4*)  
*27* = *210* ≣ *2* (mod *4*)  
*2147* = *10910* ≣ *3* (mod *4*) 
Similar solutions could be found for any odd base.
[Answer]
# Marbelous, 7\*14 = 98
```
.. \/ \/ .. ..
.. 31 \\ 32 \/
\/ \\ \/ \\ \/
\/ 30 \\ 33 ..
.. .. \/ \/ ..
```
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), 12x10 = 120
Outputs 0, 1, 2, and 3, respectively.
```
++         >
++++++++++++
++++++++++++
++++++++++++
++++++++++++
      .+++++
++++++++++++
++++++ +++++
++++++ +++++
++++++ +++++
```
[Try it online!](https://tio.run/##SypKzMxLK03O/v9fW1sBBuy4tJEAsRyIXj2cyhQIcP7/BwA "brainfuck – Try It Online")
[One turn](https://tio.run/##SypKzMxLK03O/v/fThsGuBRIZeppKygoQJgKCFF8TG2szP//AQ "brainfuck – Try It Online")
[Two turns](https://tio.run/##SypKzMxLK03O/v9fGwQUwKQ2FwGONjJHTwEMsMgQ5tgpwACQ8/8/AA "brainfuck – Try It Online")
[Three turns](https://tio.run/##SypKzMxLK03O/v9fGwgUQIQ2FzamAmGmgoKCth5CVJtUph3X//8A "brainfuck – Try It Online")
[Answer]
# [Argh!/Aargh!](http://www.sha-bang.de/12_eso/Argh-Spec.txt) (4\*4=16)
What was that about using the right tool for the job? There are no comments (in the language in general).
The entire family of programs (generated in J: `((|.@:|:) ^: (i. 4)) >'hpqh';'q01p';'p32q';'hqph'` or `((|.@:|:) ^: (i. 4)) 4 4 $ 'hpqhq01pp32qhqph'`)
```
hpqh
q01p
p32q
hqph
```
rotated once:
```
hpqh
q12p
p03q
hqph
```
rotated twice:
```
hpqh
q23p
p10q
hqph
```
rotated three times:
```
hpqh
q30p
p21q
hqph
```
To explain this, it might be best to look at an "indented" version (That also works in all rotations):
```
hhpq h
  0  h
q   1p
p3   q
h  2  
h qphh
```
This version shows that the program consists of 4 separate parts, one for each individual rotation.
* `h` - set control flow left
* `p` - print item in data/code raster below it
* `q` - quit the program
[Answer]
# [Floater](http://esolangs.org/wiki/Floater) - 9×5=45
![enter image description here](https://i.stack.imgur.com/V0Pb8.png)
Prints 4, 1, 2, or 3 to console.
Note that 'Black' is a valid instruction (NOP), and is syntactic. Without it, it can't find the starting position. Thus, all positions in the rectangle are occupied.
[Answer]
# [Triangular](https://github.com/aaronryank/triangular), 2x3 => 6
```
%%3
i%i
```
[Try it online!](https://tio.run/##KynKTMxLL81JLPr/X1XVmCtTNfP/fwA "Triangular – Try It Online")
A "rectangular triangular program" - we certainly do live in a society.
The base version here prints the top value of the stack (initially 0), then the other two prints are missed due to triangular's execution order.
**Rotation 1**
```
i%
%%
i3
```
Increments the top value to 1, prints, misses the other two print commands.
**Rotation 2**
```
i%i
3%%
```
Increments twice, hits the last print command.
**Rotation 3**
```
3i
%%
%i
```
Pushes 3 onto the stack, hits a print statement, misses the other two.
[Answer]
# [Pip](https://github.com/dloscutoff/pip), 2x2 = 4
```
tv
oi
```
[Try it online!](https://tio.run/##K8gs@P@/pIwrP/P/fwA "Pip – Try It Online")
All four letters are preinitialized variables; whichever one comes last in the program is autoprinted.
* No rotation: `i = 0`
* One rotation: `o = 1`
* Two rotations: `t = 10`
* Three rotations: `v = -1`
[Answer]
# Python, 18x18 = 324
Uses escaping and mixed quotation marks to change how each string is parsed after rotation. Triple quotes allow the literals to span multiple lines and take up less space.
```
"""p         '   "
   r         '   "
   i         '   "
   n'\""",)2(tnirp
'''t          '
   (          \
   3          "
   )          "
   ,          "
   '          ,
   '          )
   '          1
   \          (
   "          t"""
print(0),'''\"n
'   "         i
'   "         r
'   "         p'''
```
Test code (needs to be cleaned up) :
```
with open('./rotpy.py','r') as fh:
    l=list(fh)
    ll=max(len(x)for x in l)
    l=[x[:-1]+' '*(ll-len(x)) for x in l]
def r(l):
    return list(''.join(reversed(z)) for z in zip(*l))
for i in range(4):
    exec('\n'+'\n'.join(l))
    l=r(l)
```
[Answer]
# Element, 2x3 = 6
```
1*
`2
3 
```
This is an improvement over the 3x3 naive solution, which has a ``` in the middle with a number on each side. The 0 case, shown above, is the most interesting, since the `*` is used to multiply the 3 by nothing to get 0. Other than that, it's not that complicated.
If you find the space awkward, you can replace it with pretty much any other character, excluding `[]{}`_`.
For reference, here are the other three rotations:
```
case 1
*2 
1`3
case 2
 3
2`
*1
case 3
3`1
 2*
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 3 \* 1 = 3 bytes
```
5zB
```
Try it online: [as-is](https://ethproductions.github.io/japt/?v=2.0a0&code=NXpC&input=),
[rotated once](https://ethproductions.github.io/japt/?v=2.0a0&code=Qgp6CjU=&input=),
[twice](https://ethproductions.github.io/japt/?v=2.0a0&code=Qno1&input=),
[thrice](https://ethproductions.github.io/japt/?v=2.0a0&code=NQp6CkI=&input=).
Outputs 0, 5, 2, 11 respectively.
The variable `B` holds the value 11, and `Number.z(other)` is floor division (everyone looked for apparently :p). For multi-line code, the last line is passed to output, which is simply a constant here.
---
## 2 \* 2 = 4 bytes
```
2J
1T
```
Try it online: [as-is](https://ethproductions.github.io/japt/?v=2.0a0&code=MkoKMVQ=&input=),
[rotated once](https://ethproductions.github.io/japt/?v=2.0a0&code=SlQKMjE=&input=),
[twice](https://ethproductions.github.io/japt/?v=2.0a0&code=VDEKSjI=&input=),
[thrice](https://ethproductions.github.io/japt/?v=2.0a0&code=MTIKVEo=&input=).
Outputs 0, 21, 2, -1 respectively.
`T` holds 0, and `J` holds -1.
The trick is that, if two literals or variables are put side-by-side, a comma is inserted and the output is just the last one.
[2 \* 2 JS solution](https://codegolf.stackexchange.com/a/33182/78410) works in Japt too.
[Answer]
# [MAWP](https://esolangs.org/wiki/MAWP), 2x2 = 4
```
0:
23
```
-2 characters from Bubbler.
The position of the `:` operator determines when things are output, so we can abuse that and position the numbers around it.
Bubbler's modification pops the existing 1 from the stack, saving two bytes.
[Try it!](https://8dion8.github.io/MAWP/?code=0%3A%0A23%0A%0A%25%25%20stack%20cleanup%0A%0A%3A3%0A02%0A%0A32%0A%3A0%0A%0A20%0A3%3A&input=)
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 4 (2x2) [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
YX
3¾
```
To-the-point approach.
[Try it online](https://tio.run/##yy9OTMpM/f8/MoLL@NC@//8B) or [verify all four rotations](https://tio.run/##yy9OTMpM/a/0PzKCy/jQvv9Kh7YdnmXixqWgFFCUn16UmGuloKRjC@T6l5YUlJYAefYuemE6mhf2Bh/admjh4R2H13od2n1om/1/AA).
**Explanation:**
* `Y` is a variable with default value \$2\$
* `X` is a variable with default value \$1\$
* `¾` is a counter variable with default value \$0\$
So in all four rotations they are all three pushed to the stack, and then output the last integer on the stack is output implicitly as result.
An alternative 2x2 is a port of the [*@DLosc*'s Pip answer](https://codegolf.stackexchange.com/a/209398/52210), where `T` = \$10\$ and `®` = \$-1\$:
```
TX
®¾
```
[Try it online](https://tio.run/##yy9OTMpM/f8/JILr0LpD@/7/BwA) or [verify all four rotations](https://tio.run/##yy9OTMpM/a/0PySC69C6Q/v@Kx3adniWiRuXglJAUX56UWKulYKSji2Q619aUlBaAuTZu@iFudgrKWjk5qfomoAETFTt1TV1NC/sDT607dDCwzsOr/U6tPvQNvv/AA).
[Answer]
# [Zsh](https://www.zsh.org/), 36 (6x6)
```
 <<<0 
3    <
<    <
<    <
<    1
 2<<< 
```
[Try it online!](https://tio.run/##qyrO@P9fwcbGxkCBy1gBCGy4bDApQy4FI6Aahf//AQ "Zsh – Try It Online").
#### Alternative, (10x10):
```
printf 0 p
         r
3        i
         n
f        t
t        f
n         
i        1
r         
p 2 ftnirp
```
Exploits the fact that `printf` only prints the first word, if there are no quotes.
]