Le titre dit tout. Votre objectif est d'écrire un programme qui forme un rectangle aw × h de caractères pouvant être pivotés et réexécutés pour générer le nombre de rotations à 90 ° effectuées dans le sens contraire des aiguilles d'une montre.

Par exemple, si le programme 3 × 2

abc
def

résolu le problème, il produirait initialement 0 et des rotations successives de 90 ° CCW

cf    fed    da
be    cba    eb
ad           fc

afficherait 1, 2 et 3 respectivement.

L'utilisation de commentaires en fait une tâche triviale pour la plupart des langues. En Ruby par exemple, cela peut être fait dans un rectangle 7 × 7:

###p###
### ###
###1###
p 0#2 p
###3###
### ###
###p###

Le défi consiste à le faire sans aucune sorte de commentaire.

Notation

Votre score est w * h, la surface de votre rectangle. Les nouvelles lignes sont exclues. En d'autres termes, code-golf, les nouvelles lignes ne sont pas comptées.

Le score pour l'exemple Ruby est 49 (bien que, bien sûr, il ne soit pas valide car il contient des commentaires).

Remarques

• Votre code doit vraiment être rectangulaire, sans aucun caractère manquant à la fin des lignes.
• Si vous le souhaitez, vous pouvez générer d'autres valeurs légales "mod 90 °" au lieu de 0 1 2 3. Donc 8 va bien au lieu de 0, et -1 va bien au lieu de 3, etc.
• La sortie peut aller à la console ou dans un fichier.
• Les failles standard s'appliquent.

J'espère que ma première question intrigue vraiment certaines personnes. Prendre plaisir!

APL (1x3 = 3)

5!3

Cette solution utilise la règle supplémentaire selon laquelle toute sortie correspondant au mod 4 correct fonctionne.

Dans APL, x!yest le nombre de façons de choisir des xéléments y, communément appelé binom(y,x)ou choose(y,x). Vérifions que chaque rotation donne la bonne réponse.

0 rotations

5!3

Il n'y a aucun moyen de choisir 5 éléments sur 3, nous obtenons donc 0, qui est automatiquement imprimé.

1 rotation CCW

3
!
5

APL évalue avec bonheur chaque ligne, en obtenant le numéro 3, l'opérateur !, puis le numéro 5, en n'imprimant que le dernier ( 5), qui correspond à 1 mod 4.

2 rotations CCW

3!5

Ceci est binom(5,3), ce qui est (5*4*3*2*1)/(3*2*1)/(2*1) = 10, qui est 2 mod 4.

3 rotations CCW

5
!
3

Comme auparavant, seule la dernière valeur évaluée de 3est imprimante.

Je ne connais pas vraiment APL, alors dites-moi s'il vous plaît si l'une des explications est erronée. Je l'ai trouvé par essais et erreurs comme première langue de ce site :

1. Imprime automatiquement le résultat d'une expression
2. Étant donné plusieurs lignes d'expressions, ne sort que la dernière
3. N'a pas de problème avec un opérateur debout seul sur une ligne
4. Prend infixé opérateurs
5. Possède un opérateur binaire arithmétique à un caractère asymétrique (aRb! = BRa) et suffisamment flexible pour renvoyer une variété de nombres.

Pour (5), j'ai descendu la liste des fonctions dyadiques APL . Ma première opération candidate était la division entière /de C et Python 2, mais la division APL ÷donne des flottants. L'exponentiation est tentante, mais échoue car aet a^ba la même parité mais est obtenue par rotations consécutives (sauf si b=0, mais ensuite b^a=0). Les opérateurs booléens, tels que <give 0et 1180 degrés, ne fonctionnent pas. Enfin, j’ai trouvé l’opérateur binomial !et essayé des chiffres jusqu’à ce que j’en obtienne.

Merci à Quincunx pour sa confiance qu’il existe une solution plus petite que 2x2.

Rubis, 7 × 9 (63)

 30;p  
