Cardinal Code Challenge

Question

Task

You're in charge of making a compass, of sorts.

Imagine your source code as the compass "needle" where running at different orientations produces distinct output.

Supported source code orientations are North, East, South, and West.

Example

Let's say you have source code:

ABCD
 J K
WXYZ

We'll consider this the North orientation, rotating 90 degrees clockwise points us to the East:

W A
XJB
Y C
ZKD

rotating again points South:

ZYXW
K J 
DCBA

and finally, the last rotation to the West:

DKZ
C Y
BJX
A W

When ran, each of the above code examples should output a single, distinct printable ASCII character of your choosing.

Notes

Your code shall take no input.

Empty spaces or new lines do not collapse/disappear when rotating.

Leading/trailing new lines are okay in output.

Answers may be whole programs or functions, thus output to STDOUT or return the function result.

Standard code-golf rules apply; shortest answer in bytes wins!

Answer 1

Jelly, 2 bytes

*2

Try it online!

Note that the main entry for a Jelly program is its last link, where any newline character will split links), neither of the two-line programs actually access their top link.

The four full programs, all of which implicitly print their result, are:

North:

*2   -> (implicit) zero raised to the power of 2 = 0

East:

*
2    -> literal 2 = 2

South:

2*   -> two raised to the power of (implicit) 2 = 4

West:

2
*    -> (implicit) zero raised to the power of (implicit) zero = 1

Answer 2

Japt, 3 2 bytes

gy

Somehow, somehow, I found an extremely hacky 2-byte solution...

---

North outputs 0:

gy

Since there's no implicit input, it defaults to 0. g on a number returns the sign of the number regardless of its arguments ("y" in this case).

---

East outputs 2:

g
y

In a multi-line program, the first line sets the input to its result. This is basically a no-op, since g on 0 is 0. Then y returns the GCD of 0 and... since it's missing an argument, it defaults to 2 (thanks, @Oliver!). This gives 2 as the output.

---

South outputs g:

yg

y, as before, is GCD. Since gcd(0, x) is x for any value, y on 0 takes the liberty of just returning its argument. In this case, the argument is "g", which is the result.

---

West outputs 1:

y
g

y on 0, as before, returns 2. This is then passed to g, which (as already discussed) is the sign function on numbers. Therefore, the result is 1.

Answer 3

Java (OpenJDK 8), 7309 4421 855 bytes

^{-2888 bytes thanks to Leaky Nun
-3566 bytes thanks to Wheat Wizard}

//i/////////////////////////////////////////////////////////////
//n//////////////////////////////////////////////////////////////////
interface M{static void main(String[]a){System.out.println(0);}}/////
//e//}};)2(nltnirp.tuo.metsyS{)a][gnirtS(niam diov citats{M ecafretni
//r//////////////////////////////////////////////////////////////////
//f}/////////////////////////////////////////////////////////////////
//a}//
//c;//
//e)//
// 3//
//M(//
//{n//
//sl//
//tt//
//an//
//ti//
//ir//
//cp//
// .//
//vt//
//ou//
//io//
//d.//
// m//
//me//
//at//
//is//
//ny//
//(S//
//S{//
//t)//
//ra//
//i]//
//n[//
//gg//
//[n//
//]i//
//ar//
//)t//
//{S//
//S(//
//yn//
//si//
//ta//
//em//
//m //
//.d//
//oi//
//uo//
//tv//
//. //
//pc//
//ri//
//it//
//na//
//tt//
//ls//
//n{//
//(M//
//1 //
//)e//
//;c//
//}a//
//}f//
///r//
///e//
 //t//
 //n//
 //i//

Try it online!

Old version

Straightforward aproach with comments wrapping the code^2 square, this can be done in pretty much any language.
a (more readable) example in python

##p#####
# r  2 #
print 1#
# n  t #
# t  n #
#4 tnirp
# 3  r #
#####p##

Answer 4

Brain-Flak, 33 bytes

##)(##))()()  ((
((  ))##    ()##

Try it online!

Brain-Flak, 33 bytes

##)     ## #
(( ))#)())()
  # ( (

Try it online!

Brain-Flak, 36 bytes

#)##     ## #
  (())#)())()
 #   ( (

Try it online!

Brain-Flak, 38 bytes

######  (#
(()()())#))((
       #(  ##

Try it online!

Brain-Flak, 41 bytes

##(#####(#
(()()())#
##))()((
####((#)#)#

Try it online!

Answer 5

Alice, 17 bytes

1/ 3<
vPo</
5} @<

Outputs 1. Try it online!

5v1
}P/
 o 
@<3
</<

Outputs x. Try it online!

<@ }5
/<oPv
<3 /1

Outputs 5. Try it online!

</<
3<@
 o 
/P}
1v5

Outputs 3. Try it online!

Answer 6

Lost, 45 bytes

