Ecrire un programme qui sort

Do not repeat yourself!

Votre code de programme doit respecter les contraintes suivantes:

• sa longueur doit être un nombre pair
• chaque caractère en position 2n(où nest un entier> 0) doit être égal au caractère en position 2n-1. Le deuxième caractère du programme est égal au premier, le quatrième est égal au troisième, etc.

Les nouvelles lignes comptent comme des personnages!

C'est du code-golf, alors le code le plus court gagne!

Exemples

HHeellllooWWoorrlldd est un programme valide

123ou AAABBBou HHeellosont incorrects

Vérification

Vous pouvez utiliser ce script CJam pour vérifier que votre code source est valide. Collez simplement votre code dans la boîte "Entrée" et exécutez le script.

Hexagony , 166 126 124 octets

\\;;;;33rr''22DD..));;;;;;oo;;}}eeoo\\@@nn;;;;ee;;;;aass&&;;uuoo;;;;..\\\\;;ttee..pp;;tt;;;;..rr;;''ll..'';;;;..;;}}ff..}}yy

L'insertion des no-ops et des espaces implicites correspond au code source suivant:

       \ \ ; ; ; ; 3
      3 r r ' ' 2 2 D
     D . . ) ) ; ; ; ;
    ; ; o o ; ; } } e e
   o o \ \ @ @ n n ; ; ;
  ; e e ; ; ; ; a a s s &
 & ; ; u u o o ; ; ; ; . .
  \ \ \ \ ; ; t t e e . .
   p p ; ; t t ; ; ; ; .
    . r r ; ; ' ' l l .
     . ' ' ; ; ; ; . .
      ; ; } } f f . .
       } } y y . . .

Je suis sûr qu'il est possible de raccourcir davantage ce problème, et peut-être même de le résoudre en longueur de côté 6, mais cela devient difficile ...

Comment ça fonctionne

^{Diagramme généré avec le colorant Hexagony de Timwi .}

Le code est complètement linéaire. La \droite au début redirige l'IP dans une diagonale, de sorte que nous n'avons pas du tout à nous soucier des caractères doublés. Les chemins colorés sont exécutés dans l'ordre orange / rouge, bleu / gris, vert, violet (lorsqu'il existe deux chemins de la même couleur, le chemin de gauche est exécuté en premier, avant d'être enroulé dans le chemin de droite).

Si nous ignorons les no-ops, les miroirs et les commandes remplacés par d'autres, le code linéaire se résume à ceci:

D;o;&32;}n;o;t;';}r;e;p;e;a;t;';}y;o;u;r;s;e;l;f;');@

Les lettres en hexagone ne font que définir la valeur du bord de la mémoire actuelle sur le code de caractère de la lettre. ;imprime le bord de mémoire actuel sous forme de caractère. Nous utilisons &pour réinitialiser le bord de la mémoire 0et imprimer un espace avec 32;. }se déplace vers un bord différent, de sorte que nous puissions nous souvenir de 32pour les espaces suivants. Le reste du code n'imprime que des lettres sur le nouveau bord et se déplace occasionnellement ';}pour imprimer un espace. À la fin, nous passons à nouveau au bord de l'espace avec ', incrémentons la valeur à 33 avec )et imprimons le point d'exclamation. @termine le programme.

GolfScript, 130 84 76 octets

22..!!..00)){{DDoo  nnoott  rreeppeeaatt  yyoouurrsseellff}}``%%>><<[[33]]++

Essayez-le en ligne dans Web GolfScript .

Comment ça fonctionne

L’interprète GolfScript commence par placer une chaîne vide sur la pile.

22 # Push 22.
.. # Push two copies.
!! # Negate the last copy twice. Pushes 1.
.. # Push two copies.
00 # Push 0.
)) # Increment twice. Pushes 2.

   # STACK: "" 22 22 1 1 1 2

{{DDoo  nnoott  rreeppeeaatt  yyoouurrsseellff}}

`` # Push a string representation of the string representation of the block.

   # This pushes "{{DDoo  nnoott  rreeppeeaatt  yyoouurrsseellff}}" (with quotes).

