Escribe un programa que salga

Do not repeat yourself!

Su código de programa debe respetar las siguientes restricciones:

• su longitud debe ser un número par
• cada carácter que está en posición 2n(donde nes un entero> 0) debe ser igual al carácter en posición 2n-1. El segundo carácter del programa es igual al primero, el cuarto es igual al tercero, etc.

¡Las nuevas líneas cuentan como personajes!

Este es el código de golf, por lo que gana el código más corto.

Ejemplos

HHeellllooWWoorrlldd es un programa valido

123o AAABBBo HHeelloson incorrectos

Verificación

Puede usar este script CJam para verificar que su código fuente sea válido. Simplemente pegue su código en el cuadro "Entrada" y ejecute el script.

Hexagony , 166 126 124 bytes

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

Al insertar las no-operaciones y los espacios en blanco implícitos, esto corresponde al siguiente código fuente:

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

Estoy seguro de que es posible acortar esto aún más, y tal vez incluso resolverlo en la longitud lateral 6, pero se está volviendo complicado ...

Cómo funciona

^{Diagrama generado con el Coloreador de Hexagonía de Timwi .}

El código es completamente lineal. La \derecha al inicio redirige la IP a una diagonal, de modo que no tenemos que preocuparnos por los caracteres duplicados. Las rutas de colores se ejecutan en el orden naranja / rojo, azul / gris, verde, morado (cuando hay dos rutas del mismo color, la ruta de la izquierda se ejecuta primero, antes de ajustarse a la derecha).

Si ignoramos los no-ops, los espejos y los comandos que otros anulan, el código lineal se reduce a esto:

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

Las letras en Hexagony solo establecen el valor del borde de memoria actual en el código de caracteres de la letra. ;imprime el borde de la memoria actual como un carácter. Utilizamos &para restablecer el borde de la memoria 0e imprimir un espacio con 32;. }se mueve a un borde diferente, para que podamos recordar el 32espacio adicional. El resto del código solo imprime letras en el nuevo borde y ocasionalmente se mueve hacia adelante y hacia atrás ';}para imprimir un espacio. Al final, volvemos al borde del espacio con ', incrementamos el valor a 33 con )e imprimimos el signo de exclamación. @termina el programa

GolfScript, 130 84 76 bytes

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

Pruébelo en línea en Web GolfScript .

Cómo funciona

El intérprete de GolfScript comienza colocando una cadena vacía en la pila.

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

Concatenando una matriz con una cadena se aplana, por lo que el resultado es el resultado deseado.

Unario , ~ 1.86 × 10 ²²²

Brainfuck simple -> respuesta unaria. Muy subóptimo;).

El programa consta de un número par de 0; específicamente:

1859184544332157890058930014286871430407663071311497107104094967305277041316183368068453689248902193437218996388375178680482526116349347828767066983174362041491257725282304432256118059236484741485455046352611468332836658716

de ellos.

Código original de brainfuck:

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

Ruby - 2100 1428 1032 820 670 bytes

Esto supone que la salida puede ser un valor de retorno de una función (no se especificó que la salida debe ser STDOUT)

Código:

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

El truco consiste en construir la cadena a partir de una cadena vacía ""utilizando la operación de agregar <<y los códigos ASCII de los caracteres.

Para obtener los números de los códigos ASCII, estoy tratando de descomponer el número en valores que pueda generar fácilmente. Por ejemplo, ASCII 90es justo 88+1+1, que es:

• 88 está bien por sí mismo
• 11**00es decir 11^0, que es simplemente1

Afortunadamente tanto ++y --que significaría adden rubí, de modo que pueda escribir 90como88++11**00++11**00

