Tarefa

Você está encarregado de fazer uma bússola, das sortes.

Imagine seu código-fonte como a "agulha" da bússola, onde correr em diferentes orientações produz resultados distintos.

As orientações de código-fonte suportadas são Norte, Leste, Sul e Oeste.

Exemplo

Digamos que você tenha o código fonte:

ABCD
 J K
WXYZ

Consideraremos isso a orientação Norte, girando 90 graus no sentido horário nos aponta para o leste:

W A
XJB
Y C
ZKD

girando novamente aponta para o sul:

ZYXW
K J 
DCBA

e, finalmente, a última rotação para o oeste:

DKZ
C Y
BJX
A W

Quando executados, cada um dos exemplos de código acima deve gerar um caractere ASCII imprimível único e distinto de sua escolha.

Notas

Seu código não deve ser digitado.

Espaços vazios ou novas linhas não recolhem / desaparecem ao girar.

As novas linhas iniciais / finais estão corretas na saída.

As respostas podem ser programas ou funções inteiras, assim, saem para STDOUT ou retornam o resultado da função.

Aplicam-se regras padrão de código de golfe ; resposta mais curta em bytes ganha!

Geléia , 2 bytes

*2

Experimente online!

Observe que a entrada principal de um programa Jelly é seu último link, onde qualquer caractere de nova linha dividirá os links); nenhum dos programas de duas linhas realmente acessa seu link superior.

Os quatro programas completos, que implicitamente imprimem seus resultados, são:

Norte :

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

Leste :

*
2    -> literal 2 = 2

Sul :

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

Oeste :

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

Japonês , 3 2 bytes

gy

De alguma forma, de alguma forma , encontrei uma solução de 2 bytes extremamente hacky ...

Saídas do Norte0 :

gy

Como não há entrada implícita, o padrão é 0. gon a number retorna o sinal do número, independentemente de seus argumentos ( "y"neste caso).

Saídas do leste2 :

g
y

Em um programa de várias linhas, a primeira linha define a entrada como resultado. Isso é basicamente um no-op, já que gno 0é 0. Em seguida, yretorna o GCD de 0e ... como falta um argumento, o padrão é 2(obrigado, @ Oliver !). Isso dá 2como saída.

Saídas do Sulg :

yg

y, como antes, é GCD. Como gcd (0, x) é x para qualquer valor, yon 0assume a liberdade de retornar seu argumento. Nesse caso, o argumento é "g"qual é o resultado.

Saídas ocidentais1 :

y
g

yem 0, como antes, retorna 2. Isso é passado para g, que (como já discutido) é a função de sinal nos números. Portanto, o resultado é 1.

Java (OpenJDK 8) , 7309 4421 855 bytes

^{-2888 bytes graças a Freira
Furada -3566 bytes graças ao Assistente de Trigo}

//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//

Experimente online!

Versão antiga

Abordagem direta com comentários envolvendo o código ^ 2 quadrado, isso pode ser feito em praticamente qualquer idioma.
um exemplo (mais legível) em python

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

Brain-Flak , 33 bytes

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

Experimente online!

Brain-Flak , 33 bytes

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

Experimente online!

Brain-Flak , 36 bytes

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

Experimente online!

Flak cerebral , 38 bytes

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

Experimente online!

Flak cerebral , 41 bytes

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

Experimente online!

Alice , 17 bytes

1/ 3<
vPo</
5} @<

Saídas 1. Experimente online!

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

Saídas x. Experimente online!

<@ }5
/<oPv
<3 /1

Saídas 5. Experimente online!

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

Saídas 3. Experimente online!

Befunge, 17 13 bytes

Eu pensei que Befunge seria divertido por um problema geométrico. Há uma solução 4x4 trivial semelhante a outras pessoas aqui (preciso de 3 comandos), mas consegui um pouco melhor.

Editar: esqueceu as novas linhas

Edit 2: percebi que eu poderia criar um gato

Edit 3: o gato está morto

2v3
@.v
.  
1@.

Gatinho RIP: <

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

05AB1E , 5 3 bytes

Y'X

Norte , Leste , Sul , Oeste

C (GCC) , 283 279 209 bytes

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

Experimente online!

O mesmo velho truque de comentário aqui, mas pelo menos em C isso não fica huuuge ;)

• -4, graças à ETHproductions !
• Wdireção fixa e -70 (!) bytes graças aos comentários de ETHproductions

Labirinto , 9 bytes

!
2@2
 !)

Imprime 0. Experimente online!

 2)
 @!
!2

Imprime 3. Experimente online!

)!
2@2
  !

Imprime 1. Experimente online!

 2!
!@
)2

Imprime 2. Experimente online!

Explicação

Cada programa inicia no primeiro não espaço em ordem de leitura (ou seja, no caractere superior esquerdo ou no centro superior), movendo-se para leste. Para o primeiro programa:

!   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.

Para o segundo programa:

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.

Para o terceiro programa:

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

Para o quarto programa:

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.

Wumpus , 7 bytes

O@$
)))

Imprime 0. Experimente online!

)O
)@
)$

Imprime 1. Experimente online!

)))
$@O

Imprime 3. Experimente online!

$)
@)
O)

Imprime 2. Experimente online!

Explicação

O primeiro programa é fácil: Oimprime um zero implícito e @finaliza o programa.

Começando no segundo programa, precisamos observar o layout da grade triangular para entender o fluxo de controle:

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

Para o terceiro programa:

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

O quarto é onde fica realmente divertido. Linhas tracejadas indicam células que não são executadas porque são ignoradas pelo $:

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

PowerShell , 20 11 bytes

#4#
1#3
#2#

Abusa dos comentários ( #) como loucos, e o fato de que um único número colocado no pipeline é gerado como está. As impressões acima 1. Experimente online!

A partir daqui, você pode ver facilmente que cada rotação produz apenas um número à esquerda dos comentários e, portanto, há apenas um número que será gerado por rotação.

Economizou 9 bytes graças ao Wheat Wizard !

Estrelado , 34 bytes

  zz  
  +   
   .  
    + 
      

Ou com espaços mostrados como hífens para que você possa vê-los:

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

Experimente online!

Os comandos em Starry são +, .e algumas outras coisas, e o que eles fazem é determinado por quantos espaços existem antes deles: a +com n espaços empurra n -5 para a pilha e .com um número par de espaços os imprime. As zlinhas e novas linhas são totalmente ignoradas.

Existem 6 espaços antes do primeiro, +então ele empurra 6-5 = 1 e o .imprime.

E as rotações:

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

Experimente online! Isso imprime "8".

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

Experimente online! Isso imprime "2".

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

Experimente online! E isso imprime "3".

dc , 9 bytes

 1
2p3
 4

Experimente online!

Eu acho que sua obviedade faz parte do charme.

Lote, 90 bytes

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

Lote realmente não tem um caractere de comentário. Para comentários em toda a linha, :funciona, pois apresenta um rótulo, mas ainda preciso de algo para encerrar o echocomando enquanto não estiver operando quando invertido. &:parece funcionar, o que é tudo o que preciso aqui, mas realmente confunde Batch, errando se eu não colocar um :antes @da próxima linha e também de alguma forma esquecendo de imprimir uma nova linha.

MATLAB, 29 17 5 11 bytes

Tendo percebido que a pergunta pedia caracteres ASCII únicos e não apenas uma saída distinta, aqui está uma abordagem do MATLAB que fará exatamente isso:

%4%
1%3
%2%

Isso imprimirá implicitamente 1, 2, 3 ou 4, dependendo da rotação.

Cardeal , 20 17 12 11 bytes

.$
Z%"
+$v

Experimente online!

Todo esse tempo e ninguém respondeu no cardeal? Este primeiro é gerado 0.

Leste

 +Z.
 $%$
 v"

Experimente online!

Saídas 1.

Sul

v$+
"%Z
 $.

Experimente online!

Gera um espaço.

Oeste

 "v
$%$
.Z+

Experimente online!

Saídas v.

SOGL V0.12 , 4 bytes

5H
I

Saídas 1, experimente aqui!

I5
 H

Saídas H, experimente aqui!

 I
H5

Saídas 5, experimente aqui!

H
5I

Saídas 6, experimente aqui!

JS, 17 B

//1//
2///4
//3//

Saídas:
Norte: 2,
Leste: 3,
Sul: 4,
Oeste: 0,33333333333….
(como em: 2, 3/1, 4, 1/3)

Desculpe, eu quis dizer:

//0//
////
 1/2
/////
//3//

e 28B. E produz como 0,5, 3, 2, 0.

JavaScript (ES6), 86 bytes

Saídas 0 para Norte, 1 para Leste, 2 para Sul e 3 para Oeste.

////  _//
////  =//
_=>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>

MATL , 11 bytes

HxI
xFx
TxK

Experimente online!

Vamos começar com isso no MATL. O principal desafio é que o MATL falhará se uma função exigir entrada se a pilha estiver vazia. Talvez algo inteligente com modificadores como X, Y, Ze &poderia fazer algo mais curto, mas eu não poderia encontrar uma combinação adequada.

Explicação: todos os caracteres colocam um único número inteiro na pilha e os xremovem todos, exceto o último.

Perl, 49 bytes

Código de 48 bytes + 1 para -p.

Pressupõe entrada vazia que o TIO não suporta; portanto, uma nova linha é adicionada em seu lugar e não usada. Impressões N , E , S , W .

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

Experimente online!

C (gcc) , 120 bytes

Eu esperava mais sinergia entre as variantes.

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

Norte

Leste

Sul

Oeste