Aufgabe

Sie sind für die Herstellung eines Kompasses verantwortlich.

Stellen Sie sich Ihren Quellcode als die "Kompassnadel" vor, bei der das Ausführen in verschiedenen Ausrichtungen zu einer unterschiedlichen Ausgabe führt.

Unterstützte Quellcode-Ausrichtungen sind Nord, Ost, Süd und West.

Beispiel

Angenommen, Sie haben Quellcode:

ABCD
 J K
WXYZ

Wir betrachten dies als Nordausrichtung, die uns durch Drehen um 90 Grad im Uhrzeigersinn nach Osten zeigt:

W A
XJB
Y C
ZKD

erneutes Drehen zeigt nach Süden:

ZYXW
K J 
DCBA

und schließlich die letzte Rotation nach Westen:

DKZ
C Y
BJX
A W

Bei der Ausführung sollte jedes der obigen Codebeispiele ein einzelnes druckbares ASCII- Zeichen Ihrer Wahl ausgeben .

Anmerkungen

Ihr Code wird keine Eingabe nehmen.

Leerzeichen oder neue Linien werden beim Drehen nicht ausgeblendet.

Führende / nachfolgende neue Zeilen sind in der Ausgabe in Ordnung.

Antworten können ganze Programme oder Funktionen sein, also an STDOUT ausgegeben werden oder das Funktionsergebnis zurückgeben.

Es gelten die Standardregeln für Code-Golf . kürzeste Antwort in Bytes gewinnt!

Gelee , 2 Bytes

*2

Probieren Sie es online!

Beachten Sie, dass der Haupteintrag für ein Jelly-Programm die letzte Verknüpfung ist, über die ein Zeilenumbruchzeichen Verknüpfungen aufteilt. Keines der zweizeiligen Programme greift tatsächlich auf die oberste Verknüpfung zu.

Die vier vollständigen Programme, die alle implizit das Ergebnis ausgeben, sind:

Norden :

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

Osten :

*
2    -> literal 2 = 2

Süden :

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

Westen :

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

Japt , 3 2 Bytes

gy

Irgendwie irgendwie , fand ich eine extrem Hacky 2-Byte - Lösung ...

Nord - Ausgänge 0:

gy

Da keine impliziten Eingaben vorhanden sind, ist der Standardwert "" 0. gon a number gibt das Vorzeichen der Zahl unabhängig von ihren Argumenten zurück ( "y"in diesem Fall).

Ost- Ausgänge 2:

g
y

In einem mehrzeiligen Programm setzt die erste Zeile die Eingabe auf das Ergebnis. Dies ist im Grunde ein No-Op, da gauf 0ist 0. Dann ygibt die GCD von 0und ... da es ein Argument fehlt, wird standardmäßig 2(danke, lautet die Standardeinstellung @Oliver !). Dies ergibt 2als Ausgabe.

Süd Ausgänge g:

yg

yist nach wie vor GCD. Da GCD (0, x) ist , x für jeden Wert,y auf0 die Freiheit nimmt nur ihr Argument zurück. In diesem Fall ist das Argument "g", welches das Ergebnis ist.

West Ausgänge1 :

y
g

yon 0 kehrt wie zuvor zurück 2. Dies wird dann an übergeben g, was (wie bereits erläutert) die Vorzeichenfunktion für Zahlen ist. Daher ist das Ergebnis 1.

Java (OpenJDK 8) , 7309 4421 855 Bytes

^{-2888 Bytes dank Leaky Nun
-3566 Bytes dank 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//

Probieren Sie es online!

Alte Version

Einfacher Ansatz mit Kommentaren, die den Code ^ 2-Quadrat einschließen, dies kann in so ziemlich jeder Sprache erfolgen.
Ein (besser lesbares) Beispiel in Python

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

Brain-Flak , 33 Bytes

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

Probieren Sie es online!

Brain-Flak , 33 Bytes

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

Probieren Sie es online!

Brain-Flak , 36 Bytes

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

Probieren Sie es online!

Brain-Flak , 38 Bytes

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

Probieren Sie es online!

Brain-Flak , 41 Bytes

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

Probieren Sie es online!

Alice , 17 Bytes

1/ 3<
vPo</
5} @<

