Compito

Sei incaricato di creare una bussola, in qualche modo.

Immagina il tuo codice sorgente come "ago" della bussola in cui correre con orientamenti diversi produce un output distinto.

Gli orientamenti del codice sorgente supportati sono Nord, Est, Sud e Ovest.

Esempio

Supponiamo che tu abbia il codice sorgente:

ABCD
 J K
WXYZ

Considereremo questo l'orientamento a nord, ruotando di 90 gradi in senso orario ci indica verso est:

W A
XJB
Y C
ZKD

ruotando di nuovo punti verso sud:

ZYXW
K J 
DCBA

e, infine, l'ultima rotazione verso ovest:

DKZ
C Y
BJX
A W

Quando eseguito, ciascuno degli esempi di codice sopra riportati dovrebbe generare un singolo carattere ASCII stampabile distinto di propria scelta.

Gli appunti

Il tuo codice non deve contenere input.

Gli spazi vuoti o le nuove linee non collassano / scompaiono durante la rotazione.

Le nuove righe iniziali / finali vanno bene nell'output.

Le risposte possono essere interi programmi o funzioni, quindi essere inviati a STDOUT o restituire il risultato della funzione.

Si applicano le regole standard del code-golf ; vince la risposta più breve in byte!

Gelatina , 2 byte

*2

Provalo online!

Si noti che la voce principale per un programma Jelly è il suo ultimo collegamento, in cui qualsiasi carattere di nuova riga dividerà i collegamenti), nessuno dei due programmi di linea effettivamente accede al loro collegamento superiore.

I quattro programmi completi, che implicitamente stampano il loro risultato, sono:

Nord :

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

Est :

*
2    -> literal 2 = 2

Sud :

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

Ovest :

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

Japt , 3 2 byte

gy

In qualche modo, in qualche modo , ho trovato una soluzione estremamente caotica a 2 byte ...

Uscite nord0 :

gy

Poiché non vi è alcun input implicito, per impostazione predefinita è 0. gsu un numero restituisce il segno del numero indipendentemente dai suoi argomenti ( "y"in questo caso).

Uscite est2 :

g
y

In un programma multilinea, la prima riga imposta l'input sul suo risultato. Questo è fondamentalmente un no-op, dal momento che gil 0IS 0. Quindi yrestituisce il GCD di 0e ... poiché manca un argomento, il valore predefinito è 2(grazie, @Oliver !). Questo dà 2come output.

Uscite sudg :

yg

y, come prima, è GCD. Poiché gcd (0, x) è x per qualsiasi valore, yon si 0prende la libertà di restituire il suo argomento. In questo caso, l'argomento è "g", che è il risultato.

Uscite ovest1 :

y
g

ysu 0, come prima, ritorna 2. Questo viene quindi passato a g, che (come già discusso) è la funzione di segno sui numeri. Pertanto, il risultato è 1.

Java (OpenJDK 8) , 7309 4421 855 byte

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

Provalo online!

Vecchia versione

Un semplice approccio con commenti che racchiudono il codice ^ 2 quadrato, questo può essere fatto praticamente in qualsiasi lingua.
un esempio (più leggibile) in Python

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

Brain-Flak , 33 byte

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

Provalo online!

Brain-Flak , 33 byte

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

Provalo online!

Brain-Flak , 36 byte

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

Provalo online!

Brain-Flak , 38 byte

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

Provalo online!

Brain-Flak , 41 byte

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

Provalo online!

Alice , 17 byte

1/ 3<
vPo</
5} @<

Uscite 1. Provalo online!

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

Uscite x. Provalo online!

<@ }5
/<oPv
<3 /1

Uscite 5. Provalo online!

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

Uscite 3. Provalo online!

Befunge, 17 13 byte

Ho pensato che Befunge sarebbe stato divertente per un problema geometrico. C'è una banale soluzione 4x4 simile agli altri qui (ho bisogno di 3 comandi) ma sono riuscito un po 'meglio.

Modifica: dimenticato di newline

Modifica 2: realizzato che potrei creare un gatto

Modifica 3: il gatto è morto

2v3
@.v
.  
1@.

Gattino RIP: <

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

05AB1E , 5 3 byte

Y'X

Nord , Est , Sud , Ovest

C (gcc) , 283 279 209 byte

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

Provalo online!

Lo stesso vecchio trucco di commento qui, ma almeno, in C questo non è huuuge ;)

• -4, grazie a ETHproductions !
• Wdirezione fissa e -70 (!) byte grazie ai commenti di ETHproductions

Labirinto , 9 byte

!
2@2
 !)

Stampe 0. Provalo online!

 2)
 @!
!2

Stampe 3. Provalo online!

)!
2@2
  !

Stampe 1. Provalo online!

 2!
!@
)2

Stampe 2. Provalo online!

Spiegazione