%% # Take every second element of that string, then every element of the result.
>> # Discard the first element of the result. Repeat.
<< # Truncate the result to length 22. Repeat.
[[ # Begin a two-dimensional array.
33 # Push 33, the character code of '!'.
]] # End the two-dimensional array.
++ # Concatenate the empty string, the 22-character string and the array [[33]].

La concaténation d'un tableau avec une chaîne aplatit le résultat souhaité.

Unaire , ~ 1,86 × 10 ²²²

Simple brainfuck -> réponse unaire. Très sous-optimal;).

Le programme comprend un nombre pair de 0; Plus précisément:

1859184544332157890058930014303073630713307137107107094930302761381861381861883683680836880836836880801388083683688080138083683680138088083680808368080836880836880836880836880836803680138018801380801380

d'eux.

Code brainfuck original:

++++[++++>---<]>+.[--->+<]>+++.[--->+<]>-----.+[----->+<]>+.+.+++++.[---->+<]>+++.---[----->++<]>.-------------.+++++++++++.-----------.----.--[--->+<]>-.[---->+<]>+++.--[->++++<]>+.----------.++++++.---.+.++++[->+++<]>.+++++++.------.[--->+<]>-.

Ruby - 2100 1428 1032 820 670 octets

Cela suppose que la sortie peut être une valeur de retour d'une fonction (il n'a pas été spécifié que la sortie doit être sur STDOUT)

Code:

((((((((((((((((((((((((((((((((((((((((((((((""<<66++11**00++11**00))<<99++11++11**00))<<((55>>11**00))++((11>>11**00))))<<99++11))<<99++11++11**00))<<99++((33>>11**00))++11**00))<<((55>>11**00))++((11>>11**00))))<<99++11++((11**00<<11**00<<11**00))))<<99++11**00++11**00))<<99++11++11**00++11**00))<<99++11**00++11**00))<<88++((11>>11**00))++((11**00<<11**00<<11**00))))<<99++((33>>11**00))++11**00))<<((55>>11**00))++((11>>11**00))))<<99++22))<<99++11++11**00))<<99++((33>>11**00))++11**00++11**00))<<99++11++((11**00<<11**00<<11**00))))<<99++((33>>11**00))))<<99++11**00++11**00))<<99++((11>>11**00))++((11**00<<11**00<<11**00))))<<99++11**00++11**00++11**00))<<33))

L'astuce consiste à construire la chaîne à partir d'une chaîne vide ""à l'aide de l'opération d'ajout <<et des codes ASCII des caractères.

Pour obtenir les numéros des codes ASCII, j'essaie de décomposer le nombre en valeurs que je peux facilement générer. Par exemple, ASCII 90est juste 88+1+1, ce qui est:

• 88 est d'accord sur son propre
• 11**00est 11^0, qui est simplement1

Heureusement les deux ++et --signifieraient adden rubis, donc je peux écrire 90comme88++11**00++11**00

Il existe quelques astuces pour obtenir des nombres plus faciles que simplement ajouter des 1, voici le code que j'utilise pour générer ce qui précède (qui inclut tous les mappages que j'utilise):

d = "Do not repeat yourself!"

d.each_char do |c|
  print "(("
end

print '""'

VALUES = [
  [0,'00'],
  [1,'11**00'],
  [4,'((11**00<<11**00<<11**00))'],
  [5,'((11>>11**00))'],
  [11,'11'],
  [16,'((33>>11**00))'],
  [22,'22'],
  [27,'((55>>11**00))'],
  [33,'33'],
  [38,'((77>>11**00))'],
  [44,'44'],
  [49,'((99>>11**00))'],
  [55,'55'],
  [66,'66'],
  [77,'77'],
  [88,'88'],
  [99,'99']
].reverse

d.each_char do |c|
  print "<<"
  num = c.ord
  while num != 0
    convert = VALUES.find{|val|val.first<=num}
    print convert.last
    num -= convert.first
    print "++" unless num == 0
  end
  print "))"
end

Je pense toujours à d'autres astuces pour diminuer le nombre de caractères requis pour obtenir un nombre.