Ausgänge 1. Probieren Sie es online!

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

Ausgänge x. Probieren Sie es online!

<@ }5
/<oPv
<3 /1

Ausgänge 5. Probieren Sie es online!

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

Ausgänge 3. Probieren Sie es online!

Befunge, 17 13 Bytes

Ich dachte, Befunge würde bei einem geometrischen Problem Spaß machen. Es gibt eine einfache 4x4-Lösung, die mit anderen hier vergleichbar ist (ich benötige 3 Befehle), aber ich habe es ein bisschen besser geschafft.

Edit: Newlines vergessen

Edit 2: erkannte, dass ich eine Katze erschaffen konnte

Edit 3: Die Katze ist tot

2v3
@.v
.  
1@.

RIP Kitty: <

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

05AB1E , 5 3 Bytes

Y'X

Norden , Osten , Süden , Westen

C (gcc) , 283 279 209 Bytes

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

Probieren Sie es online!

Selber alter Kommentar-Trick hier, aber zumindest in C wird das nicht riesig ;)

• -4, danke an ETHproductions !
• feste WRichtung und -70 (!) Bytes dank Kommentaren von ETHproductions

Labyrinth , 9 Bytes

!
2@2
 !)

Druckt 0. Probieren Sie es online!

 2)
 @!
!2

Druckt 3. Probieren Sie es online!

)!
2@2
  !

Druckt 1. Probieren Sie es online!

 2!
!@
)2

Druckt 2.Probieren Sie es online!

Erläuterung

Jedes Programm beginnt mit dem ersten Leerzeichen in der Lesereihenfolge (dh entweder dem Zeichen oben links oder oben in der Mitte) und bewegt sich nach Osten. Für das erste Programm:

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

Für das zweite Programm:

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.

Für das dritte Programm:

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

Für das vierte Programm:

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@$
)))

Druckt 0.Probieren Sie es online!

)O
)@
)$

Druckt 1.Probieren Sie es online!

)))
$@O

Druckt 3.Probieren Sie es online!

$)
@)
O)

Druckt 2. Probieren Sie es online!

Erläuterung

Das erste Programm ist einfach genug: O druckt eine implizite Null und@ beendet das Programm.

Ab dem zweiten Programm müssen wir uns das dreieckige Raster ansehen, um den Kontrollfluss zu verstehen:

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

Für das dritte Programm:

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

Das vierte ist, wo es wirklich funky wird. Gestrichelte Linien kennzeichnen Zellen, die nicht ausgeführt werden, weil sie vom folgenden Befehl übersprungen werden $:

$   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#