0||p=p 
0|0;p;p
;p;p|p;
p=p ||0
;p   p;
2||p =p
 00;1  
     p 

Un peu plus long que l'autre solution, mais au moins cette solution ne dépend d'aucune impression implicite ou d'abus de règles. Pour les quatre rotations, le code complet est analysé et, à l'exception d'un court-circuit, tout est exécuté. Étonnamment, il n'y a absolument aucune symétrie dans le code

Cette solution repose sur le fait qu'il est toujours possible d'appeler la pfonction (qui permet d'imprimer les nombres) même si une variable du même nom a déjà été définie. Par exemple, quelque chose comme p pappelle la fonction pavec la variable pen argument (donc, en affichant la valeur de p).

Explication de certaines expressions courantes utilisées dans le code:

• p: Comme mentionné ci-dessus, il s’agit d’un appel de fonction ou d’une variable. Lorsque la variable n'est pas définie, la fonction est pappelée sans arguments, ce qui ne fait rien et retourne nil.
• p p: Imprime la variable p.
• p|x: Quand pest la fonction, c'est identique à nil|x, qui retourne vrai / faux en fonction de la valeur de x. Si pest un entier, c'est au niveau du bit ou. Quoi qu'il en soit, cette déclaration n'a aucun effet secondaire.
• p=p||x: Effectivement identique à p||=x(affectation conditionnelle) avec l'avantage d'être valide du point de vue syntaxique et de ne pas être opéré une fois inversé

Version symétrique (9 × 10 = 90)

    p    

  0 * 0  
  00100  
  0||2* p
p *0||0  
  00300  
  0 * 0  

    p    

Ceci est la solution la plus courte symétrique (C ₂ en ignorant les chiffres à imprimer) Je pourrais trouver.

Script de test

Voici un script de test pour vérifier le code ci-dessus (les #fins de ligne ont été ajoutées pour que les espaces ne soient pas supprimés et soient supprimés avant l'exécution):

rotate=->s{s.split($/).map{|i|i.chars.reverse}.transpose.map(&:join).join($/)}

s=<<EOD.gsub(?#,"")
 30;p  #
0||p=p #
0|0;p;p#
;p;p|p;#
p=p ||0#
;p   p;#
2||p =p#
 00;1  #
     p #
EOD


puts ">>> 0°"
eval s
puts ">>> 90°"
eval rotate[s]
puts ">>> 180°"
eval rotate[rotate[s]]
puts ">>> 270°"
eval rotate[rotate[rotate[s]]]

GolfScript, 4 (2x2)

43
12

Imprime 4312ce qui est 0(mod 4). Les rotations sont imprimées 3241(1 mod 4), 2134(2 mod 4) et 1423(3 mod 4).

Invité par:

Si vous le souhaitez, vous pouvez générer d'autres valeurs légales "mod 90 °" au lieu de 0 1 2 3. Donc 8 va bien au lieu de 0, et -1 va bien au lieu de 3, etc.

Il existe en réalité de nombreux ensembles de nombres pour lesquels cela fonctionne. J'ai trouvé ceux-ci avec ce programme Python:

def f(a,b,c,d):
    return int("%i%i%i%i"%(a,b,c,d))
for a in range(10):
    for b in range(10):
        for c in range(10):
            for d in range(10):
                candidate = f(a,b,c,d) % 4 == 0
                candidate &= f(b,d,a,c) % 4 == 1
                candidate &= f(d,c,b,a) % 4 == 2
                candidate &= f(c,a,d,b) % 4 == 3
                if candidate:
                    print("%i, %i, %i, %i"%(a,b,c,d))

Bien que le programme génère 0s (ce qui ne fonctionnerait probablement pas), les solutions valables sont les suivantes:

ab
cd

Où a∈{4,8}, b∈{3,7}, c∈{1,5,9}, d∈{2,6}. IE (a,b,c,d)∈{4,8}×{3,7}×{1,5,9}×{2,6}qui est 24 solutions.

Python - 23 x 23 = 529

Ok, cette question a déjà un gagnant, mais il n’existe pas encore de solution Python. Alors j'y ai pensé - lourdement! - et a trouvé un moyen de faire fonctionner la printcommande volumineuse dans n’importe quelle direction sans générer d’erreurs lorsqu’elle était analysée depuis l’une des autres directions.

La percée était la ligne suivante:

'"\'';forward_code;"';backward_code;""\'"''

Alors que le forward_codeest exécuté, le backward_codefait partie d'une chaîne et n'est donc pas imprimé. C'est exactement l'inverse lorsque vous lisez à l'envers.

Donc, combiné avec deux autres directions et ajusté pour obtenir toutes les citations correspondant correctement, je me retrouve avec la solution suivante:

''"''""''"''"''"'"''""'
"  ""                 "
"  \\                 "
'"\'';print 1;"'""\'"''
'"\''"';3 tnirp;""\'"''
"  ;""                "
"  p'                 "
'  r;                 '
'  i2                 '
"  n                  "
"  tt                 "
'   n                 '
'  4i                 '
"  ;r     .-=<>=-.    "
' \"p    /__----__\   '
"  ';'  |/ (')(') \|  "
"  ""    \   __   /   "
'  ""    .`--__--`.   '
"  \\   /    :|    \  "
'  ''  (_)   :|   (_) '
'  ""    |___:|____|  '
"  ''    |_________|  "
''"''""''"''"''"'"''""'

Edit: J'ai trouvé un moyen de gérer tout cet espace. ;)

BASIC, 64

Je ne gagnerai pas, mais le voici quand même. (Testé dans Chipmunk Basic )

?0:END:?
:::::::1
D:::::::
N::::::E
E::::::N
:::::::D
3:::::::
?:DNE:2?

Remarque: ?est un raccourci pour PRINTdivers dialectes de BASIC. Bien qu'il y ait beaucoup d'erreurs de syntaxe dans le code, l' ENDinstruction de la première ligne empêche qu'elles soient vues par l'interpréteur.

Pyth , 9 caractères (3x3)

0 1

3 2

En pyth, tout est imprimé par défaut, sauf s'il est précédé d'un espace. Les lignes après la première ligne sont destinées à l'utilisateur et ne sont pas évaluées dans ce programme.

Une autre façon d’obtenir 9 caractères:

"0"
3 1
"2"

Pyth 1.0.5 , 4 caractères

Bien que les modifications récentes apportées à Pyth aient rendu la génération de nombres à 2 chiffres plus difficile (modification que j’envisage d’annuler), les anciennes versions de Pyth permettent de générer facilement des nombres à deux chiffres, qui, combinés à l’impression implicite et au fait que toutes les lignes, sauf la première, sont ignorés, donne la solution suivante:

32
41

Imprime 32,21,14,43.

Befunge, 16 ans

0.@1
@@@.
.@@@
3@.2

Explanation: Chiffres de 0pour 9insérer le nombre correspondant dans la pile, .extraire une valeur de la pile et l'imprimer sous forme d'entier, puis @terminer le programme.

(testé ici )

Piet, 49 ans

Je me suis contenté d'utiliser des couleurs jaune et rouge et d'essayer de le rendre plus ou moins symétrique. Lors de la rotation, il imprime 0, 1, 2 ou 3. Quitter le programme dans Piet est difficile et prend malheureusement environ la moitié de la surface de la photo.

GNU dc , 6 (3x2)

Je pense que c'est la réponse la plus courte pour ne pas exiger l'assouplissement des règles "mod 90 °":

3z1
0p2

Sorties 0, 1, 2ou 3pour chaque rotation.

Pour les 0, 2et les 3rotations, les ppops simplement et imprime le dernier littéral avoir été poussé à la pile. Pour la 1rotation, zappuyez sur la profondeur actuelle de la pile (1) pour la placer sur la pile, puis sur pour la faire papparaître et l'imprimer.

GolfScript, 9 (3x3)

0}1
} }
3}2

