Scrivi un programma che emette

Do not repeat yourself!

Il codice del programma deve rispettare i seguenti vincoli:

• la sua lunghezza deve essere un numero pari
• ogni carattere in posizione 2n(dove nè un numero intero> 0) deve essere uguale al carattere in posizione 2n-1. Il secondo carattere del programma è uguale al primo, il quarto è uguale al terzo, ecc.

Newline contano come personaggi!

Questo è code-golf, quindi vince il codice più corto!

Esempi

HHeellllooWWoorrlldd è un programma valido

123o AAABBBo HHeellosono errati

Verifica

È possibile utilizzare questo script CJam per verificare che il codice sorgente sia valido. Basta incollare il codice nella casella "Input" ed eseguire lo script.

Esagonia , 166 126 124 byte

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

Inserendo le no-op e gli spazi bianchi impliciti, questo corrisponde al seguente codice sorgente:

       \ \ ; ; ; ; 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 . . .

Sono sicuro che è possibile accorciarlo ancora di più, e forse anche risolverlo in 6 di lunghezza laterale, ma sta diventando complicato ...

Come funziona

^{Diagramma generato con Hexagony Colorer di Timwi .}

Il codice è completamente lineare. Il \diritto all'inizio reindirizza l'IP in una diagonale, in modo tale che non dobbiamo preoccuparci affatto dei caratteri doppi. I percorsi colorati vengono eseguiti nell'ordine arancione / rosso, blu / grigio, verde, viola (quando sono presenti due percorsi dello stesso colore, il percorso a sinistra viene eseguito per primo, prima di spostarsi attorno a quello a destra).

Se ignoriamo no-op, mirror e comandi che sono sovrascritti da altri, il codice lineare si riduce a questo:

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

Le lettere in Esagonia hanno appena impostato il valore del bordo di memoria corrente sul codice carattere della lettera. ;stampa il bordo di memoria corrente come carattere. Usiamo &per ripristinare il bordo di memoria 0e stampare uno spazio con 32;. }si sposta su un bordo diverso, in modo che possiamo ricordare 32per ulteriori spazi. Il resto del codice stampa solo lettere sul nuovo bordo e occasionalmente si sposta avanti e indietro ';}per stampare uno spazio. Alla fine ci spostiamo di nuovo sul bordo dello spazio con ', incrementiamo il valore a 33 con )e stampiamo il punto esclamativo. @termina il programma.

GolfScript, 130 84 76 byte

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

Provalo online in Web GolfScript .

Come funziona

L'interprete GolfScript inizia posizionando una stringa vuota sullo stack.

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

Concatenare un array con una stringa si appiattisce, quindi il risultato è l'output desiderato.

Unario , ~ 1,86 × 10 ²²²

Brainfuck semplice -> risposta unaria. Molto subottimale;).

Il programma è composto da un numero pari di 0; in particolare:

1859184544332157890058930014286871430407663071311497107104094967305277041316183368068453689248902193437218996388375178680482526116349347828767066983174362041491257725282304432256118059236484741485455046352611468332836658716

di loro.

Codice Brainfuck originale:

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

Rubino - 2100 1428 1032 820 670 byte

Ciò presuppone che l'output possa essere un valore restituito da una funzione (non è stato specificato che l'output deve essere su STDOUT)

Codice:

((((((((((((((((((((((((((((((((((((((((((((((""<<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))

Il trucco è costruire la stringa da una stringa vuota ""usando l'operazione append <<e i codici ASCII dei caratteri.

Per ottenere i numeri per i codici ASCII sto cercando di scomporre il numero in valori che posso facilmente generare. Ad esempio ASCII 90è giusto 88+1+1, ovvero:

• 88 va bene da solo
• 11**00è 11^0, che è semplicemente1

Fortunatamente entrambi ++e --significherebbe addin rubino, quindi posso scrivere 90come88++11**00++11**00

Ci sono alcuni trucchi per ottenere alcuni numeri più facilmente rispetto all'aggiunta di solo 1, ecco il codice che sto usando per generare quanto sopra (che include tutti i mapping che sto usando):

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

Sto ancora pensando ad altri trucchi per ridurre i personaggi richiesti per arrivare a un numero.

Nota che se usi il -rppflag e aggiungi ppall'inizio del codice in questo modo:

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

quindi per ulteriori 2 + 4 byte questo può funzionare come un programma completamente completo, ma stamperà un extra "prima e dopo la stringa richiesta:

Esempio:

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

> <> , 174 byte

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

**

..

Per fortuna, in un certo senso la restrizione non si applica in senso verticale. Tuttavia, il problema più grande è che dobbiamo raddoppiare ogni nuova riga.

Il codice che gira approssimativamente va così:

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

Si noti che il programma non ha doppi spazi: in modalità stringa,> <> invia spazi per celle vuote. Al contrario, ciò significa che una soluzione che utilizza g(leggi una singola cella dal codice sorgente) sarebbe più complicata, dal momento che quali spazi sono nel programma diventano NUL quando letti.

^{(Nota: questo può essere più corto di 50 byte se termina con un errore , ma mi piace in questo modo.)}

Sclipting , 186 146 byte

끄끄 닶닶 긂긂 닦닦 닶닶 덇덇 긂긂 댧댧 뉖뉖 댇댇 뉖뉖 눖눖 덇덇 긂긂 뎗뎗 닶닶 덗덗 댧댧 댷댷 뉖뉖 닆닆 뉦뉦 긒긒

껢껢 鎵 鎵 ❶❶ 合 合 虛虛 替 替 標 標 現 現 併 併 一一 終 終

Per essere chiari, ci sono tre righe di codice, la metà delle quali è vuota, perché la nuova riga deve essere duplicata. Il conteggio dei byte si basa sulla codifica UTF-16.

Spiegazione

Il blocco di caratteri coreani all'inizio spinge la stringa "DDDof� \"\u0002nf�of�twG \"\u0002rw'efVpw\aefVaf\u0016twG \"\u0002yw�of�uwWrw'sw7efVlf�fff!\"\u0012". Noterai che ogni terzo personaggio è un personaggio che vogliamo; il resto è incomprensibile. Ecco perché:

In Sclipting, due caratteri coreani codificano tre byte. Pertanto, ogni carattere coreano codifica effettivamente 12 bit. Per iniziare una stringa D, devono essere i primi 8 bit 0x44; il resto non ha importanza, ma dal momento che dobbiamo ripetere ogni personaggio, lo saranno anche i bit dal 12 al 20 0x44. Pertanto, avremo un valore della forma 0x44n44nper alcuni n , che si decompone in tre byte 0x44 0xn4 0x4n.

Per il o, che è 0x6F, otteniamo i byte 0x6F 0xn6 0xFn.

Dato che sono pigro, ho iniziato con la codifica "DDDooo nnnooottt (etc.)"e poi ho sostituito ogni altro carattere con il precedente, motivo per cui ottengo 0x444444= "DDD"per il De 0x6F66F6= "of�"per il o. L' �è lì perché 0xF6di per sé è UTF-8 codifica non valida.

Ora, torniamo al programma. Il resto del programma procede come segue:

껢껢 - spinge la stringa ".\"�"

鎵 鎵 - rimuove due volte l'ultimo carattere, lasciandoci con "."

❶❶ - due duplicati. Stack ora:[".", ".", "."]

合 合 - concatenare due volte. Stack ora:["..."]

Ora, quello che voglio fare dopo è usare "..."come espressione regolare in modo da poter abbinare tre caratteri dalla stringa originale alla volta, usando il costrutto loop 終 ... 終. Tuttavia, poiché ogni istruzione è duplicata, ho bisogno di avere due di questi cicli di espressioni regolari annidati l'uno nell'altro, e se lo stack si interrompe ottengo un errore di runtime. Perciò,

虛虛 - premere due volte la stringa vuota

e quindi avviare i loop. In questo modo, il ciclo esterno scorre una sola volta perché corrisponde all'espressione regolare ""rispetto alla stringa "", che produce una singola corrispondenza. Il ciclo interno viene eseguito una volta per ogni corrispondenza di "..."contro la stringa grande. Il corpo del loop è:

標 標 - spingere due segni sulla pila. Stack ora:[mark mark]

現 現 - invia due copie della partita regex corrente. Stack ora:[mark mark "DDD" "DDD"]

併 併 - concatena fino al primo segno. Stack ora:["DDDDDD"]

一一 - prendi il primo carattere di quella stringa, quindi (ridondante) il primo carattere di quella stringa. Stack ora ha il personaggio che vogliamo.

Il ciclo interno termina qui, quindi ogni corrispondenza dell'espressione regolare viene sostituita con il primo carattere di quella corrispondenza. Questo lascia la stringa desiderata in pila.

Quindi il ciclo esterno termina, a quel punto la stringa desiderata viene rimossa dallo stack e l'unica corrispondenza di ""nella stringa ""viene sostituita con essa, lasciando di nuovo la stringa desiderata nello stack.

Labyrinth , 528 byte

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

Le doppie newline fanno male, ma almeno questo dimostra che è fattibile!

Ogni carattere viene stampato uno a uno, prima formando il punto di codice, quindi stampando un singolo carattere. I punti di codice sono formati da:

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

dove

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

Il comportamento insolito delle cifre di Labyrinth è sfruttato 33::00&&, che in realtà lo è

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

Ogni singolo carattere è stampato con il meccanismo

__vv

  ..

xx

La xxesistono solo per riempire la griglia in modo che sia 5 alto. Prima __spingiamo due zero, quindi colpiamo un operatore di rotazione della griglia v. Apriamo uno zero e ruotiamo:

__ v
  v
   .
  .
xx

e di nuovo:

__ v

  v.

xx.

Passiamo quindi .alla terza riga verso destra , eseguendo così il comando di stampa una sola volta.

CJam - 176 136 byte

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

Grazie a Sp3000 per aver diviso la dimensione del mio programma per due :-)

Spiegazione

• I codici HH77++, GG00++... calcolano il codice intero ASCII dei caratteri aggiungendo numeri (ad esempio: `HH77 ++ 'inserisce 17, 17 e 77 nello stack, quindi aggiunge questi 3 numeri)
• la parte di codice all'estremità ]]{{cc}}//scorre attraverso i codici ASCII e li converte in caratteri.

Provalo qui

Brainf *** automodificante , 72 byte

Si noti che \x00rappresenta un NULbyte esadecimale letterale (cella vuota). Il codice sorgente viene posizionato sul nastro, a sinistra della cella iniziale.

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

Spiegazione

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

Inoltre, prima di creare questo programma, ne stavo realizzando uno usando solo caratteri BF nella fonte. È possibile! È anche molto più lungo, poiché per un valore ASCII dispari, avrei creato il doppio del valore, quindi dividere per due. Un po 'più breve sarebbe modificare l'intera fonte per generare valori dispari per cominciare.

Gelatina , 66 byte (non competitiva)

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

Provalo online!

factoid

Il programma funziona ancora se si rimuove ogni secondo carattere.

Provalo online!

Come funziona

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

restituisce una matrice di stringhe. Il letterale inizia con a “, termina con a ”e le stringhe sono delimitate internamente da “. Il risultato è

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

L'argomento del collegamento e il valore restituito sono impostati su questo array di stringhe, quindi viene eseguito il resto del codice sorgente.

<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 byte

\\

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

Gammaplex è un linguaggio 2D che utilizza la posizione della prima nuova riga come lunghezza della linea e ignora tutte le altre nuove righe.

MSM , 270 160 byte

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

Il mio primo programma MSM!

L'output delle stringhe in MSM viene eseguito spingendo i singoli caratteri nello stack e unendoli in una singola stringa tramite ., ad es

!olleH.....

Il numero di .è uno in meno del numero di caratteri. Perché Do not repeat yourself!abbiamo bisogno di 22 .s. Fortunatamente questo è un numero pari, quindi abbiamo 11 doppie

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

Mettere le lettere davanti ad esso richiede qualche sforzo in più. Il modello

cc'',,

fa il trucco per ogni personaggio c. Valuta come segue

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

Abbiamo bisogno di 23 di questi schemi che iniziano con !!'',,e finiscono con DD'',,seguiti dai 22 comandi join ..

Befunge 98, 70 66 byte

Provalo online!

Dopo la mia risposta non valida, eccone una migliore che si adatta alla sfida!

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

(Grazie a Martin Ender per aver suggerito l'uso di ��, carattere 0x17, anziché 88ff++)

Spiegazione:

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 byte

File dnr6.short.dc(senza trascinare la nuova riga):

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

Correre:

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

BotEngine , 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

>>  ^^

Rovescio , 54 byte

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

Provalo online!

Dal momento che il puntatore di Backhand si sta già muovendo su tre celle per tick, tutto ciò che dobbiamo fare è ridurlo a 2 usando v

reticolare, non competitivo, 62 byte

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

Provalo online!

Spiegazione in parti:

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

Uimposta la direzione del puntatore su (2, 0), cioè, muovendo le 2unità xe le unità 0y, in modo da saltare ogni altro carattere, iniziando con il successivo Uda saltare. Quindi, ogni altro personaggio viene registrato ed equivale a:

"Do not repeat yourself!"o;

che è un semplice programma di output.

Altro

Questo è in competizione per la generosità JavaScript di WallyWest:

Posso dimostrare che, mentre i numeri possono essere costruiti in base a questa restrizione, le stringhe non possono. Poiché non è possibile utilizzare valori letterali, poiché il posizionamento di qualsiasi carattere di creazione letterale creerebbe una stringa vuota:

""
''
``

Quindi, è possibile utilizzare solo alcuni operatori; gli unici operatori "accoppiati" utilizzati sono:

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

E nessuno di questi può trasmettere numeri / altri a stringhe. Quindi non è possibile produrre stringhe.

Alice , 74 byte

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

Provalo online!

Spiegazione

Il primo problema è che dobbiamo essere in grado di inserire la stringa, quindi vogliamo saltare solo il primo ". Lo facciamo saltando sul primo "perché quindi l'IP si sposterà di una cella prima di guardare di nuovo la cella corrente, in modo che sia la seconda "che entra in modalità stringa. Ma per poter saltare lì, abbiamo bisogno 10, 0in cima allo stack, in quell'ordine (secondo, in alto). Questo viene fatto con 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]

Questa funzione di rotazione apre un argomento. Se tale argomento è negativo, spinge il valore in cima allo stack di molte posizioni. Se l'argomento è positivo, cerca l'elemento che molte posizioni sotto la parte superiore e lo tira verso l'alto. Si noti che nel caso di Rotate(10), non ci sono abbastanza elementi nello stack, ma c'è una quantità infinita implicita di zeri nella parte inferiore, motivo per cui uno zero finisce in cima.

Ora possiamo Jpassare al primo "usando questi due argomenti. Il secondo "entra in modalità stringa e registra tutto ciò DDoo nnoott.... Quando colpisce il /, l'IP viene reindirizzato a sud-est e entriamo in modalità Ordinale. Per ora l'IP rimbalza su e giù attraverso le tre linee (due delle quali sono vuote), quindi registra prima altri tre spazi sulle linee due e tre e poi lasciamo la modalità stringa quando colpisce il ". Dato che siamo in modalità Ordinale in questo momento, tutti i caratteri registrati vengono inseriti come una singola stringa nello stack (anche se ne abbiamo registrati la maggior parte in modalità Cardinale), quindi finiamo con questa stringa (notare gli spazi finali) :

DDoo  nnoott  rreeppeeaatt  yyoouurrsseellff!!   

Ora l'IP continua a rimbalzare su e giù, il che significa che esegue un comando di ogni altra coppia, cioè Ye t. Quindi l'IP colpirà la fine della griglia sulla seconda riga e inizierà a rimbalzare indietro attraverso la griglia. Questo cambia anche in quale coppia di caratteri l'IP colpisce la prima riga, quindi quando torna indietro ora esegue ;, oe @. Quindi ignorando tutti gli spazi e i reindirizzamenti IP impliciti, il codice eseguito è Yt;o@in modalità Ordinale.

Il Yè il comando "unzip" che separa una stringa in caratteri in posizioni alternate. Dato che ogni personaggio viene ripetuto, ciò ci dà solo due copie della stringa che stiamo cercando, sebbene la prima copia abbia due spazi finali e la seconda uno spazio finale. tdivide lo spazio finale e lo ;scarta. Infine, ostampa la stringa e @termina il programma.

05AB1E , 100 58 52 byte

-6 byte grazie a Kevin Cruijssen

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

Provalo online!

„„€€·              # 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

Regole di idempotenza.

Stax , 70 byte

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

Eseguilo e esegui il debug su staxlang.xyz!

Stax ha per fortuna il built ::-in per l'ennesimo. Tutto quello che devo fare è spingere la stringa raddoppiata, spingere 2 ed eseguire ::. Facile vero?

Sbagliato.

Spingere quella corda è complicato. La prima virgoletta può essere raddoppiata da .."", che è un letterale di lunghezza 2 per ."seguito da una virgoletta significativa. Il problema è che non vedo alcun modo per terminare la stringa (che è necessario, altrimenti verrà stampata la versione raddoppiata) senza avviarne una nuova.

La fine del programma termina i letterali di stringa. Se riesco a mettere questo letteralmente raddoppiato lì, forse ci sarà una bella soluzione. Per saltare da qualche parte dalla fine di un programma, tuttavia, è necessario G}, quindi almeno sto guardando questo:

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

Questo non fa ... niente. Gnon inizia un blocco, quindi nessuno dei due salterà al secondo }. Anche in questo caso, ho bisogno di ignorare un carattere: ..}}. L'esecuzione salta dal primo Gal secondo }, continua fino alla fine, torna al secondo Ge da lì al secondo }, e continua ancora una volta alla fine prima di riprendere all'inizio della [deduplicate]sezione con la stringa raddoppiata in cima allo stack.

La deduplicazione è semplice. 11hhha spinto undici volte e dimezzato due volte, arrotondando per difetto entrambe le volte e producendo due, e ::poi ci darà il risultato di cui abbiamo bisogno.

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

Uh Oh. Questo non stampa nulla. Ci sono due problemi qui: in primo luogo, ciò ..}significa che la stringa .}sarà in cima allo stack alla fine del programma, e in secondo luogo, l'output implicito ordinario di Stax ora è disabilitato!

Il problema peggiore è l'output. Quando un programma Stax termina graziosamente senza stampare nulla, la parte superiore della pila verrà stampata implicitamente. Ma non abbiamo stampato nulla ...? Ah, ma abbiamo. I letterali di stringa non terminati vengono stampati anziché spinti e anche quelle due stringhe vuote (dalla non "corrispondente alla fine), nonostante siano vuote, sono sufficienti per far scattare questo controllo. Qualsiasi stampa deve essere eseguita a mano.

Avremo bisogno di o ppo PP, e in questo caso, ignorare il primo passaggio ..ppè inaccettabile, poiché stamperà la stringa .p. Ciò significa che abbiamo bisogno dell'output desiderato da soli nello stack o tra i primi due insieme a una stringa vuota. Quest'ultimo si ottiene premendo due stringhe vuote ( zz) e ruotando i primi tre elementi due volte ( aa) prima di stampare.

Fatto ciò, abbiamo una pila alta quattro corde. Un quinto, .}viene quindi spinto prima che il programma esca con grazia; a questo punto, la mancanza di output implicito diventa una benedizione oltre che una maledizione, poiché ora non verrà stampato nulla in più!