v////v1//v(((
\(((%>2@0>%(((\
  (((v//3v////v

Try it online!

To recap the gimmick of lost from the esolangs wiki:

Lost is a 2-Dimensional language where the instruction pointer starts at a random location, moving in a random direction. Despite this, Lost is still capable of creating completely deterministic programs.

So at first glace, Lost is perhaps not the ideal language for this challenge because of its incredible fragility.

Answer 7

Befunge, 17 13 bytes

I thought Befunge would be fun for a geometrical problem. There is a trivial 4x4 solution akin to others here (I need 3 commands) but I managed a bit better.

Edit: forgot about newlines

Edit 2: realized I could create a cat

Edit 3: the cat is dead

2v3
@.v
.  
1@.

RIP kitty :<

1.@ 2
^._.^
3 @.4

Answer 8

05AB1E, 5 3 bytes

Y'X

North, East, South, West

Answer 9

C (gcc), 283 279 209 bytes

/////////)pm//
/////////;ua//
main(){//}ti//
puts("N"//sn//
);}///////((//
//////////")//
///"//////W{//
///E//////"///
//)"//////////
//((///////};)
//ns//"S"(stup
//it}//{)(niam
//au;/////////
//mp)/////////

Try it online!

Same old comment trick here, but at least, in C this doesn't get huuuge ;)

• -4, thanks to ETHproductions!
• fixed W direction and -70 (!) bytes thanks to comments by ETHproductions

Answer 10

Starry, 34 bytes

  zz  
  +   
   .  
    + 
      

Or with spaces shown as hyphens so you can see them:

--zz--
--+---
---.--
----+-
------

Try it online!

The commands in Starry are +, . and some other things, and what they do is determined by how many spaces there are before them: a + with n spaces pushes n−5 to the stack, and . with an even number of spaces prints it. The zs and newlines are ignored entirely.

There are 6 spaces before the first + so it pushes 6−5 = 1, and the . prints it.

And the rotations:

-----
-----
---+z
--.-z
-+---
-----

Try it online! This prints "8".

------
-+----
--.---
---+--
--zz--

Try it online! This prints "2".

-----
---+-
z-.--
z+---
-----
-----

Try it online! And this prints "3".

Answer 11

Labyrinth, 9 bytes

!
2@2
 !)

Prints 0. Try it online!

 2)
 @!
!2

Prints 3. Try it online!

)!
2@2
  !

Prints 1. Try it online!

 2!
!@
)2

Prints 2. Try it online!

Explanation

Each program starts at the first non-space in reading order (i.e. either the top left or top centre character), moving east. For the first program:

!   Print an implicit zero.
    The IP can't move east, so it moves south instead.
2   Push a 2.
    The IP can't keep going south, so it turns east instead.
@   Terminate the program.

For the second program:

2   Push a 2.
)   Increment it to 3.
    The IP can't keep going east, so it turns south instead.
!   Print the 3.
    The IP can't keep going south, so it turns west instead.
@   Terminate the program.

For the third program:

)   Increment an implicit zero to 1.
!   Print the 1.
    The IP can't keep going east, so it turns south instead.
@   Terminate the program.

For the fourth program:

2   Push a 2.
!   Print the 2.
    The IP can't keep going east, so it turns back around to move west.
2   Push another 2.
    The IP can't keep going west, so it turns south instead.
@   Terminate the program.

Answer 12

Wumpus, 7 bytes

O@$
)))

Prints 0. Try it online!

)O
)@
)$

Prints 1. Try it online!

)))
$@O

Prints 3. Try it online!

$)
@)
O)

Prints 2. Try it online!

Explanation

The first program is easy enough: O prints an implicit zero and @ terminates the program.

Starting at the second program, we need to look at the triangular grid layout to understand the control flow:

)   Increment an implicit zero to 1.
O   Print the 1.
))  Two irrelevant increments.
@   Terminate the program.

For the third program:

))) Increment an implicit zero to 3.
O   Print the 3.
@   Terminate the program.

The fourth one is where it gets really funky. Dashed lines indicate cells that aren't executed because they are skipped by the $:

$   Skip the ).
$   Skip the @.
))  Increment an implicit zero to 2.
O   Print the 2.
))  Two irrelevant increments.
@   Terminate the program.

Answer 13

PowerShell, 20 11 bytes

#4#
1#3
#2#

