Tâche

Vous êtes en charge de fabriquer une boussole, en quelque sorte.

Imaginez votre code source comme «l'aiguille» de la boussole où courir à différentes orientations produit une sortie distincte.

Les orientations de code source prises en charge sont le nord, l'est, le sud et l'ouest.

Exemple

Disons que vous avez du code source:

ABCD
 J K
WXYZ

Nous considérerons ceci comme l'orientation Nord, une rotation de 90 degrés dans le sens horaire nous pointe vers l'Est:

W A
XJB
Y C
ZKD

tourner à nouveau pointe vers le sud:

ZYXW
K J 
DCBA

et enfin, la dernière rotation vers l'Ouest:

DKZ
C Y
BJX
A W

Lorsqu'il est exécuté, chacun des exemples de code ci-dessus doit générer un seul caractère ASCII imprimable distinct de votre choix.

Remarques

Votre code ne prendra aucune entrée.

Les espaces vides ou les nouvelles lignes ne s'effondrent pas / ne disparaissent pas lors de la rotation.

Les nouvelles lignes de début / fin sont correctes en sortie.

Les réponses peuvent être des programmes ou des fonctions entières, donc sorties vers STDOUT ou retour du résultat de la fonction.

Les règles de code-golf standard s'appliquent; réponse la plus courte en octets gagne!

Gelée , 2 octets

*2

Essayez-le en ligne!

Notez que l'entrée principale d'un programme Jelly est son dernier lien, où tout caractère de nouvelle ligne divisera les liens), aucun des programmes à deux lignes n'accède réellement à son lien supérieur.

Les quatre programmes complets, qui impriment tous implicitement leur résultat, sont:

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

Ouest :

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

Japt , 3 2 octets

gy

D'une manière ou d'une autre , j'ai trouvé une solution extrêmement hacky sur 2 octets ...

Sorties Nord0 :

gy

Puisqu'il n'y a pas d'entrée implicite, il est par défaut 0. gsur un nombre renvoie le signe du nombre indépendamment de ses arguments ( "y"dans ce cas).

Sorties Est2 :

g
y

Dans un programme à plusieurs lignes, la première ligne définit l'entrée sur son résultat. Ceci est essentiellement un no-op, puisque gsur 0est - 0. yRetourne ensuite le GCD de0 et ... comme il manque un argument, il est par défaut 2(merci, @Oliver !). Cela donne 2comme sortie.

Sorties Sudg :

yg

y, comme précédemment, est GCD. Puisque gcd (0, x) est x pour n'importe quelle valeur, yon 0prend la liberté de simplement renvoyer son argument. Dans ce cas, l'argument est "g", qui est le résultat.

OuestSorties1 :

y
g

ysur 0, comme précédemment, revient 2. Ceci est ensuite transmis à g, qui (comme déjà discuté) est la fonction de signe sur les nombres. Par conséquent, le résultat est 1.

Java (OpenJDK 8) , 7309 4421 855 octets

^{-2888 octets grâce à Leaky Nun
-3566 octets grâce à 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//

Essayez-le en ligne!

Ancienne version

Une approche simple avec des commentaires enveloppant le code ^ 2 carré, cela peut être fait dans à peu près n'importe quelle langue.
un exemple (plus lisible) en python

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

Brain-Flak , 33 octets

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

Essayez-le en ligne!

Brain-Flak , 33 octets

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

Essayez-le en ligne!

Brain-Flak , 36 octets

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

Essayez-le en ligne!

Brain-Flak , 38 octets

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

Essayez-le en ligne!

Brain-Flak , 41 octets

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

Essayez-le en ligne!

Alice , 17 octets

1/ 3<
vPo</
5} @<

Sorties 1. Essayez-le en ligne!

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

Sorties x. Essayez-le en ligne!

<@ }5
/<oPv
<3 /1

Sorties 5. Essayez-le en ligne!

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

Sorties 3. Essayez-le en ligne!

Befunge, 17 13 octets

Je pensais que Befunge serait amusant pour un problème géométrique. Il y a une solution 4x4 triviale semblable à d'autres ici (j'ai besoin de 3 commandes) mais j'ai réussi un peu mieux.

Modifier: oublié les nouvelles lignes

Edit 2: réalisé que je pouvais créer un chat

Edit 3: le chat est mort

2v3
@.v
.  
1@.

Kitty RIP: <

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

05AB1E , 5 3 octets

Y'X

Nord , Est , Sud , Ouest

C (gcc) , 283 279 209 octets

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

Essayez-le en ligne!

Même vieux truc de commentaire ici, mais au moins, en C, cela ne devient pas huuuge ;)

• -4, grâce à ETHproductions !
• Wdirection fixe et -70 (!) octets grâce aux commentaires d' ETHproductions

Labyrinthe , 9 octets

!
2@2
 !)

Impressions 0. Essayez-le en ligne!

 2)
 @!
!2

Impressions 3. Essayez-le en ligne!

)!
2@2
  !

Impressions 1. Essayez-le en ligne!

 2!
!@
)2

Impressions 2. Essayez-le en ligne!

Explication

Chaque programme commence au premier non-espace dans l'ordre de lecture (c'est-à-dire soit le caractère supérieur gauche ou supérieur central), se déplaçant vers l'est. Pour le premier programme:

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