Ogni programma inizia dal primo non spazio nell'ordine di lettura (ovvero il carattere in alto a sinistra o in alto al centro), spostandosi verso est. Per il primo programma:

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

Per il secondo programma:

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.

Per il terzo programma:

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

Per il quarto programma:

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 byte

O@$
)))

Stampe 0. Provalo online!

)O
)@
)$

Stampe 1. Provalo online!

)))
$@O

Stampe 3. Provalo online!

$)
@)
O)

Stampe 2. Provalo online!

Spiegazione

Il primo programma è abbastanza semplice: Ostampa uno zero implicito e @termina il programma.

A partire dal secondo programma, dobbiamo esaminare il layout della griglia triangolare per comprendere il flusso di controllo:

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

Per il terzo programma:

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

Il quarto è dove diventa davvero funky. Le linee tratteggiate indicano celle che non sono eseguite perché vengono ignorate da $:

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

PowerShell , 20 11 byte

#4#
1#3
#2#

Abusa dei commenti ( #) come pazzi, e il fatto che un singolo numero inserito nella pipeline ottenga un output così com'è. Le stampe sopra 1. Provalo online!

Da qui, puoi facilmente vedere che ogni rotazione produce solo un numero che si trova sulla "sinistra" dei commenti, e quindi c'è un solo numero che verrà emesso per rotazione.

Salvato 9 byte grazie a Wheat Wizard !

Stellato , 34 byte

  zz  
  +   
   .  
    + 
      

O con spazi mostrati come trattini in modo da poterli vedere:

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

Provalo online!

I comandi in Starry sono +, .e alcune altre cose, e ciò che fanno è determinato da quanti spazi ci sono prima di loro: a +con n spazi spinge n −5 nella pila e .con un numero pari di spazi lo stampa. Le zs e le nuove righe vengono completamente ignorate.

Ci sono 6 spazi prima del primo, +quindi spinge 6−5 = 1 e il. stampa.

E le rotazioni:

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

Provalo online! Questo stampa "8".

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

Provalo online! Questo stampa "2".

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

Provalo online! E questo stampa "3".

dc , 9 byte

 1
2p3
 4

Provalo online!

Penso che la sua ovvietà sia parte del fascino.

Lotto, 90 byte

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

Batch non ha davvero un carattere di commento. Per i commenti a riga intera, :funziona, poiché introduce un'etichetta, ma ho ancora bisogno di qualcosa per terminare il echocomando pur essendo una non-operazione quando invertito. &:sembra funzionare, che è tutto ciò di cui ho bisogno qui, ma confonde davvero Batch, sbagliando se non metto un :prima @sulla riga successiva e anche in qualche modo dimenticare di stampare una nuova riga.

MATLAB, 29 17 5 11 byte

Avendo capito che la domanda richiedeva singoli caratteri ASCII non solo un output distinto, ecco un approccio MATLAB che farà proprio questo:

%4%
1%3
%2%

Ciò stamperà implicitamente 1, 2, 3 o 4 a seconda della rotazione.

Cardinale , 20 17 12 11 byte

.$
Z%"
+$v

Provalo online!

Per tutto questo tempo e nessuno ha risposto in Cardinale? Questo primo emette0 .

est

 +Z.
 $%$
 v"

Provalo online!

Uscite 1.

Sud

v$+
"%Z
 $.

Provalo online!

Emette uno spazio.

ovest

 "v
$%$
.Z+

Provalo online!

Uscite v.

SOGL V0.12 , 4 byte

5H
I

Uscite 1, provalo qui!

I5
 H

Uscite H, provalo qui!

 I
H5

Uscite 5, provalo qui!

H
5I

Uscite 6, provalo qui!

JS, 17 B

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

Uscite:
Nord: 2,
Est: 3,
Sud: 4,
Ovest: 0.33333333333….
(come in: 2, 3/1, 4, 1/3)

Scusa, volevo dire:

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

e 28B. E produce 0,5, 3, 2, 0.

JavaScript (ES6), 86 byte

Emette 0 per Nord, 1 per Est, 2 per Sud e 3 per Ovest.

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

HxI
xFx
TxK

Provalo online!

Cominciamo in MATL. La sfida principale è che MATL fallisce solo se una funzione richiede input se lo stack è vuoto. Forse qualcosa di intelligente con i modificatori come X, Y, Ze &potrebbe fare per qualcosa di più breve, ma non ho potuto trovare una combinazione adatta.

Spiegazione: tutti i caratteri inseriscono un singolo numero intero nello stack e li xrimuove tutti tranne l'ultimo.

Perl, 49 byte

48 byte codice + 1 per -p.

Presuppone input vuoti che TIO non supporta, quindi una nuova riga viene aggiunta al suo posto e non utilizzata. Stampe N , E , S , W .

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

Provalo online!

C (gcc) , 120 byte

Avevo sperato in una maggiore sinergia tra le varianti.

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

Nord

est

Sud

ovest