Notez que si vous utilisez le -rppdrapeau, et ajoutez ppau début du code comme suit:

pp((((((((((((((((((((((((((((((((((((((((((((((""<<66++11**00++11**00))<<99++11++11**00))<<((55>>11**00))++((11>>11**00))))<<99++11))<<99++11++11**00))<<99++((33>>11**00))++11**00))<<((55>>11**00))++((11>>11**00))))<<99++11++((11**00<<11**00<<11**00))))<<99++11**00++11**00))<<99++11++11**00++11**00))<<99++11**00++11**00))<<88++((11>>11**00))++((11**00<<11**00<<11**00))))<<99++((33>>11**00))++11**00))<<((55>>11**00))++((11>>11**00))))<<99++22))<<99++11++11**00))<<99++((33>>11**00))++11**00++11**00))<<99++11++((11**00<<11**00<<11**00))))<<99++((33>>11**00))))<<99++11**00++11**00))<<99++((11>>11**00))++((11**00<<11**00<<11**00))))<<99++11**00++11**00++11**00))<<33))

alors, pour 2 + 4 octets supplémentaires, cela peut fonctionner comme un programme complet, mais cela affichera un extra "avant et après la chaîne requise:

Exemple:

$ ruby -rpp golf.rb
"Do not repeat yourself!"

> <> , 174 octets

vv

77

99

**

00

77

bb

**

pp

""

!!

ff

ll

ee

ss

rr

uu

oo

yy



tt

aa

ee

pp

ee

rr



tt

oo

nn



oo

DD

""

~~

oo

ll

11

==

;;

00

66

bb

**

..

Heureusement, dans un sens, la restriction ne s'applique pas verticalement. Cependant, le plus gros problème est que nous devons doubler chaque nouvelle ligne.

Le code qui tourne grossièrement ressemble à ceci:

v            Redirect instruction pointer to move downwards
79*07b*p     Place a ? on row 77 before the first ;
"..."        Push "Do not repeat yourself!" backwards, riffled between spaces

[main loop]
~o           Pop a space and output a char
l1=?;        If there is only the final space left, halt
06b*.        Jump back to the start of the loop

Notez que le programme n'a pas de double espace - en mode chaîne,> <> pousse les espaces pour les cellules vides. Inversement, cependant, cela signifie qu'une solution utilisant g(lire une seule cellule du code source) serait plus délicate, car les espaces présents dans le programme deviennent des NUL lors de la lecture.

^{(Remarque: cela peut être 50 octets plus court s'il se termine par une erreur , mais j'aime bien ça.)}

Déclenchement , 186 146 octets

긂긂

鎵 一 一一 終

Pour être clair, il y a trois lignes de code, dont le milieu est vide, car la nouvelle ligne doit être dupliquée. Le nombre d'octets est basé sur le codage UTF-16.

Explication

Le bloc de caractères coréens au début pousse la chaîne "DDDof� \"\u0002nf�of�twG \"\u0002rw'efVpw\aefVaf\u0016twG \"\u0002yw�of�uwWrw'sw7efVlf�fff!\"\u0012". Vous remarquerez que chaque troisième caractère est un caractère que nous voulons; le reste est du charabia. Voici pourquoi:

Dans Sclipting, deux caractères coréens codent trois octets. Ainsi, chaque caractère coréen code effectivement 12 bits. Pour obtenir une chaîne commençant par D, les 8 premiers bits doivent être 0x44; le reste importe peu, mais comme nous devons répéter chaque caractère, les 12ème à 20ème bits le seront également 0x44. Ainsi, nous aurons une valeur de la forme 0x44n44npour certains n , qui se décompose en trois octets 0x44 0xn4 0x4n.

Pour le o, ce qui est 0x6F, nous obtenons les octets 0x6F 0xn6 0xFn.

Depuis que je suis paresseux, j'ai commencé par encoder "DDDooo nnnooottt (etc.)", puis j'ai remplacé tous les autres caractères par les précédents, raison pour laquelle j'obtiens 0x444444= "DDD"pour le Det 0x6F66F6= "of�"pour le o. Le �est là parce que 0xF6par lui-même est un codage UTF-8 invalide.

