Tarea

Estás a cargo de hacer una brújula, más o menos.

Imagine su código fuente como la "aguja" de la brújula donde el correr en diferentes orientaciones produce una salida distinta.

Las orientaciones de código fuente admitidas son Norte, Este, Sur y Oeste.

Ejemplo

Digamos que tienes el código fuente:

ABCD
 J K
WXYZ

Consideraremos que esta es la orientación Norte, girando 90 grados en el sentido de las agujas del reloj nos señala al Este:

W A
XJB
Y C
ZKD

girando nuevamente apunta al sur:

ZYXW
K J 
DCBA

y finalmente, la última rotación hacia el oeste:

DKZ
C Y
BJX
A W

Cuando se ejecuta, cada uno de los ejemplos de código anteriores debe generar un carácter ASCII imprimible único y distinto de su elección.

Notas

Su código no tendrá entrada.

Los espacios vacíos o las nuevas líneas no colapsan / desaparecen al girar.

Las nuevas líneas iniciales / finales están bien en la salida.

Las respuestas pueden ser programas completos o funciones, por lo tanto, se envían a STDOUT o devuelven el resultado de la función.

Se aplican reglas estándar de código de golf ; ¡La respuesta más corta en bytes gana!

Jalea , 2 bytes

*2

Pruébalo en línea!

Tenga en cuenta que la entrada principal para un programa Jelly es su último enlace, donde cualquier personaje de nueva línea dividirá los enlaces), ninguno de los programas de dos líneas accede realmente a su enlace superior.

Los cuatro programas completos, todos los cuales imprimen implícitamente su resultado, son:

Norte :

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

Este :

*
2    -> literal 2 = 2

Sur :

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

Oeste :

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

Japt , 3 2 bytes

gy

De alguna manera, de alguna manera , encontré una solución extremadamente hacky de 2 bytes ...

Salidas del norte0 :

gy

Como no hay entrada implícita, su valor predeterminado es 0. gen un número devuelve el signo del número independientemente de sus argumentos ( "y"en este caso).

Salidas del este2 :

g
y

En un programa de varias líneas, la primera línea establece la entrada a su resultado. Esto es básicamente un no-op, ya que gon 0es 0. Luego ydevuelve el GCD de 0y ... ya que le falta un argumento, su valor predeterminado es 2(¡gracias, @Oliver !). Esto da 2como salida.

Salidas del surg :

yg

y, como antes, es GCD. Como gcd (0, x) es x para cualquier valor, yon se 0toma la libertad de devolver su argumento. En este caso, el argumento es "g"cuál es el resultado.

Salidas del oeste1 :

y
g

yen 0, como antes, vuelve 2. Esto se pasa a g, que (como ya se discutió) es la función de signo en los números. Por lo tanto, el resultado es 1.

Java (OpenJDK 8) , 7309 4421 855 bytes

^{-2888 bytes gracias a Leaky Nun
-3566 bytes gracias a 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//

Pruébalo en línea!

Versión antigua

Enfoque directo con comentarios que envuelven el código ^ 2 cuadrado, esto se puede hacer en casi cualquier idioma.
Un ejemplo (más legible) en Python

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

Brain-Flak , 33 bytes

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

Pruébalo en línea!

Brain-Flak , 33 bytes

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

Pruébalo en línea!

Brain-Flak , 36 bytes

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

Pruébalo en línea!

Brain-Flak , 38 bytes

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

Pruébalo en línea!

Brain-Flak , 41 bytes

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

Pruébalo en línea!

Alice , 17 bytes

1/ 3<
vPo</
5} @<

Salidas 1. Pruébalo en línea!

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

Salidas x. Pruébalo en línea!

<@ }5
/<oPv
<3 /1

Salidas 5. Pruébalo en línea!

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

Salidas 3. Pruébalo en línea!

Befunge, 17 13 bytes

Pensé que Befunge sería divertido para un problema geométrico. Hay una solución trivial 4x4 similar a otras aquí (necesito 3 comandos) pero me las arreglé un poco mejor.

Editar: se olvidó de las nuevas líneas

Edición 2: me di cuenta de que podía crear un gato

Edición 3: el gato está muerto

2v3
@.v
.  
1@.

Gatito RIP: <

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

05AB1E , 5 3 bytes

Y'X

Norte , este , sur , oeste

C (gcc) , 283 279 209 bytes

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

Pruébalo en línea!

El mismo viejo truco de comentarios aquí, pero al menos, en C, esto no se vuelve enorme ;)

• -4, gracias a ETHproductions !
• Wdirección fija y -70 (!) bytes gracias a los comentarios de ETHproductions

Laberinto , 9 bytes

!
2@2
 !)

Impresiones 0. Pruébalo en línea!

 2)
 @!
!2

Impresiones 3. Pruébalo en línea!

)!
2@2
  !

Impresiones 1. Pruébalo en línea!

 2!