En quelque sorte d'abuser des règles. La }fin du programme s’il n’ya pas de correspondance {et le contenu de la pile est imprimé à la fin du programme.

JavaScript, 4

03
12

Lorsque vous exécutez ce programme (ou une rotation de ce programme) dans une console javaScript, seule la dernière ligne est évaluée et répercutée dans la console.

Alors:

12 modulo 4 == 0
01 modulo 4 == 1
30 modulo 4 == 2
23 modulo 4 == 3

Voici tous les programmes 2x2 similaires qui fonctionnent aussi:

03
12

03
16

03
52

03
56

03
92

03
96

07
12

07
16

07
52

07
56

07
92

07
96

43
12

43
16

43
52

43
56

43
92

43
96

47
12

47
16

47
52

47
56

47
92

47
96

83
12

83
16

83
52

83
56

83
92

83
96

87
12

87
16

87
52

87
56

87
92

87
96

En d'autres termes,

ab
cd

où a est dans [0,4,8], b est dans [3,7], c est dans [1,5,9] et d est dans [2,6]

CJam / GolfScript - 3 * 3

2;3
;7;
1;0

Le point-virgule fait apparaître le numéro précédent, seul le coin inférieur droit est imprimé.

Aheui , 8 ans

바몽희뷸
뷷희몽반