Abuses comments (#) like crazy, and the fact that a single number placed onto the pipeline gets output as-is. The above prints 1. Try it online!

From here, you can easily see that each rotation yields only one number that's on the "left" of the comments, and so there's only one number that will be output per rotation.

Saved 9 bytes thanks to Wheat Wizard!

Answer 14

Batch, 90 bytes

 :: :::@:
:&s ohce@
:e   : c:
      :h:
:o     o:
:h:
:c :   w:
@echo n&:
:@::: ::

Batch doesn't really have a comment character. For whole-line comments, : works, as it introduces a label, but I still need something to terminate the echo command while being a no-op when reversed. &: seems to work, which is all I need here, but it really confuses Batch, erroring out if I don't put a : before the @ on the next line, and also somehow forgetting to print a newline.

Answer 15

dc, 9 bytes

 1
2p3
 4

Try it online!

I think its obviousness is part of the charm.

Answer 16

Cardinal, 20 17 12 11 bytes

.$
Z%"
+$v

Try it online!

All this time and no-one answered in Cardinal? This first one outputs 0.

East

 +Z.
 $%$
 v"

Try it online!

Outputs 1.

South

v$+
"%Z
 $.

Try it online!

Outputs a space.

West

 "v
$%$
.Z+

Try it online!

Outputs v.

Answer 17

JavaScript (ES6), 86 bytes

Outputs 0 for North, 1 for East, 2 for South, and 3 for West.

////  _//
////  =//
_=>0//>//
  ////1//
  // //
//3////
//>//2>=_
//=  ////
//_  ////

const source =
`////  _//
////  =//
_=>0//>//
  ////3//
  // //
//1////
//>//2>=_
//=  ////
//_  ////`;

function rotateTextCW(text) {
  const lines = text.split("\n");
  const maxLineLength = lines
    .map(line => line.length)
    .reduce((max, len) => Math.max(len, max), 0);
  const paddedLines = lines.map(line => line.padEnd(maxLineLength));
  const charGrid = paddedLines.map(line => line.split(""));
  const rotatedGrid = [...new Array(maxLineLength)]
    .map(v => new Array(charGrid.length));

  for (let i = 0; i < charGrid.length; i++) {
    for (let j = 0; j < charGrid[i].length; j++) {
      rotatedGrid[j][charGrid.length - i - 1] = charGrid[i][j];
    }
  }

  return rotatedGrid
    .map(chars => chars.join("").trimRight())
    .join("\n");
}

const orientations = ["North", "East", "South", "West"];
let rotatedSource = source;
let markup = "";

orientations.forEach(orientation => {
  const code = `<pre>${rotatedSource}</pre>`;
  const result = `<code>${eval(rotatedSource)()}</code>`;
  const row = `
    <td>${orientation}</td>
    <td>${code}</td>
    <td>${result}</td>`;
  markup += `<tr>${row}</tr>`;
  rotatedSource = rotateTextCW(rotatedSource);
});

document.querySelector("table tr:first-child")
  .parentNode
  .innerHTML += markup;

<link href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet" />
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/js/bootstrap.min.js"></script>

<div class="container">
  <table class="table table-striped table-responsive">
    <tr>
      <th>Orientation</th>
      <th>Source</th>
      <th>Result</th>
    </tr>
  </table>
</div>

Answer 18

MATLAB, 29 17 5 11 bytes

Having realised that the question called for single ASCII characters not just a distinct output, here is a MATLAB approach which will do just that:

%4%
1%3
%2%

This will implicitly print 1, 2, 3, or 4 depending on the rotation.

Answer 19

SOGL V0.12, 4 bytes

5H
I

Outputs 1, Try it Here!

I5
 H

Outputs H, Try it Here!

 I
H5

Outputs 5, Try it Here!

H
5I

Outputs 6, Try it Here!

Answer 20

MATL, 11 bytes

HxI
xFx
TxK

Try it online!

Let's get this started in MATL. The main challenge is that MATL just fails if a function requires input if the stack is empty. Perhaps something clever with modifiers like X, Y, Z and & could make for something shorter, but I couldn't find a suitable combination.

Explanation: all characters push a single integer on the stack, and x removes all of them but the last.

Answer 21

Perl, 49 bytes

48 bytes code + 1 for -p.

Assumes empty input which TIO doesn't support, so a newline is added in its place and not used. Prints N, E, S, W.

# ####
#S= _$
#; W#
 $_=N#
#_ _#
#= $#
#E#
 ## #

Try it online!

Answer 22

C (gcc), 120 bytes

I had hoped for more synergy between the variants.

//}=)f8 ///
// c{(7 ///
   ;rr; //}
        ;c=
78; /// r{)
f(r /// r(f
){r /// ;38
=c;
}// ;rr;
/// 9({c //
/// 6f)=}//

North

East

South

West

Answer 23

MathGolf, 11 bytes

Þ2Þ
3 1
Þ0Þ

A bit boring, but since MathGolf implicitly outputs the entire stack joined together, I'm not sure if something shorter is possible here..

Default; rotated once clockwise; rotated two times clockwise; rotated three times clockwise.

Explanation:

• 0123: These push the digit to the stack
• : This pushes a space character to the stack
• Þ: This empties the stack except for the top value

And in the end the entire stack joined together is output implicitly as result.

Answer 24

brainfuck, 72 bytes

++
+++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++++++
+

Try it online!
Try it rotated once!
Try it rotated twice!
Try it rotated thrice!

Answer 25

JavaScript (Node.js), 69 bytes

 _=>0//
/*    *_
/      =
1      >
>      3
=      /
_*    */
 //2>=_

Try it online!

This approach should work for any language with C-style comments.

Answer 26

MAWP, 5 bytes

North: 3

2M:
2

Try it!

East: 4

22
 M
 :

Try it!

South: 2

  2
:M2

Try it!

West: 1

:
M
22

Try it!

The existing 1 in the stack is very convenient here.

Answer 27

Python 2, 71 bytes

##p#####
# r  2 #
print 1#
# n  t #
# t  n #
#4 tnirp
# 3  r #
#####p##

Try it online!

Big thanks to this answer!

Note I did not copy it directly, but actually had a program in mind and golfed it with this.