Escreva um programa que produza

Do not repeat yourself!

O código do seu programa deve respeitar as seguintes restrições:

• seu comprimento deve ser um número par
• cada caractere que está na posição 2n(onde né um número inteiro> 0) deve ser igual ao caractere na posição 2n-1. O segundo caractere do programa é igual ao primeiro, o quarto é igual ao terceiro, etc.

As novas linhas contam como caracteres!

Isso é código-golfe, então o código mais curto vence!

Exemplos

HHeellllooWWoorrlldd é um programa válido

123ou AAABBBou HHeelloestão incorretos

Verificação

Você pode usar esse script CJam para verificar se seu código-fonte é válido. Simplesmente cole seu código na caixa "Entrada" e execute o script.

Hexagonia , 166 126 124 bytes

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

Inserir as no-ops e os espaços em branco implícitos, isso corresponde ao seguinte código-fonte:

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

Tenho certeza de que é possível reduzir ainda mais isso e talvez até resolvê-lo no comprimento lateral 6, mas está ficando complicado ...

Como funciona

^{Diagrama gerado com o Hexagony Colorer da Timwi .}

O código é completamente linear. A \direita no início redireciona o IP para uma diagonal, de modo que não precisamos nos preocupar com os caracteres dobrados. Os caminhos coloridos são executados na ordem laranja / vermelho, azul / cinza, verde, roxo (quando existem dois caminhos da mesma cor, o caminho esquerdo é executado primeiro, antes de contornar o caminho à direita).

Se ignorarmos no-ops, espelhos e comandos que são substituídos por outros, o código linear se resume a isso:

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

As letras no Hexagony apenas definem o valor da borda da memória atual como o código de caracteres da letra. ;imprime a borda da memória atual como um caractere. Usamos &para redefinir a borda da memória 0e imprimir um espaço com 32;. }move-se para uma borda diferente, para que possamos lembrar 32de outros espaços. O restante do código apenas imprime letras na nova borda e, ocasionalmente, se move para frente e para trás ';}para imprimir um espaço. No final, movemos para a borda do espaço novamente com ', aumente o valor para 33 )e imprima o ponto de exclamação. @finaliza o programa.

GolfScript, 130 84 76 bytes

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

Experimente online no Web GolfScript .

Como funciona

O intérprete GolfScript começa colocando uma sequência vazia na pilha.

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

Concatenar uma matriz com uma cadeia de caracteres nivela, para que o resultado seja a saída desejada.

Unário , ~ 1,86 × ¹⁰²²²

Brainfuck simples -> resposta unária. Muito abaixo do ideal;).

O programa consiste em um número par de zeros; especificamente:

1859184544332157890058930014286871430407663071311497107104094967305277041316183368068453689248903

deles.

Código original do brainfuck:

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

Rubi - 2100 1428 1032 820 670 bytes

Isso pressupõe que a saída possa ser um valor de retorno de uma função (não foi especificado que a saída precise ser para 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))

O truque é criar a sequência a partir de uma sequência vazia ""usando a operação de acréscimo <<e os códigos ASCII dos caracteres.

Para obter os números dos códigos ASCII, estou tentando decompor o número em valores que posso gerar facilmente. Por exemplo, ASCII 90é justo 88+1+1, que é:

• 88 está bem por si própria
• 11**00é 11^0, que é simplesmente1

Felizmente ambos ++e --significaria addem ruby, para que eu possa escrever 90como88++11**00++11**00

