Zadanie

Jesteś odpowiedzialny za tworzenie kompasu.

Wyobraź sobie swój kod źródłowy jako „igłę” kompasu, gdzie bieganie w różnych orientacjach daje wyraźne wyniki.

Obsługiwane orientacje kodu źródłowego to Północ, Wschód, Południe i Zachód.

Przykład

Powiedzmy, że masz kod źródłowy:

ABCD
 J K
WXYZ

Rozważymy to jako orientację północną, obrót o 90 stopni zgodnie z ruchem wskazówek zegara skieruje nas na wschód:

W A
XJB
Y C
ZKD

obracanie ponownie wskazuje południe:

ZYXW
K J 
DCBA

i wreszcie ostatnia rotacja na Zachód:

DKZ
C Y
BJX
A W

Po uruchomieniu, każdy z powyższych przykładów kodu powinien wypisać jeden, wyraźny znak ASCII do wydrukowania, który wybierzesz.

Notatki

Twój kod nie przyjmuje żadnych danych wejściowych.

Puste spacje lub nowe linie nie zapadają się / nie znikają podczas obracania.

Wiodące / końcowe nowe linie są w porządku.

Odpowiedzi mogą być całymi programami lub funkcjami, dlatego są wysyłane do STDOUT lub zwracają wynik funkcji.

Obowiązują standardowe zasady gry w golfa ; najkrótsza odpowiedź w bajtach wygrywa!

Galaretka , 2 bajty

*2

Wypróbuj online!

Zauważ, że głównym wpisem dla programu Jelly jest jego ostatni link, w którym dowolny znak nowej linii podzieli linki), żaden z programów dwuwierszowych nie ma dostępu do swojego górnego linku.

Cztery pełne programy, z których wszystkie pośrednio wypisują swój wynik, to:

Północ :

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

Wschód :

*
2    -> literal 2 = 2

Południe :

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

Zachód :

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

Japt , 3 2 bajty

gy

W jakiś sposób znalazłem bardzo zhackowane 2-bajtowe rozwiązanie ...

Wyjścia północne0 :

gy

Ponieważ nie ma żadnych niejawnych danych wejściowych, domyślnie jest to 0. gna liczbę zwraca znak liczby niezależnie od jej argumentów ( "y"w tym przypadku).

Wyjścia wschodnie2 :

g
y

W programie wieloliniowym pierwszy wiersz ustawia dane wejściowe na wynik. Jest to w zasadzie brak możliwości, ponieważ gon 0jest 0. Następnie yzwraca GCD 0i ... ponieważ brakuje argumentu, domyślnie jest to 2(dzięki, @Oliver !). Daje to 2jako wynik.

Wyjścia południoweg :

yg

y, jak poprzednio, jest GCD. Ponieważ gcd (0, x) jest x dla dowolnej wartości, yon może 0swobodnie zwrócić swój argument. W tym przypadku argumentem jest "g"wynik.

Wyjścia zachodnie1 :

y
g

yna 0, jak poprzednio, zwraca 2. Jest to następnie przekazywane do g, która (jak już omówiono) jest funkcją znaku na liczbach. Dlatego wynik jest 1.

Java (OpenJDK 8) , 7309 4421 855 bajtów

^{-2888 bajtów dzięki Leaky Nun
-3566 bajtów dzięki 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//

Wypróbuj online!

Stara wersja

Proste podejście z komentarzami owijającymi kod ^ 2, można to zrobić w prawie każdym języku.
(bardziej czytelny) przykład w pythonie

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

Brain-Flak , 33 bajty

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

Wypróbuj online!

Brain-Flak , 33 bajty

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

Wypróbuj online!

Brain-Flak , 36 bajtów

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

Wypróbuj online!

Brain-Flak , 38 bajtów

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

Wypróbuj online!

Brain-Flak , 41 bajtów

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

Wypróbuj online!

Alice , 17 bajtów

1/ 3<
vPo</
5} @<

Wyjścia 1. Wypróbuj online!

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

Wyjścia x. Wypróbuj online!

<@ }5
/<oPv
<3 /1

Wyjścia 5. Wypróbuj online!

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

Wyjścia 3. Wypróbuj online!

Befunge, 17 13 bajtów

Myślałem, że Befunge będzie świetną zabawą dla problemu geometrycznego. Istnieje trywialne rozwiązanie 4x4 podobne do innych tutaj (potrzebuję 3 poleceń), ale udało mi się trochę lepiej.

Edycja: zapomniałem o nowych liniach

Edycja 2: zdałem sobie sprawę, że mogę stworzyć kota

Edycja 3: kot nie żyje

2v3
@.v
.  
1@.

Kitty RIP: <

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

05AB1E , 5 3 bajty

Y'X

Północ , Wschód , Południe , Zachód

C (gcc) , 283 279 209 bajtów

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

Wypróbuj online!

Ta sama stara sztuczka z komentarzem tutaj, ale przynajmniej w C nie robi się to huuuge ;)

• -4, dzięki produktom ETH !
• naprawiono Wkierunek i -70 (!) bajtów dzięki komentarzom ETHproductions

Labirynt , 9 bajtów

!
2@2
 !)

Wydruki 0.Wypróbuj online!

 2)
 @!
!2

Wydruki 3.Wypróbuj online!

)!
2@2
  !

Wydruki 1.Wypróbuj online!

 2!
!@
)2

Wydruki 2 . Wypróbuj online!

Wyjaśnienie

Każdy program rozpoczyna się od pierwszej spacji w kolejności odczytywania (tj. Albo w lewym górnym rogu, albo w górnym środkowym znaku), przesuwając się na wschód. Dla pierwszego programu:

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