Comme Aheui n’a pas de lettre qui pousse 1 sur la pile, j’ai décidé d’imprimer 0, 5, 2 et 3.

Explication: 바 et 반 poussent respectivement 0 et 2 sur la pile et déplace le curseur d'un caractère vers la droite. 뷸 et 뷷 poussent respectivement 5 et 3 dans la pile et déplace le curseur de deux caractères vers le bas. 몽 affiche et affiche le nombre dans la pile et déplace le curseur d'un caractère vers le haut. Termine le programme.

JavaScript

(Entré dans la console du navigateur, shell ou un autre REPL, le résultat est imprimé)

1+2
-3-
4+5

Devrait fonctionner pour toute autre langue avec des expressions, des retours à la ligne non significatifs et l’impression automatique du résultat.

Matlab / Octave - 144 100

Golfé: 10 x 10 = 100

....d.....
....i.....
....s.....
... p2 ...
disp  1...
...3  psid
... 4p ...
.....s....
.....i....
.....d....

Solution alternative: 15 x 15 = 225

.......d.......
.......i.......
.......s.......
...    p    ...
...         ...
...    4    ...
...    .    ...
disp 1...3 psid
...    .    ...
...    2    ...
...         ...
...    p    ...
.......s.......
.......i.......
.......d.......

Perl 5x7 (35)

1+p+t+1
-print+
1+i+i+1
+tnirp+
1+t+p+1

Un peu tard pour la fête. Le solitaire -détermine quel numéro est imprimé.

JavaScript, 3

2
1
4

Cela fonctionne ... en base 7.

Version base 9:

2
7
0

Explication

Lorsqu’il est exécuté de manière interactive, par exemple à partir d’une console de débogage, la valeur de la dernière instruction / expression est sortie.

4 ₇ = 4 ₁₀ ≣ 0 (mod 4 )
412 ₇ = 205 ₁₀ ≣ 1 (mod 4 )
2 ₇ = 2 ₁₀ ≣ 2 (mod 4 )
214 ₇ = 109 ₁₀ ≣ 3 (mod 4 )

Des solutions similaires pourraient être trouvées pour toute base impaire.

Befunge, 12 (6x2)

J'ai réussi à apporter une légère amélioration à la réponse existante de Befunge en exploitant au mieux la nature bidimensionnelle de Befunge et en faisant en sorte que le chemin du code soit vertical dans deux des orientations.

0.@.1v
v3.@.2

Essayez-le en ligne: à partir de 0 , rotation 1 , rotation 2 , rotation 3 .

Marbelous, 7 * 14 = 98