Existem alguns truques para chegar a alguns números mais facilmente do que apenas adicionar 1s. Aqui está o código que estou usando para gerar o acima (que inclui todos os mapeamentos que estou 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

Ainda estou pensando em outros truques para diminuir os caracteres necessários para chegar a um número.

Observe que se você usar o -rppsinalizador e adicionar ppao início do código da seguinte maneira:

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

então, para 2 + 4 bytes extras, isso pode funcionar como um programa completo, mas imprimirá um extra "antes e depois da sequência necessária:

Exemplo:

$ 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

**

..

Felizmente, em certo sentido, a restrição não se aplica verticalmente. No entanto, o maior problema é que precisamos dobrar todas as novas linhas.

O código que é executado aproximadamente é assim:

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

Observe que o programa não possui espaços duplos - quando no modo string,> <> empurra espaços para células vazias. Por outro lado, isso significa que uma solução usando g(ler célula única a partir do código fonte) seria mais complicada, pois quais espaços no programa se tornam NULs quando lidos.

^{(Nota: isso pode ser 50 bytes mais curto se terminar com um erro , mas eu gosto dessa maneira.)}

Sclipting , 186 146 bytes

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

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

Para ficar claro, existem três linhas de código, a meio da qual está vazia, porque a nova linha precisa ser duplicada. A contagem de bytes é baseada na codificação UTF-16.

Explicação

O bloco de caracteres coreanos no início empurra a string "DDDof� \"\u0002nf�of�twG \"\u0002rw'efVpw\aefVaf\u0016twG \"\u0002yw�of�uwWrw'sw7efVlf�fff!\"\u0012". Você notará que todo terceiro personagem é um personagem que queremos; o resto é sem sentido. Aqui está o porquê:

No Sclipting, dois caracteres coreanos codificam três bytes. Assim, cada caractere coreano codifica efetivamente 12 bits. Para começar uma string D, os primeiros 8 bits devem ser 0x44; o resto não importa, mas como temos que repetir todos os caracteres, os bits de 12 a 20 também serão 0x44. Assim, teremos um valor do formulário 0x44n44npara alguns n , que se decompõe em três bytes 0x44 0xn4 0x4n.

Para o o, ou seja 0x6F, obtemos os bytes 0x6F 0xn6 0xFn.

Como sou preguiçoso, comecei por codificar "DDDooo nnnooottt (etc.)"e depois substitui todos os outros caracteres pelo anterior, e é por isso que recebo 0x444444= "DDD"para o De 0x6F66F6= "of�"para o o. O �existe porque, 0xF6por si só, é uma codificação UTF-8 inválida.

Agora, de volta ao programa. O restante do programa continua da seguinte maneira:

껢껢 - empurra a corda ".\"�"

鎵 鎵 - remove o último caractere duas vezes, deixando-nos com "."

❶❶ - duas duplicatas. Empilhe agora:[".", ".", "."]

合 - concatena duas vezes. Empilhe agora:["..."]

Agora, o que eu quero fazer a seguir é usar "..."como uma expressão regular para que eu possa combinar três caracteres da sequência original de cada vez, usando a construção de loop 替 ... 終. No entanto, como todas as instruções são duplicadas, preciso ter dois desses loops de expressão regular aninhados um no outro e, se a pilha estiver abaixo do normal, recebo um erro de tempo de execução. Portanto,

虛虛 - pressione a corda vazia duas vezes

e então inicie os loops. Dessa forma, o loop externo itera apenas uma vez porque corresponde à expressão regular ""na sequência "", o que gera uma única correspondência. O loop interno é executado uma vez para cada partida "..."contra a corda grande. O corpo do loop é:

標 標 - pressione duas marcas na pilha. Empilhe agora:[mark mark]

現 現 - envia duas cópias da correspondência atual de regex. Empilhe agora:[mark mark "DDD" "DDD"]

併 併 - concatena até a primeira marca. Empilhe agora:["DDDDDD"]

Take - pega o primeiro caractere dessa string e depois (redundantemente) o primeiro caractere dessa string. Stack agora tem o personagem que queremos.

O loop interno termina aqui, portanto, toda correspondência da expressão regular é substituída pelo primeiro caractere dessa correspondência. Isso deixa a sequência desejada na pilha.

Em seguida, o loop externo termina, quando a string desejada é retirada da pilha e a única correspondência da ""string ""é substituída por ela, deixando a string desejada novamente na pilha.

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

As novas linhas duplas doem, mas pelo menos isso prova que é factível!

Cada caractere é impresso um por um, primeiro formando o ponto de código e depois imprimindo um único caractere. Os pontos de código são 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

Onde

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

O comportamento incomum dos dígitos do labirinto é explorado 33::00&&, o que é realmente

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

Cada caractere único é impresso com o mecanismo

__vv

  ..

xx

A xxexistir apenas para preencher a grade de modo que é 5 alta. Primeiro, __pressione dois zeros e, em seguida, atingimos um operador de rotação da grade v. Nós colocamos um zero e giramos:

__ v
  v
   .
  .
xx

e de novo:

__ v

  v.

xx.

Em seguida, movemos para a direita .na terceira linha, executando o comando de impressão apenas uma 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}}//

Obrigado ao Sp3000 por dividir o tamanho do meu programa por dois :-)

Explicação