Revenons maintenant au programme. Le reste du programme se déroule comme suit:

껢껢 - pousse la corde ".\"�"

鎵 鎵 - supprime le dernier caractère deux fois, nous laissant avec "."

- deux doublons. Empiler maintenant:[".", ".", "."]

合 - concaténer deux fois. Empiler maintenant:["..."]

Ce que je veux faire maintenant, c’est utiliser "..."comme expression régulière pour pouvoir faire correspondre trois caractères de la chaîne originale à la fois, en utilisant la construction de boucle 替 .... Cependant, comme chaque instruction est dupliquée, il me faut deux boucles d’expression régulière imbriquées l'une dans l'autre. Si la pile est sous-chargée, j'obtiens une erreur d'exécution. Donc,

虛虛 - pousse deux fois la chaîne vide

et ensuite commencer les boucles. De cette façon, la boucle extérieure itère une seule fois car elle correspond à l'expression régulière ""à la chaîne "", ce qui donne une seule correspondance. La boucle interne est exécutée une fois pour chaque match "..."contre la grosse chaîne. Le corps de la boucle est:

標 標 - Poussez deux marques sur la pile. Empiler maintenant:[mark mark]

現 現 - Poussez deux copies de la correspondance de regex actuelle. Empiler maintenant:[mark mark "DDD" "DDD"]

併 併 - concaténer jusqu'à la première marque. Empiler maintenant:["DDDDDD"]

一一 - prend le premier caractère de cette chaîne, puis (de manière redondante) le premier caractère de celle-ci. Stack a maintenant le personnage que nous voulons.

La boucle interne se termine ici, donc chaque correspondance de l'expression régulière est remplacée par le premier caractère de cette correspondance. Cela laisse la chaîne souhaitée sur la pile.

Ensuite, la boucle externe se termine, à quel point la chaîne souhaitée est retirée de la pile et la seule correspondance de ""la chaîne ""est remplacée par celle-ci, laissant la chaîne souhaitée à nouveau sur la pile.

Labyrinthe , 528 octets

66))__vv          ..33::00&&__vv          ..44__99||__vv          ..33::00&&__vv            ..99))__vv            ..99))__vv      ..44__88$$__vv          ..22__99++__vv          ..22__99$$__vv            ..22__99))$$__vv      ..33__77$$__vv            ..33__vv

      ..44__99||__^^          ..11__99++__^^          ..44__88$$__^^          ..44((__88$$__^^      ..11))__99++__^^      ..99((__^^          ..33::00&&__^^          ..44__99||__^^          ..44((__88$$__^^            ..99))__^^          ..11__99$$((__^^    ..@@

xx

La double nouvelle ligne fait mal, mais au moins, cela prouve que c'est faisable!

Chaque caractère est imprimé un par un, d'abord en formant le point de code, puis en imprimant un seul caractère. Les points de code sont formés par:

D 68  66))
o 111 44__99||
  32  33::00&&
n 110 11__99++
t 116 44__88$$
r 114 44((__88$$
e 101 99))
p 112 11))__99++
a 97  99((
y 121 22__99++
u 117 22__99$$
s 115 22__99))$$
l 108 33__77$$
f 102 11__99$$((
! 33  33

où

)(        Increment/decrement by 1 respectively
&|$       Bitwise AND/OR/XOR respectively
+         Add
:         Duplicate
_         Push zero
0-9       Pop n and push n*10+<digit>

Le comportement inhabituel des chiffres de Labyrinth est exploité dans 33::00&&, ce qui est en fait

[33] -> [33 33] -> [33 33 33] -> [33 33 330] -> [33 33 3300] -> [33 32] -> [32]
     :          :             0              0               &          &

Chaque caractère est imprimé avec le mécanisme

__vv

  ..

xx

Ils xxn'existent que pour remplir la grille de manière à ce que sa hauteur soit de 5. D'abord, __appuyez sur deux zéros, puis nous avons frappé un opérateur de rotation de la grille v. Nous sautons un zéro et tournons:

__ v
  v
   .
  .
xx

et encore:

__ v

  v.

xx.

Nous nous déplaçons ensuite vers .la troisième ligne, exécutant ainsi la commande d'impression une seule fois.

CJam - 176 136 octets

66))HH77++GG00++BB88++HH77++EE88++GG00++DD88++99))CC88++99))AA77++EE88++GG00++BB99++HH77++KK77++DD88++JJ77++99))AA88++II66++33]]{{cc}}//