.. \/ \/ .. ..
.. 31 \\ 32 \/
\/ \\ \/ \\ \/
\/ 30 \\ 33 ..
.. .. \/ \/ ..

Argh! / Aargh! (4 * 4 = 16)

En quoi consistait l'utilisation du bon outil pour le travail? Il n'y a pas de commentaires (dans la langue en général).

Toute la famille de programmes (générée en J: ((|.@:|:) ^: (i. 4)) >'hpqh';'q01p';'p32q';'hqph'ou ((|.@:|:) ^: (i. 4)) 4 4 $ 'hpqhq01pp32qhqph')

hpqh
q01p
p32q
hqph

tourné une fois:

hpqh
q12p
p03q
hqph

tourné deux fois:

hpqh
q23p
p10q
hqph

tourné trois fois:

hpqh
q30p
p21q
hqph

Pour expliquer cela, il pourrait être préférable de regarder une version "en retrait" (qui fonctionne également dans toutes les rotations):

hhpq h
  0  h
q   1p
p3   q
h  2  
h qphh

Cette version montre que le programme comprend 4 parties distinctes, une pour chaque rotation individuelle.

• h - régler le flux de contrôle à gauche

• p - imprimer un élément dans le raster de données / code en dessous

• q - quitter le programme

Flotteur - 9 × 5 = 45

Imprime 4, 1, 2 ou 3 sur la console.

Notez que 'Black' est une instruction valide (NOP) et qu'elle est syntaxique. Sans cela, il ne peut pas trouver la position de départ. Ainsi, toutes les positions dans le rectangle sont occupées.

Élément, 2x3 = 6

1*
`2
3 

Il s’agit d’une amélioration par rapport à la solution naïve 3x3, qui se situe `au centre avec un chiffre de chaque côté. Le cas 0, présenté ci-dessus, est le plus intéressant, car il *sert à multiplier les 3 par rien pour obtenir 0. À part cela, ce n'est pas si compliqué.

Si vous trouvez cet espace inconfortable, vous pouvez le remplacer par n'importe quel autre personnage, à l'exception de []{}`_.

Pour référence, voici les trois autres rotations:

case 1
*2 
1`3

case 2
 3
2`
*1

case 3
3`1
 2*

Puce, (2x5) 10

b~
+a
~t
e*
 f

*active tous les éléments voisins: nord, est, sud et ouest (source)
~si elle n'est pas activée de l'ouest, active le voisin est (porte NON) (jamais activé ici)
ttermine l'exécution après l'impression de l'octet actuel
adéfinit le bit 0x01des
bensembles de sortie le bit 0x02de la sortie
edéfinit le bit 0x10de la sortie
fdéfinit le bit 0x20de la sortie
+s'il est activé par un voisin, activez tous les autres voisins (fil)

La puce nécessite soit le -wdrapeau (pour permettre l'exécution sans entrée), soit une entrée pour s'exécuter.

Estampes 0, 1, 2ou 3en ASCII. Si 0x00vous 0x03souhaitez utiliser le code souhaité, supprimez les boutons eand f, puis déplacez l’espace vers le haut pour le combler.

Japt , 3 * 1 = 3 octets

5zB

Essayez-le en ligne: tel quel , pivoté une fois , deux fois , trois fois .

Sorties 0, 5, 2, 11 respectivement.

La variable Bcontient la valeur 11 et Number.z(other)est la division du plancher (tout le monde cherchait apparemment: p). Pour un code multiligne, la dernière ligne est transmise à la sortie, qui est simplement une constante ici.

2 * 2 = 4 octets

2J
1T

Essayez-le en ligne: tel quel , pivoté une fois , deux fois , trois fois .

Sorties 0, 21, 2, -1 respectivement.

Tdétient 0 et Jdétient -1.

Le truc, c’est que, si deux littéraux ou deux variables sont mis côte à côte, une virgule est insérée et la sortie n’est que la dernière.

La solution 2 * 2 JS fonctionne également dans Japt.