Pour le deuxième programme:

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.

Pour le troisième programme:

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

Pour le quatrième programme:

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 octets

O@$
)))

Impressions 0. Essayez-le en ligne!

)O
)@
)$

Impressions 1. Essayez-le en ligne!

)))
$@O

Impressions 3. Essayez-le en ligne!

$)
@)
O)

Impressions 2. Essayez-le en ligne!

Explication

Le premier programme est assez simple: Oimprime un zéro implicite et@ termine le programme.

À partir du deuxième programme, nous devons examiner la disposition de la grille triangulaire pour comprendre le flux de contrôle:

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

Pour le troisième programme:

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

Le quatrième est l'endroit où ça devient vraiment génial. Les lignes en pointillés indiquent les cellules qui ne sont pas exécutées car elles sont ignorées par $:

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

PowerShell , 20 11 octets

#4#
1#3
#2#

Abuse les commentaires ( #) comme des fous, et le fait qu'un seul numéro placé sur le pipeline soit sorti tel quel. Les impressions ci-dessus 1. Essayez-le en ligne!

De là, vous pouvez facilement voir que chaque rotation ne produit qu'un seul nombre qui se trouve à la "gauche" des commentaires, et donc il n'y a qu'un seul nombre qui sera affiché par rotation.

Enregistré 9 octets grâce à Wheat Wizard !

Étoilé , 34 octets

  zz  
  +   
   .  
    + 
      

Ou avec des espaces représentés par des tirets pour que vous puissiez les voir:

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

Essayez-le en ligne!

Les commandes dans Starry sont +, entre .autres choses, et ce qu'elles font est déterminé par le nombre d'espaces devant elles: a +avec n espaces pousse n −5 dans la pile, et .avec un nombre pair d'espaces l'imprime. lez s et les nouvelles lignes sont complètement ignorés.

Il y a 6 espaces avant le premier +donc il pousse 6−5 = 1, et le. affiche.

Et les rotations:

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

Essayez-le en ligne! Cela imprime "8".

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

Essayez-le en ligne! Cela imprime "2".

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

Essayez-le en ligne! Et cela imprime "3".

dc , 9 octets

 1
2p3
 4

Essayez-le en ligne!

Je pense que son évidence fait partie du charme.

Lot, 90 octets

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

Le lot n'a pas vraiment de caractère de commentaire. Pour les commentaires sur toute la ligne, :fonctionne, car il introduit une étiquette, mais j'ai encore besoin de quelque chose pour terminer leecho commande tout en étant non-op lorsqu'il est inversé. &:semble fonctionner, ce qui est tout ce dont j'ai besoin ici, mais cela confond vraiment Batch, l'erreur si je ne mets pas de :avant @sur la ligne suivante, et oublie également d'imprimer une nouvelle ligne.

MATLAB, 29 17 5 11 octets

Après avoir réalisé que la question appelait des caractères ASCII uniques et pas seulement une sortie distincte, voici une approche MATLAB qui fera exactement cela:

%4%
1%3
%2%

Cela imprimera implicitement 1, 2, 3 ou 4 selon la rotation.

Cardinal , 20 17 12 11 octets

.$
Z%"
+$v

Essayez-le en ligne!

Pendant tout ce temps et personne n'a répondu au Cardinal? Ce premier produit0 .

est

 +Z.
 $%$
 v"

Essayez-le en ligne!

Les sorties 1.

Sud

v$+
"%Z
 $.

Essayez-le en ligne!

Sort un espace.

Ouest

 "v
$%$
.Z+

Essayez-le en ligne!

Sorties v.

SOGL V0.12 , 4 octets

5H
I

Sorties 1, essayez-le ici!

I5
 H

Sorties H, essayez-le ici!

 I
H5

Sorties 5, essayez-le ici!

H
5I

Sorties 6, essayez-le ici!

JS, 17 B

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

Sorties:
Nord: 2,
Est: 3,
Sud: 4,
Ouest: 0,33333333333….
(comme dans: 2, 3/1, 4, 1/3)

Désolé, je voulais dire:

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

et 28B. Et les sorties comme 0,5, 3, 2, 0.

JavaScript (ES6), 86 octets

Sorties 0 pour le nord, 1 pour l'est, 2 pour le sud et 3 pour l'ouest.

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

HxI
xFx
TxK

Essayez-le en ligne!

Commençons par MATL. Le principal défi est que MATL échoue simplement si une fonction nécessite une entrée si la pile est vide. Peut-être quelque chose d'intelligent avec des modificateurs commeX que , Y,Z et& pourrait faire quelque chose de plus court, mais je ne pouvais pas trouver une combinaison appropriée.

Explication: tous les caractères poussent un seul entier sur la pile et les xsuppriment tous sauf le dernier.

Perl, 49 octets

Code de 48 octets + 1 pour -p.

Suppose une entrée vide que TIO ne prend pas en charge, donc une nouvelle ligne est ajoutée à sa place et n'est pas utilisée. Prints N , E , S , W .

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

Essayez-le en ligne!

C (gcc) , 120 octets

J'avais espéré plus de synergie entre les variantes.

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

Nord

est

Sud

Ouest