Hay algunos trucos para llegar a algunos números más fácilmente que simplemente agregar 1s, aquí está el código que estoy usando para generar lo anterior (que incluye todas las asignaciones que estoy 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

Todavía estoy pensando en otros trucos para disminuir los caracteres necesarios para llegar a un número.

Tenga en cuenta que si usa la -rppbandera y agrega ppal inicio del código de esta manera:

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

luego, para 2 + 4 bytes adicionales, esto puede funcionar como un programa completamente completo, pero imprimirá un extra "antes y después de la cadena requerida:

Ejemplo:

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

> <> , 174 bytes

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

**

..

Afortunadamente, en cierto sentido, la restricción no se aplica verticalmente. Sin embargo, el mayor problema es que necesitamos duplicar cada nueva línea.

El código que se ejecuta aproximadamente es el siguiente:

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

Tenga en cuenta que el programa no tiene espacios dobles: cuando está en modo de cadena,> <> empuja espacios para celdas vacías. Sin embargo, a la inversa, esto significa que una solución usando g(leer una sola celda del código fuente) sería más complicado, ya que los espacios que hay en el programa se convierten en NUL cuando se leen.

^{(Nota: Esto puede ser 50 bytes más corto si termina con un error , pero me gusta de esta manera).}

Sclipting , 186 146 bytes

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

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

Para ser claros, hay tres líneas de código, la mitad de las cuales está vacía, porque la nueva línea debe duplicarse. El recuento de bytes se basa en la codificación UTF-16.

Explicación

El bloque de caracteres coreanos al comienzo empuja la cadena "DDDof� \"\u0002nf�of�twG \"\u0002rw'efVpw\aefVaf\u0016twG \"\u0002yw�of�uwWrw'sw7efVlf�fff!\"\u0012". Notarás que cada tercer personaje es un personaje que queremos; El resto es galimatías. Este es el por qué:

En Sclipting, dos caracteres coreanos codifican tres bytes. Por lo tanto, cada carácter coreano codifica efectivamente 12 bits. Para comenzar una cadena D, los primeros 8 bits tienen que ser 0x44; el resto no importa, pero como tenemos que repetir todos los caracteres, los bits 12 a 20 también lo serán 0x44. Por lo tanto, tendremos un valor de la forma 0x44n44npara algunos n , que se descompone en los tres bytes 0x44 0xn4 0x4n.

Para el o, que es 0x6F, obtenemos los bytes 0x6F 0xn6 0xFn.

Como soy vago, comencé codificando "DDDooo nnnooottt (etc.)"y luego reemplacé todos los demás caracteres con el anterior, por lo que obtengo 0x444444= "DDD"para el Dy 0x6F66F6= "of�"para el o. El �está allí porque 0xF6por sí solo es una codificación UTF-8 no válida.

Ahora, de vuelta al programa. El resto del programa procede de la siguiente manera:

껢껢 - empuja la cuerda ".\"�"

鎵 鎵 - elimina el último personaje dos veces, dejándonos con "."

❶❶ - dos duplicados. Apilar ahora:[".", ".", "."]

合 合 - concatenar dos veces. Apilar ahora:["..."]

Ahora, lo que quiero hacer a continuación es usarlo "..."como una expresión regular para poder hacer coincidir tres caracteres de la cadena original a la vez, usando la construcción de bucle 替 ... 終. Sin embargo, dado que cada instrucción está duplicada, necesito tener dos bucles de expresión regular anidados uno dentro del otro, y si la pila no funciona, obtengo un error de tiempo de ejecución. Por lo tanto,

虛虛 - empuja la cuerda vacía dos veces

y luego comienza los bucles. De esta manera, el bucle externo itera solo una vez porque coincide con la expresión regular ""contra la cadena "", lo que produce una sola coincidencia. El bucle interno se ejecuta una vez por cada partido de "..."contra la cadena grande. El cuerpo del bucle es:

標 標 - empuja dos marcas en la pila. Apilar ahora:[mark mark]

現 現: inserta dos copias de la coincidencia de expresiones regulares actual. Apilar ahora:[mark mark "DDD" "DDD"]

併 併 - concatenar hasta la primera marca. Apilar ahora:["DDDDDD"]

一一 - toma el primer carácter de esa cadena y luego (redundantemente) el primer carácter de esa cadena. Stack ahora tiene el personaje que queremos.

El ciclo interno termina aquí, por lo que cada coincidencia de la expresión regular se reemplaza con el primer carácter de esa coincidencia. Esto deja la cadena deseada en la pila.

Luego, termina el bucle externo, en cuyo punto la cadena deseada se retira de la pila y la única coincidencia de ""la cadena ""se reemplaza con ella, dejando la cadena deseada nuevamente en la pila.

Laberinto , 528 bytes

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

Las nuevas líneas dobles duelen, pero al menos esto demuestra que es factible.

Cada carácter se imprime uno por uno, primero formando el punto de código y luego imprimiendo un único carácter. Los puntos de código están formados por:

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

dónde

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

Se explota el comportamiento inusual de los dígitos del Laberinto 33::00&&, que en realidad es

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

Cada carácter individual se imprime con el mecanismo.

__vv

  ..

xx

El xxsólo existen para rellenar la cuadrícula para que sea más 5 alta. Primero __presionamos dos ceros, luego tocamos un operador de rotación de cuadrícula v. Hacemos un cero y giramos:

__ v
  v
   .
  .
xx

y otra vez:

__ v

  v.

xx.

Luego nos movemos hacia la derecha .en la tercera fila, ejecutando el comando de impresión solo una vez.

CJam - 176 136 bytes

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

Gracias a Sp3000 por dividir el tamaño de mi programa entre dos :-)

Explicación