W przypadku drugiego programu:

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.

W przypadku trzeciego programu:

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

W przypadku czwartego programu:

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 bajtów

O@$
)))

Wydruki0 . Wypróbuj online!

)O
)@
)$

Wydruki1 . Wypróbuj online!

)))
$@O

Wydruki3 . Wypróbuj online!

$)
@)
O)

Wydruki 2.Wypróbuj online!

Wyjaśnienie

Pierwszy program jest dość prosty: Owypisuje ukryte zero i@ kończy program.

Począwszy od drugiego programu, musimy spojrzeć na trójkątny układ siatki, aby zrozumieć przepływ sterowania:

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

W przypadku trzeciego programu:

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

Czwarty z nich jest naprawdę funky. Linie przerywane wskazują komórki, które nie są wykonywane, ponieważ są pomijane przez $:

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

PowerShell , 20 11 bajtów

#4#
1#3
#2#

Nadużywa komentarzy ( #) jak wariactwo, a fakt, że pojedyncza liczba umieszczona w potoku jest wyświetlana w niezmienionej postaci. Powyższe wydruki 1. Wypróbuj online!

Stąd możesz łatwo zobaczyć, że każdy obrót daje tylko jedną liczbę, która znajduje się po „lewej” stronie komentarza, a więc jest tylko jedna liczba, która będzie wyprowadzana na obrót.

Oszczędność 9 bajtów dzięki Kreatorowi pszenicy !

Gwiaździsta , 34 bajty

  zz  
  +   
   .  
    + 
      

Lub ze spacjami pokazanymi jako łączniki, abyś mógł je zobaczyć:

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

Wypróbuj online!

Komendy w Starry to + , .i kilka innych rzeczy, i to, co robią jest określana przez ile przestrzenie są przed nimi: a +z n obowiązuje popycha n -5 do stosu oraz .o liczbie miejsc odbitek nawet nim. Thez s i nowe linie są ignorowane w całości.

Przed pierwszym jest 6 spacji, +więc wypycha 6-5 = 1 i .drukuje.

I obroty:

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

Wypróbuj online! To wyświetla „8”.

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

Wypróbuj online! To wyświetla „2”.

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

Wypróbuj online! I to wyświetla „3”.

dc , 9 bajtów

 1
2p3
 4

Wypróbuj online!

Myślę, że jego oczywistość jest częścią uroku.

Partia, 90 bajtów

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

Batch tak naprawdę nie ma znaku komentarza. W przypadku komentarzy obejmujących całą linię :działa, ponieważ wprowadza etykietę, ale nadal potrzebuję czegoś, aby zakończyć echopolecenie, będąc odwróconym opcją. &:wydaje się działać, co jest wszystkim, czego potrzebuję tutaj, ale naprawdę wprowadza w błąd Batch, popełniając błąd, jeśli nie wstawię znaku :przed @następnym wierszem, a także w jakiś sposób zapominam o wydrukowaniu nowego wiersza.

MATLAB, 29 17 5 11 bajtów

Po zrozumieniu, że pytanie wymaga pojedynczych znaków ASCII, a nie tylko wyraźnego wyniku, oto podejście MATLAB, które zrobi to:

%4%
1%3
%2%

Spowoduje to niejawne wydrukowanie 1, 2, 3 lub 4 w zależności od obrotu.

Kardynał , 20 17 12 11 bajtów

.$
Z%"
+$v

Wypróbuj online!

Cały czas i nikt nie odpowiedział w Kardynale? Ten pierwszy wychodzi0 .

Wschód

 +Z.
 $%$
 v"

Wypróbuj online!

Wyjścia 1.

południe

v$+
"%Z
 $.

Wypróbuj online!

Wyprowadza spację.

Zachód

 "v
$%$
.Z+

Wypróbuj online!

Wyjścia v.

SOGL V0.12 , 4 bajty

5H
I

Wyjścia 1, wypróbuj tutaj!

I5
 H

Wyjścia H, wypróbuj tutaj!

 I
H5

Wyjścia 5, wypróbuj tutaj!

H
5I

Wyjścia 6, wypróbuj tutaj!

JS, 17 B.

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

Wyjścia:
północ: 2,
wschód: 3,
południe: 4,
zachód: 0,333333333333….
(jak w: 2, 3/1, 4, 1/3)

Przepraszam, miałem na myśli:

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

i 28B. I wyniki jako 0,5, 3, 2, 0.

JavaScript (ES6), 86 bajtów

Wyjścia 0 dla Północy, 1 dla Wschodu, 2 dla Południa i 3 dla Zachodu.

////  _//
////  =//
_=>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 bajtów

HxI
xFx
TxK

Wypróbuj online!

Zacznijmy od MATL. Głównym wyzwaniem jest to, że MATL po prostu zawodzi, jeśli funkcja wymaga danych wejściowych, jeśli stos jest pusty. Może coś z modyfikatorów, jak mądry X, Y,Z i& mógłby zrobić coś krótszego, ale nie mogłem znaleźć odpowiednią kombinację.

Objaśnienie: wszystkie postacie wypychają na stos pojedynczą liczbę całkowitą i xusuwają wszystkie oprócz ostatniej.

Perl, 49 bajtów

Kod 48 bajtów + 1 dla -p.

Zakłada puste dane wejściowe, których TIO nie obsługuje, więc nowa linia jest dodawana i nie jest używana. Wydruki N , E , S , W .

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

Wypróbuj online!

C (gcc) , 120 bajtów

Miałem nadzieję na większą synergię między wariantami.

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

Północ

Wschód

południe

Zachód