!@
)2

Impresiones 2. Pruébalo en línea!

Explicación

Cada programa comienza en el primer espacio no ordenado en orden de lectura (es decir, el carácter superior izquierdo o superior central), moviéndose hacia el este. Para el primer 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 el 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 el tercer 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 el cuarto 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@$
)))

Impresiones 0. Pruébalo en línea!

)O
)@
)$

Impresiones 1. Pruébalo en línea!

)))
$@O

Impresiones 3. Pruébalo en línea!

$)
@)
O)

Impresiones 2. Pruébalo en línea!

Explicación

El primer programa es bastante fácil: Oimprime un cero implícito y @termina el programa.

Comenzando en el segundo programa, debemos observar el diseño de la cuadrícula triangular para comprender el flujo de control:

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

Para el tercer programa:

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

El cuarto es donde se pone realmente funky. Las líneas discontinuas indican celdas que no se ejecutan porque son omitidas por $:

$   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 de los comentarios ( #) como una locura, y del hecho de que un solo número colocado en la tubería obtiene salida tal cual. Las impresiones de arriba 1. Pruébalo en línea!

Desde aquí, puede ver fácilmente que cada rotación produce solo un número que se encuentra a la "izquierda" de los comentarios, por lo que solo se generará un número por rotación.

¡Guardado 9 bytes gracias a Wheat Wizard !

Estrellado , 34 bytes

  zz  
  +   
   .  
    + 
      

O con espacios que se muestran como guiones para que pueda verlos:

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

Pruébalo en línea!

Los comandos en Starry son +, .y algunas otras cosas, y lo que hacen está determinado por cuántos espacios hay delante de ellos: a +con n espacios empuja n −5 a la pila, y .con un número par de espacios lo imprime. Las zlíneas sy nuevas se ignoran por completo.

Hay 6 espacios antes del primero, +por lo que empuja 6−5 = 1, y lo .imprime.

Y las rotaciones:

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

Pruébalo en línea! Esto imprime "8".

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

Pruébalo en línea! Esto imprime "2".

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

Pruébalo en línea!Y esto imprime "3".

dc , 9 bytes

 1
2p3
 4

Pruébalo en línea!

Creo que su obviedad es parte del encanto.

Lote, 90 bytes.

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

Batch realmente no tiene un carácter de comentario. Para los comentarios de línea completa, :funciona, ya que introduce una etiqueta, pero todavía necesito algo para terminar el echocomando mientras que no funciona cuando se invierte. &:parece funcionar, que es todo lo que necesito aquí, pero realmente confunde a Batch, me equivoca si no pongo un :antes @en la siguiente línea y también de alguna manera me olvido de imprimir una nueva línea.

MATLAB, 29 17 5 11 bytes

Al darse cuenta de que la pregunta requería caracteres ASCII individuales no solo una salida distinta, aquí hay un enfoque MATLAB que hará exactamente eso:

%4%
1%3
%2%

Esto imprimirá implícitamente 1, 2, 3 o 4 dependiendo de la rotación.

Cardenal , 20 17 12 11 bytes

.$
Z%"
+$v

Pruébalo en línea!

¿Todo este tiempo y nadie respondió en Cardinal? Este primero sale 0.

Este

 +Z.
 $%$
 v"

Pruébalo en línea!

Salidas 1.

Sur

v$+
"%Z
 $.

Pruébalo en línea!

Emite un espacio.

Oeste

 "v
$%$
.Z+

Pruébalo en línea!

Salidas v.

SOGL V0.12 , 4 bytes

5H
I

Salidas 1, Pruébelo aquí!

I5
 H

Salidas H, Pruébelo aquí!

 I
H5

Salidas 5, Pruébelo aquí!

H
5I

Salidas 6, Pruébelo aquí!

JS, 17 B

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

Salidas:
Norte: 2,
Este: 3,
Sur: 4,
Oeste: 0.33333333333….
(como en: 2, 3/1, 4, 1/3)

Perdon, quise decir:

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

y 28B. Y salidas como 0.5, 3, 2, 0.

JavaScript (ES6), 86 bytes

Salidas 0 para el norte, 1 para el este, 2 para el sur y 3 para el 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

Pruébalo en línea!

Comencemos esto en MATL. El desafío principal es que MATL simplemente falla si una función requiere entrada si la pila está vacía. Tal vez algo inteligente con modificadores como X, Y, Zy& podría hacer algo más corto, pero no pude encontrar una combinación adecuada.

Explicación: todos los caracteres introducen un único número entero en la pila y los xelimina a todos, excepto el último.

Perl, 49 bytes

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

Asume una entrada vacía que TIO no admite, por lo que se agrega una nueva línea en su lugar y no se usa. Imprime N , E , S , W .

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

Pruébalo en línea!

C (gcc) , 120 bytes

Esperaba más sinergia entre las variantes.

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

norte

Este

Sur

Oeste