• Los códigos HH77++, GG00++... calculan el código ascii entero de los caracteres agregando números (por ejemplo: 'HH77 ++' empuja 17, 17 y 77 en la pila, luego agrega estos 3 números)
• la parte del código al final ]]{{cc}}//recorre los códigos ascii y los convierte en caracteres.

Pruébalo aquí

Brainf *** auto modificable , 72 bytes

Tenga en cuenta que \x00representa un NULbyte hexadecimal literal (celda vacía). El código fuente se coloca en la cinta, a la izquierda de la celda inicial.

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

Explicación

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

Además, antes de hacer este programa, estaba haciendo uno usando solo caracteres BF en la fuente. ¡Es posible! También es mucho más largo, ya que para un valor ASCII impar, iba a crear el doble del valor, luego dividirlo por dos. Algo más corto sería modificar toda la fuente para generar valores impares para comenzar.

Gelatina , 66 bytes (no competitiva)

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

Pruébalo en línea!

Factoid

El programa aún funciona si elimina cada segundo carácter.

Pruébalo en línea!

Cómo funciona

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

devuelve una matriz de cadena. El literal comienza con a “, termina con a ”, y las cadenas están delimitadas internamente por “. El resultado es

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

El argumento del enlace y el valor de retorno se establecen en esta matriz de cadenas, luego se ejecuta el resto del código fuente.

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

\\

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

Gammaplex es un lenguaje 2D que utiliza la posición de la primera línea nueva como la longitud de la línea e ignora todas las demás líneas nuevas.

MSM , 270160 bytes

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

Mi primer programa de MSM!

La salida de cadena en MSM se realiza empujando los caracteres individuales en la pila y uniéndolos en una sola cadena a través de ., por ejemplo

!olleH.....

El número de .es uno menos que el número de caracteres. Para Do not repeat yourself!nosotros necesitamos 22 .s. Por suerte este es un número par, por lo que tenemos 11 dobles

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

Poner las letras delante requiere algo más de esfuerzo. El patrón

cc'',,

hace el truco para cada personaje c. Se evalúa de la siguiente manera

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

Necesitamos 23 patrones de este tipo que comiencen !!'',,y terminen DD'',,seguidos de los 22 comandos de unión ..

Befunge 98, 70 66 bytes

Pruébalo en línea!

Después de mi respuesta no válida, ¡aquí hay una mejor que realmente se ajusta al desafío!

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

(Gracias a Martin Ender por sugerir el uso del ��carácter 0x17 en lugar de 88ff++)

Explicación:

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 bytes

Archivo dnr6.short.dc(sin línea nueva):

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

Correr:

$ 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

>>  ^^

Revés , 54 bytes

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

Pruébalo en línea!

Dado que el puntero de Backhand ya se mueve en tres celdas por tic, todo lo que tenemos que hacer es disminuirlo a 2 usando v

reticular, no competitivo, 62 bytes

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

Pruébalo en línea!

Explicación en partes:

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

Uestablece la dirección del puntero en (2, 0), es decir, mover 2las unidades xy las unidades y 0, por lo que omite todos los demás caracteres, comenzando con el siguiente Uomitido. Luego, se graba cada otro personaje, y es equivalente a:

"Do not repeat yourself!"o;

que es un programa de salida simple.

Otro

Esto está compitiendo por la recompensa JavaScript de WallyWest:

Puedo demostrar que, si bien los números pueden construirse bajo esta restricción, las cadenas no pueden. Dado que no se pueden usar literales, ya que la colocación de cualquier carácter de construcción literal crearía una cadena vacía:

""
''
``

Entonces, solo se puede usar algún operador; Los únicos operadores "emparejados" utilizados son:

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

Y ninguno de estos puede emitir números / otros a cadenas. Por lo tanto, no se pueden generar cadenas.

Alice , 74 bytes

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

Pruébalo en línea!

Explicación

El primer problema es que necesitamos poder ingresar la cadena, por lo que queremos omitir solo el primero ". Hacemos esto saltando a la primera "porque luego la IP moverá una celda antes de mirar la celda actual nuevamente, de modo que sea la segunda la "que ingrese al modo de cadena. Pero para poder saltar allí, necesitamos 10, 0en la parte superior de la pila, en ese orden (segundo, superior). Esto se hace 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]

Esta función de rotación muestra un argumento. Si ese argumento es negativo, empuja el valor en la parte superior de la pila hacia abajo en esa cantidad de posiciones. Si el argumento es positivo, busca el elemento que se encuentra muchas posiciones debajo de la parte superior y lo empuja hacia arriba. Tenga en cuenta que, en el caso de Rotate(10), no hay suficientes elementos en la pila, pero hay una cantidad infinita implícita de ceros en la parte inferior, por lo que un cero termina en la parte superior.