• Os códigos HH77++, GG00++... calculam o código ascii inteiro dos caracteres adicionando números (por exemplo: `HH77 ++ 'empurra 17, 17 e 77 na pilha e, em seguida, adicione esses 3 números)
• a parte do código no final ]]{{cc}}//percorre os códigos ascii e os converte em caracteres.

Experimente aqui

Brainf auto-modificador *** , 72 bytes

Observe que \x00representa um literal NULbyte hexadecimal (célula vazia). O código fonte é colocado na fita, à esquerda da célula inicial.

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

Explicação

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

Além disso, antes de fazer este programa, eu estava criando um usando apenas caracteres BF na fonte. É possível! Também é muito mais longo, já que, para um valor ASCII ímpar, eu criaria o dobro do valor e depois dividiria por dois. Um pouco mais curto seria modificar toda a fonte para gerar valores ímpares para começar.

Gelatina , 66 bytes (não concorrente)

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

Experimente online!

Factóide

O programa ainda funciona se você remover cada segundo caractere.

Experimente online!

Como funciona

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

retorna uma matriz de sequência. O literal começa com a “, termina com a ”e as cadeias são delimitadas internamente por “. O resultado é

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

O argumento do link e o valor de retorno são definidos para essa matriz de seqüências de caracteres; o restante do código-fonte é executado.

<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 é uma linguagem 2D que usa a posição da primeira linha nova como o comprimento da linha e ignora todas as outras linhas novas.

MSM , 270 160 bytes

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

Meu primeiro programa de HSH!

A saída da string no MSM é feita empurrando os caracteres individuais para a pilha e juntando-os em uma única string via ., por exemplo,

!olleH.....

O número de .é um menor que o número de caracteres. Pois Do not repeat yourself!precisamos de 22 .s. Felizmente, este é um número par, por isso temos 11 duplos

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

Colocar as letras na frente exige mais esforço. O padrão

cc'',,

faz o truque para cada personagem c. Avalia da seguinte forma

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

Precisamos de 23 padrões desse tipo começando !!'',,e terminando com DD'',,seguido pelos 22 comandos de junção ..

Entre 98, 70 66 bytes

Experimente online!

Após a minha resposta inválida, aqui está uma melhor que realmente se encaixa no desafio!

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

(Agradecemos a Martin Ender por sugerir o uso do ��caractere 0x17 em vez de 88ff++)

Explicação:

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

Arquivo dnr6.short.dc(sem linha nova à direita):

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

Corre:

$ 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

>>  ^^

Backhand , 54 bytes

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

Experimente online!

Como o ponteiro do Backhand já está se movendo a três células por marca, tudo o que precisamos fazer é diminuir esse número para 2 usando v

reticular, não-competidor, 62 bytes

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

Experimente online!

Explicação em partes:

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

Udefine a direção do ponteiro para (2, 0), ou seja, mover 2as unidades xe as unidades 0y, para que ele pule todos os outros caracteres, começando com o próximo a User pulado. Então, todos os outros caracteres são gravados e é equivalente a:

"Do not repeat yourself!"o;

que é um programa de saída simples.

De outros

Isso está competindo pela recompensa JavaScript do WallyWest:

Eu posso provar que, embora os números possam ser construídos sob essa restrição, as strings não podem. Como nenhum literal pode ser usado, o posicionamento de qualquer caractere de construção literal criaria uma string vazia:

""
''
``

Então, apenas algum operador pode ser usado; os únicos operadores "emparelhados" usados ​​são:

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

E nada disso pode converter números / outros em strings. Portanto, nenhuma string pode ser emitida.

Alice , 74 bytes

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

Experimente online!

Explicação

O primeiro problema é que precisamos ser capazes de inserir a string, portanto, queremos pular apenas o primeiro ". Fazemos isso saltando para a primeira, "porque o IP moverá uma célula antes de olhar para a célula atual novamente, de modo que é a segunda "que entra no modo de seqüência de caracteres. Mas para poder pular lá, precisamos 10, 0no topo da pilha, nessa ordem (segundo, topo). Isso é feito com 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]

Essa função de rotação exibe um argumento. Se esse argumento for negativo, ele empurra o valor no topo da pilha para baixo em muitas posições. Se o argumento for positivo, ele procura o elemento que está em muitas posições abaixo do topo e o puxa para cima. Observe que, no caso de Rotate(10), não há elementos suficientes na pilha, mas há uma quantidade infinita implícita de zeros na parte inferior, e é por isso que um zero acaba no topo.

Agora podemos Jadotar o primeiro "usando esses dois argumentos. O segundo "entra no modo de sequência e registra tudo isso DDoo nnoott.... Quando atinge o /, o IP é redirecionado para o sudeste e entramos no modo Ordinal. Por enquanto, o IP salta para cima e para baixo nas três linhas (duas das quais estão vazias); portanto, primeiro registra mais três espaços nas linhas dois e três e, em seguida, deixamos o modo de seqüência de caracteres quando atinge o ". Como estamos no modo Ordinal no momento, todos os caracteres gravados são enviados como uma única sequência para a pilha (mesmo que tenhamos gravado a maioria deles no modo Cardinal), então terminamos com essa sequência (observe os espaços à direita) :

DDoo  nnoott  rreeppeeaatt  yyoouurrsseellff!!   

Agora, o IP continua subindo e descendo, o que significa que ele executa um comando de qualquer outro par, ou seja, Ye t. Em seguida, o IP atingirá o final da grade na segunda linha e começará a saltar para trás na grade. Isso também muda em qual par de caracteres o IP atinge a primeira linha; portanto, ao voltar, ele agora executa ;, oe @. Portanto, ignorando todos os espaços e redirecionamentos IP implícitos, o código executado está Yt;o@no modo Ordinal.

O Yé o comando "descompactar" que separa uma string nos caracteres em posições alternadas. Como cada caractere é repetido, isso nos dá apenas duas cópias da sequência que queremos, embora a primeira cópia tenha dois espaços à direita e a segunda tenha um espaço à direita. tdivide esse espaço à direita e o ;descarta. Por fim, oimprime a string e @finaliza o programa.

05AB1E , 100 58 52 bytes

-6 bytes graças a Kevin Cruijssen

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

Experimente 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

Regras de idempotência.

Stax , 70 bytes

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

Execute e depure-o em staxlang.xyz!

Felizmente, Stax tem o construído ::para todos os dias. Tudo o que preciso é pressionar a corda dobrada, pressionar 2 e correr ::. Fácil né?

Errado.

Empurrar essa corda é complicado. A primeira citação pode ser dobrada por .."", que é um literal de comprimento 2 para ."seguido por uma citação significativa. O problema é que não vejo como terminar a string (o que é necessário, ou a versão dobrada será impressa) sem iniciar uma nova.

O final do programa termina os literais de sequência. Se eu puder colocar esse literal duplicado lá, talvez haja uma boa solução alternativa. Para pular para algum lugar do final de um programa, no entanto, é necessário G}, portanto, no mínimo, estou olhando para isso:

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

Isso não faz nada. Gnão inicia um bloco, então nenhum deles salta para o segundo }. Mais uma vez, eu preciso ignorar um personagem: ..}}. A execução salta do primeiro Gpara o segundo }, continua até o fim, volta para o segundo Ge de lá para o segundo }, e continua mais uma vez até o fim, antes de continuar no início da [deduplicate]seção com a corda dobrada no topo da pilha.

A desduplicação é simples. 11hhempurrou onze e reduziu pela metade duas vezes, arredondando as duas vezes para baixo e rendendo duas e ::, em seguida, obterá a saída de que precisamos.

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

Oh-oh. Isso não imprime nada. Existem dois problemas aqui: primeiro, isso ..}significa que a string .}estará no topo da pilha no final do programa e, segundo, a saída implícita comum do Stax agora está desativada!

O pior problema é a saída. Quando um programa Stax termina normalmente sem imprimir nada, a parte superior da pilha é impressa implicitamente. Mas não imprimimos nada ...? Ah, mas nós temos. Literais de sequência não terminados são impressos em vez de enviados por push, e mesmo essas duas sequências vazias (das sem correspondência "no final), apesar de vazias, são suficientes para desarmar essa verificação. Qualquer impressão deve ser feita à mão.

Precisamos de um ppou PP, e, neste caso, ignorar o primeiro passo ..ppé inaceitável, pois ele imprimirá a sequência .p. Isso significa que precisamos da saída desejada sozinhos na pilha ou entre os dois primeiros, juntamente com uma string vazia. Isso é feito pressionando duas cordas vazias ( zz) e girando os três itens principais duas vezes ( aa) antes de imprimir.

Feito isso, temos uma pilha com quatro cordas de altura. Um quinto, .}é pressionado antes que o programa saia normalmente; neste ponto, a falta de saída implícita se torna uma bênção e uma maldição, pois nada extra será impresso agora!