Merci à Sp3000 d’avoir divisé la taille de mon programme par deux :-)

Explication

• Les codes HH77++, GG00++... calculent le code entier ascii des caractères en ajoutant des nombres (par exemple: `HH77 ++ 'pousse 17, 17 et 77 sur la pile, puis ajoute ces 3 chiffres)
• la partie de code située à la fin ]]{{cc}}//parcourt les codes ascii et les convertit en caractères.

Essayez-le ici

Brainf *** auto-modifiable , 72 octets

Notez que \x00représente un NULoctet hexadécimal littéral (cellule vide). Le code source est placé sur la bande, à gauche de la cellule de départ.

!!fflleessrruuooyy  ttaaeeppeerr  ttoonn  ooDD\0\0<<<<<<++[[<<]]<<[[..<<]]

Explication

!!fflleessrruuooyy  ttaaeeppeerr  ttoonn  ooDD  The string on the tape for easy printing
\x00\x00                                        A separator to make printing shorter
<<<<<<++                                        Change first '.' to '0' (comment)
[[<<]]<<                                        Move to separator, then left to string
[[0.<<]]                                        Print string

De plus, avant de créer ce programme, j'en fabriquais un en utilisant uniquement des caractères BF dans la source. C'est possible! C'est aussi beaucoup plus long, car pour une valeur ASCII impaire, j'allais créer le double de la valeur, puis le diviser par deux. Un peu plus court serait de modifier toute la source pour générer des valeurs impaires.

Gelée , 66 octets (non concurrente)

““DDoo  nn““oott  rreepp““eeaatt  yyoouurrss““eellff!!””ṛṛḷḷWWQQ€€

Essayez-le en ligne!

Factoïde

Le programme fonctionne toujours si vous supprimez tous les deux caractères.

Essayez-le en ligne!

Comment ça fonctionne

““DDoo  nn““oott  rreepp““eeaatt  yyoouurrss““eellff!!”

retourne un tableau de chaîne. Le littéral commence par a “, se termine par a ”et les chaînes sont délimitées intérieurement par “. Le résultat est

["", "DDoo  nn", "", "oott  rreepp", "", "eeaatt  yyoouurrss", "", "eellff!!"]

L'argument du lien et la valeur de retour sont définis sur ce tableau de chaînes, puis le reste du code source est exécuté.

<literal>”ṛṛḷḷWWQQ€€  Argument/return value: A (string array)

         ”ṛ           Yield the character 'ṛ'.
           ṛ          Select the right argument of 'ṛ' and A: A.
            ḷ         Select the left argument of A and A: A.
              W       Wrap; yield [A].
             ḷ        Select the left argument of A and [A]: A.
               W      Wrap; yield [A].
                Q     Unique; deduplicate [A]. Yields [A].
                 Q€€  Unique each each; for each string s in A, deduplicate s.

Gammaplex , 66 octets

\\

XX""!!fflleessrruuooyy  ttaaeeppeerr  ttoonn  ooDD""XXXXrrRREE

Gammaplex est un langage 2D qui utilise la position de la première ligne nouvelle comme longueur de ligne et ignore toutes les autres lignes nouvelles.

MSM , 270 160 octets

!!'',,ff'',,ll'',,ee'',,ss'',,rr'',,uu'',,oo'',,yy'',,  '',,tt'',,aa'',,ee'',,pp'',,ee'',,rr'',,  '',,tt'',,oo'',,nn'',,  '',,oo'',,DD'',,......................

Mon premier programme HSH!

La sortie de chaîne dans MSM est réalisée en poussant les caractères individuels sur la pile et en les joignant en une seule chaîne ., par exemple

!olleH.....

Le nombre de .est un de moins que le nombre de caractères. Car Do not repeat yourself!nous avons besoin de 22 .s. Heureusement, c'est un nombre pair, nous avons donc 11 doubles

......................

Mettre les lettres devant nécessite plus d'effort. Le motif

cc'',,

fait le tour pour chaque personnage c. Il évalue comme suit

cc'',,            push c (remember: commands are taken from the left and operate on the right)
c'',,c            push c
'',,cc            quote ' and push
,,cc'             pop
,cc               pop
c                 voilà!

Nous avons besoin de 23 modèles commençant par !!'',,et se terminant DD'',,par 22 suivis des commandes de jointure ..

Befunge 98, 70 à 66 octets

Essayez-le en ligne!

Après ma réponse invalide, en voici une meilleure qui relève réellement du défi!

2200**xx""!!fflleessrruuooyy  ttaaeeppeerr  ttoonn  ooDD��""kk,,@@

(Merci à Martin Ender pour avoir suggéré l'utilisation de ��caractère 0x17 au lieu de 88ff++)

Explication:

2200          Push 2, 2, 0, and 0 onto the stack
*             Multiply 0 and 0, yielding 0
*             Multiply 2 and 0, yielding 0
              The stack is now [2, 0]
x             Pop a vector off the stack and set the instruction pointer delta to that
              The instruction pointer is now skipping over every other character, since the delta is (2, 0)
"!f ... oD�" Push the string onto the stack, with the number 23 (number of characters in the string) at the top
k,            Pop characters off the stack and print them, 23 times
@             End the program

DC , 348 346 342 306 290 278 octets

Fichier dnr6.short.dc(sans nouvelle ligne):

AAzz--22222222vvPPAAAAAAAAvvPP88vvFFFFFFFFvv00++AAzz--PP11vvFFFFFFFFvv00++AAAAAAvvPP11vvEEEEEEEEvv00++OOOO//44999999vv++PP77II++OOOO//44999999vv++PPAAAAAAvv88vvFFFFFFFFvv00++PPAAzz--BBPP11vvFFFFFFFFvv00++77OOOO++++PPOOOO//44999999vv++66vvFFFFFFFFvv00++PP99zz++OO88++PPAAAAvv33PP

Courir:

$ dc < dnr6.short.dc 
Do not repeat yourself!

Moteur Bot , 6x49 = 294

vv  PP

  !!ee

  ffee

  llee

  eeee

  ssee

  rree

  uuee

  ooee

  yyee

    ee

  ttee

  aaee

  eeee

  ppee

  eeee

  rree

    ee

  ttee

  ooee

  nnee

    ee

  ooee

  DDee

>>  ^^

Revers , 54 octets

vv""!!fflleessrruuooyy  ttaaeeppeerr  ttoonn  ooDD""HH

Essayez-le en ligne!

Puisque le pointeur de Backhand se déplace déjà de trois cellules à la fois, il suffit de le réduire à 2 en utilisant v

réticulaire, non compétitif, 62 octets

2200**UU""DDoo  nnoott  rreeppeeaatt  yyoouurrsseellff!!""oo;;

Essayez-le en ligne!

Explication en parties:

2200**
2200    the stack looks like [2 2 0 0]
    *   [2 2 0*0]
     *  [2 2*0*0]
        [2 0]

Udéfinit la direction du pointeur sur (2, 0), c'est-à-dire, les 2unités x et les unités 0y en mouvement, de sorte qu'il saute tous les autres caractères, en commençant par le prochain Uignoré. Ensuite, tous les autres caractères sont enregistrés, ce qui équivaut à:

"Do not repeat yourself!"o;

qui est un programme de sortie simple.

Autre

Ceci est en compétition pour la prime JavaScript de WallyWest:

Je peux prouver que, bien que les nombres puissent être construits avec cette restriction, les chaînes ne le peuvent pas. Etant donné qu'aucun littéral ne peut être utilisé, le placement d'un caractère de construction de littéral créerait une chaîne vide:

""
''
``

Ensuite, seul un opérateur peut être utilisé. les seuls opérateurs "appariés" utilisés sont:

++ -- << >> ** ~~ || && !! ==

Et aucun de ceux-ci ne peut attribuer des numéros / autres aux chaînes. Donc, aucune chaîne ne peut être sortie.

Alice , 74 octets

aa00tt,,JJ""DDoo  nnoott  rreeppeeaatt  yyoouurrsseellff!!//@@""ooYY;;tt

Essayez-le en ligne!

Explication

Le premier problème est que nous devons être capables de saisir la chaîne, nous voulons donc ignorer uniquement le premier ". Nous faisons cela en sautant sur le premier "car l’adresse IP déplacera une cellule avant de regarder à nouveau la cellule actuelle, de sorte que ce soit la seconde "qui entre en mode chaîne. Mais pour pouvoir sauter là-bas, nous avons besoin 10, 0du sommet de la pile, dans cet ordre (deuxième, haut). Ceci est fait avec aa00tt,,:

                          Stack:
aa   Push two 10s.        [... 10 10]
00   Push two 0s.         [... 10 10 0 0]
tt   Decrement twice.     [... 10 10 0 -2]
,    Rotate(-2).          [... 0 10 10]
,    Rotate(10).          [... 0 10 0]

Cette fonction de rotation déclenche un argument. Si cet argument est négatif, la valeur qui se trouve en haut de la pile est abaissée d'autant de positions. Si l'argument est positif, il recherche l'élément qui se positionne en dessous du sommet et le tire vers le haut. Notez que dans le cas de Rotate(10), il n'y a pas assez d'éléments sur la pile, mais il existe une quantité implicite infinie de zéros en bas, ce qui explique pourquoi un zéro se termine en haut.

Nous pouvons maintenant Jpasser au premier en "utilisant ces deux arguments. Le second "entre en mode chaîne et enregistre tout cela DDoo nnoott.... Lorsqu'il atteint le /, l'adresse IP est redirigée vers le sud-est et nous passons en mode ordinal. Pour l’instant, l’IP rebondit sur les trois lignes (dont deux sont vides), donc il enregistre d’abord trois espaces supplémentaires sur les lignes deux et trois, puis nous quittons le mode chaîne quand il frappe le ". Puisque nous sommes en mode ordinal à ce moment-là, tous les caractères enregistrés sont poussés comme une seule chaîne dans la pile (même si nous en avons enregistré la plupart en mode cardinal). Nous nous retrouvons donc avec cette chaîne (notez les espaces de fin) :

DDoo  nnoott  rreeppeeaatt  yyoouurrsseellff!!   

Maintenant, l'IP continue de rebondir, ce qui signifie qu'il exécute une commande sur une autre paire, c'est Y-à- dire et t. Ensuite, l’IP atteindra la fin de la grille sur la deuxième ligne et commencera à rebondir en arrière à travers la grille. Cela permet également d’indiquer dans quelle paire de caractères l’adresse IP frappe la première ligne. Par conséquent, lors du retour, elle est exécutée ;, oet @. Donc, en ignorant tous les espaces et les redirections IP implicites, le code exécuté est Yt;o@en mode Ordinal.

Le Yest la commande "unzip" qui sépare une chaîne en caractères alternant des caractères. Étant donné que chaque caractère est répété, cela ne nous donne en réalité que deux copies de la chaîne que nous recherchons, bien que la première copie comporte deux espaces de fin et le second un espace de fin. tsépare cet espace de fuite et le ;jette. Enfin, oaffiche la chaîne et @termine le programme.

05AB1E , 100 58 52 octets

-6 octets grâce à Kevin Cruijssen

„„€€··™™……€€––  ……¹¹‚‚  ……––‚‚))εε##θθáá}}»»……!!θθJJ

Essayez-le en ligne!

„„€€·              # dictionary string "g do"
     ·             # double (no effect on strings)
      ™            # title case: "G Do"
       ™           # title case again (no effect)
……€€––             # dictionary string "tools not–"
                   # spaces necessary so "–…" isn't parsed as a dictionary word
……¹¹‚‚             # dictionary string "team repeat‚"
                   # spaces necessary again
……––‚‚             # dictionary string "j yourself‚"
)                  # wrap the entire stack in an array
 )                 # and again: [["G Do", "tools not–", "team repeat‚", "j yourself‚"]]
  ε        }       # for each:
   ε      }        #  for each:
    #              #   split on spaces: ["tools", "not–"]
     #             #   and again: [["tools", "not–"]]
      θ            #   get the last element: ["tools", "not–"]
       θ           #   and again: "not–"
        á          #   keep only letters: "not"
         á         #   and again (no effect)
            »      # join the list by newlines, joining sublists by spaces:
                   # "Do not repeat yourself"
             »     # join the stack by newlines, joining lists by spaces (no effect)
……!!               # literal string "…!!"
    θ              # get the last character: "!"
     θ             # and again (no effect)
      J            # join the stack without separators: "Do not repeat yourself!"
       J           # and again (no effect)
                   # implicit output

Règles d'Idempotency.

Stax , 70 octets

GG11hh::zzaapp..}}..""DDoo  nnoott  rreeppeeaatt  yyoouurrsseellff!!""

Exécutez-le et déboguez-le sur staxlang.xyz!

Stax a très heureusement été construit ::pour chaque mois. Tout ce dont j'ai besoin est de pousser la chaîne doublée, d'appuyer sur 2 et de courir ::. Facile, non?

Faux.

Pousser cette corde est délicat. Le premier guillemet peut être doublé .."", ce qui correspond à un littéral de longueur 2 ."suivi d'un guillemet significatif. Le problème, c'est que je ne vois aucun moyen de terminer la chaîne (ce qui est nécessaire, sinon la version doublée sera imprimée) sans en démarrer une nouvelle.

La fin du programme termine les littéraux de chaîne. Si je peux mettre ce double littéral ici, il y aura peut-être une solution de rechange intéressante. Pour sauter quelque part à la fin d'un programme, cependant, il faut G}au minimum que je regarde ceci:

GG [deduplicate] }}""DDoo  nnoott  rreeppeeaatt  yyoouurrsseellff!!""

Cela ne fait rien. Gne commence pas un bloc, donc ni va sauter à la seconde }. Encore une fois, je dois ignorer un caractère: ..}}. L'exécution saute de la première Gà la seconde }, continue jusqu'à la fin, revient à la seconde Get de là à la seconde }, et continue encore une fois jusqu'à la fin avant de reprendre au début de la [deduplicate]section avec la chaîne doublée au sommet de la pile.

La déduplication est simple. 11hhonze poussé et divisé en deux fois, arrondir les deux fois et donner deux, et ::nous obtiendrez alors la sortie dont nous avons besoin.

GG11hh::..}}..""DDoo  nnoott  rreeppeeaatt  yyoouurrsseellff!!""

Uh-oh. Cela n'imprime rien. Il y a deux problèmes ici: premièrement, cela ..}signifie que la chaîne .}sera au sommet de la pile à la fin du programme, et deuxièmement, la sortie implicite ordinaire de Stax est maintenant désactivée!

Le pire problème est la sortie. Lorsqu'un programme Stax se termine normalement sans rien imprimer, le haut de la pile est implicitement imprimé. Mais nous n'avons rien imprimé ...? Ah, mais nous avons. Les littéraux de chaîne non terminés sont imprimés plutôt que poussés, et même ces deux chaînes vides (parmi celles qui ne correspondent à rien "à la fin), bien qu'elles soient vides, sont suffisantes pour déclencher cette vérification. Toute impression doit être faite à la main.

Nous aurons besoin de ppou PP, et dans ce cas, ignorer le premier passage ..ppest inacceptable, car cela affichera la chaîne .p. Cela signifie que nous avons besoin de la sortie souhaitée, soit seule sur la pile, soit parmi les deux premières avec une chaîne vide. Ce dernier est accompli en poussant deux chaînes vides ( zz) et en tournant les trois éléments du haut deux fois ( aa) avant l'impression.

Une fois que cela est fait, nous avons une pile de quatre chaînes. Un cinquième .}est ensuite poussé avant la fin du programme; à ce stade, le manque de sortie implicite devient une bénédiction et une malédiction, car rien de plus ne sera imprimé!