Ahora podemos Jpasar al primero "usando estos dos argumentos. El segundo "ingresa al modo de cadena y registra todo eso DDoo nnoott.... Cuando toca el /, la IP se redirige al sureste y entramos en modo ordinal. Por ahora, la IP rebota hacia arriba y hacia abajo a través de las tres líneas (dos de las cuales están vacías), por lo que primero registra tres espacios más en las líneas dos y tres y luego dejamos el modo de cadena cuando toca el ". Dado que estamos en modo Ordinal en este momento, todos los caracteres grabados se insertan como una sola cadena en la pila (a pesar de que grabamos la mayoría de ellos en modo Cardinal), por lo que terminamos con esta cadena (tenga en cuenta los espacios finales) :

DDoo  nnoott  rreeppeeaatt  yyoouurrsseellff!!   

Ahora la IP sigue rebotando hacia arriba y hacia abajo, lo que significa que ejecuta un comando de cada par, es decir, Yy t. Luego, la IP llegará al final de la cuadrícula en la segunda línea y comenzará a rebotar hacia atrás a través de la cuadrícula. Esto también cambia en qué par de caracteres la IP toca la primera línea, por lo que al retroceder ahora se ejecuta ;, oy @. Ignorando todos los espacios y las redirecciones de IP implícitas, el código ejecutado está Yt;o@en modo Ordinal.

El Yes el comando "descomprimir" que separa una cadena en los caracteres en posiciones alternas. Dado que cada carácter se repite, eso realmente nos da dos copias de la cadena que buscamos, aunque la primera copia tiene dos espacios finales y la segunda tiene un espacio final. tdivide ese espacio final y lo ;descarta. Finalmente, oimprime la cadena y @termina el programa.

05AB1E , 100 58 52 bytes

-6 bytes gracias a Kevin Cruijssen

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

Pruébalo en línea!

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

Reglas de idempotencia.

Stax , 70 bytes

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

¡Ejecútelo y depúrelo en staxlang.xyz!

Stax, afortunadamente, tiene la capacidad ::para cada enésima. Todo lo que necesito es empujar la cadena doblada, presionar 2 y correr ::. Fácil, verdad?

Incorrecto.

Empujar esa cuerda es complicado. La primera comilla se puede duplicar por .."", que es un literal de longitud 2 para ."seguido de una comilla significativa. El problema es que no veo forma de terminar la cadena (lo cual es necesario, o de lo contrario se imprimirá la versión duplicada) sin comenzar una nueva.

El final del programa termina los literales de cadena. Si puedo poner este literal duplicado allí, tal vez haya una buena solución. Sin embargo, para saltar desde el final de un programa, se requiere G}, así que, como mínimo, estoy mirando esto:

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

Esto no hace ... nada. Gno comienza un bloqueo, por lo que ninguno saltará al segundo }. Una vez más, tengo que hacer caso omiso de un carácter: ..}}. La ejecución salta del primero Gal segundo }, continúa hasta el final, salta de nuevo al segundo Gy de allí al segundo }, y continúa una vez más hasta el final antes de continuar al comienzo de la [deduplicate]sección con la cadena doblada encima de la pila.

La deduplicación es simple. 11hhempujó once y lo redujo a la mitad dos veces, redondeando hacia abajo las dos veces y produciendo dos, y ::luego nos dará la salida que necesitamos.

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

UH oh. Esto no imprime nada. Aquí hay dos problemas: primero, eso ..}significa que la cadena .}estará encima de la pila al final del programa, y ​​segundo, ¡la salida implícita ordinaria de Stax ahora está desactivada!

El peor problema es la salida. Cuando un programa Stax finaliza correctamente sin imprimir nada, la parte superior de la pila se imprimirá implícitamente. ¿Pero no hemos impreso nada ...? Ah, pero tenemos. Los literales de cadena no terminados se imprimen en lugar de empujarse, e incluso esas dos cadenas vacías (de las que no coinciden "al final), a pesar de estar vacías, son suficientes para disparar esta comprobación. Cualquier impresión debe hacerse a mano.

Necesitaremos uno ppo PP, y en este caso, ignorar el primer paso ..ppes inaceptable, ya que imprimirá la cadena .p. Eso significa que necesitamos nuestra salida deseada ya sea solo en la pila o en los dos primeros junto con una cadena vacía. Esto último se logra presionando dos cadenas vacías ( zz) y girando los tres elementos superiores dos veces ( aa) antes de imprimir.

Una vez hecho esto, tenemos una pila de cuatro cuerdas de alto. Un quinto, .}luego se empuja antes de que el programa salga con gracia; En este punto, la falta de salida implícita se convierte en una bendición y una maldición, ya que ahora no se imprimirá nada extra.