Missbräuche Kommentare ( #) mögen verrückt sein, und die Tatsache, dass eine einzelne Zahl, die in die Pipeline eingefügt wird, unverändert ausgegeben wird. Die oben genannten Drucke 1.Probieren Sie es online!

An dieser Stelle können Sie leicht erkennen, dass jede Drehung nur eine Zahl "links" in den Kommentaren ergibt und somit nur eine Zahl pro Drehung ausgegeben wird.

Dank Wheat Wizard 9 Bytes gespart !

Sternenhimmel , 34 Bytes

  zz  
  +   
   .  
    + 
      

Oder mit Leerzeichen, die als Bindestriche angezeigt werden, damit Sie sie sehen können:

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

Probieren Sie es online!

Die Befehle in Starry sind +, .und einige andere Dinge, und was sie tun , ist dadurch bestimmt, wie viele Räume gibt , bevor sie sind: eine +mit n Leerzeichen Schübe n -5 auf den Stapel, und. mit einer geraden Anzahl von Räumen druckt. Das zs und die Zeilenumbrüche werden vollständig ignoriert.

Es gibt 6 Leerzeichen vor dem ersten + also drückt es 6−5 = 1 und .druckt es aus.

Und die Drehungen:

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

Probieren Sie es online!Dies druckt "8".

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

Probieren Sie es online!Dies druckt "2".

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

Probieren Sie es online! Und dies druckt "3".

Gleichstrom , 9 Bytes

 1
2p3
 4

Probieren Sie es online!

Ich denke, seine Offensichtlichkeit ist Teil des Charmes.

Batch, 90 Bytes

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

Batch hat eigentlich keinen Kommentarcharakter. Bei ganzzeiligen Kommentaren :funktioniert dies, da es eine Bezeichnung einführt, aber ich benötige immer noch etwas, um den echoBefehl zu beenden, während ich im umgekehrten Fall ein No-Op bin. &:scheint zu funktionieren, was hier alles ist, was ich brauche, aber es verwirrt Batch wirklich, macht einen Fehler, wenn ich in der nächsten Zeile kein :vor das setze @, und vergisst irgendwie, eine neue Zeile zu drucken.

MATLAB, 29 17 5 11 Bytes

Nachdem wir erkannt haben, dass die Frage nach einzelnen ASCII-Zeichen und nicht nur nach einer bestimmten Ausgabe lautet, folgt ein MATLAB-Ansatz, der genau dies ermöglicht:

%4%
1%3
%2%

Dies gibt implizit 1, 2, 3 oder 4 aus, abhängig von der Drehung.

Kardinal , 20 17 12 11 Bytes

.$
Z%"
+$v

Probieren Sie es online!

Während dieser ganzen Zeit antwortete niemand auf Kardinal? Dieser erste gibt aus0 .

Osten

 +Z.
 $%$
 v"

Probieren Sie es online!

Ausgänge 1.

Süd

v$+
"%Z
 $.

Probieren Sie es online!

Gibt ein Leerzeichen aus.

Westen

 "v
$%$
.Z+

Probieren Sie es online!

Ausgänge v.

SOGL V0.12 , 4 Bytes

5H
I

Ausgänge 1, probieren Sie es hier!

I5
 H

Ausgänge H, probieren Sie es hier!

 I
H5

Ausgänge 5, probieren Sie es hier!

H
5I

Ausgänge 6, probieren Sie es hier!

JS, 17B

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

Ausgänge:
Nord: 2,
Ost: 3,
Süd: 4,
West: 0,33333333333….
(wie in: 2, 3/1, 4, 1/3)

Entschuldigung, ich meinte:

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

und 28B. Und Ausgänge als 0,5, 3, 2, 0.

JavaScript (ES6), 86 Byte

Ausgänge 0 für Nord, 1 für Ost, 2 für Süd und 3 für 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>

MATL , 11 Bytes

HxI
xFx
TxK

Probieren Sie es online!

Beginnen wir damit in MATL. Die größte Herausforderung besteht darin, dass MATL nur dann fehlschlägt, wenn für eine Funktion eine Eingabe erforderlich ist, wenn der Stapel leer ist. Vielleicht etwas gescheites mit Modifikatoren wieX , Y, Zund &kürzer für etwas machen könnte, aber ich konnte keine passende Kombination finden.

Erläuterung: Alle Zeichen verschieben eine einzelne Ganzzahl auf den Stapel und xentfernen alle Zeichen außer dem letzten.

Perl, 49 Bytes

48 Byte Code + 1 für -p.

Nimmt eine leere Eingabe an, die von TIO nicht unterstützt wird. Daher wird an ihrer Stelle eine neue Zeile hinzugefügt und nicht verwendet. Druck N , E , S , W .

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

Probieren Sie es online!

C (gcc) , 120 Bytes

Ich hatte mir mehr Synergie zwischen den Varianten erhofft.

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

Norden

Osten

Süd

Westen