Solo repítete

64

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.

Arnaud
fuente
51
Dato curioso: si el problema tuviera trillizos en su lugar, DDDooo nnnooottt rrreeepppeeeaaattt yyyooouuurrrssseeelllfff!!!sería una respuesta válida en Trigger
Sp3000
14
Pensé que esto podría ser demasiado restrictivo, pero la gran cantidad de respuestas me demuestra que estoy equivocado. ¡Buena pregunta!
trichoplax
Se necesitaría un esfuerzo bastante serio para satisfacer estos requisitos en Haskell. Se eliminan todas las formas de enlace, todas las formas de expresión condicional, todas las formas de ingresar caracteres y cadenas, y todas las formas de producir resultados.
dfeuer
1
¿Alguien podría agregar un fragmento de puntuación? Me gusta tenerlos y desearía que cada pregunta los tuviera.
mbomb007
Todas las respuestas actuales son langs esotéricos. Me pregunto si esto es posible en un idioma normal?
DankMemes

Respuestas:

51

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

ingrese la descripción de la imagen aquí

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

Martin Ender
fuente
44
¡Esto es realmente impresionante!
WizardOfMenlo
¿Cómo llegaste a la conclusión de que es posible en tamaño 6 o incluso 5 ? Veo el tamaño 7 como apenas ajustado.
Timwi
@Timwi 5 probablemente fue un poco ambicioso, pero con la excepción de uno solo ;, todavía no hay absolutamente ninguna reutilización entre pares de caracteres en el código. El código actual es más o menos lo primero que se me ocurrió, así que estoy pensando que si uno lo intentara lo suficiente, debería ser posible encontrar una solución mucho más complicada que reutilice los puntos y comas y tal vez incluso algunas letras, para que encajen. en la longitud lateral 6.
Martin Ender
Para llegar al tamaño 6, tendría que guardar 36 caracteres en comparación con el tamaño 7. Incluso si usa las 6 ranuras no utilizadas que tiene en este momento, aún tendría que guardar 30. Puede reutilizarlo ;solo una vez porque no puede atravesarlos horizontalmente. Solo hay 23 ;s en su código, y solo 6 repeticiones de caracteres (2 × o, 1 × t, 1 × r, 2 × e), dando solo 29. Personalmente, esto más que me convence de que el tamaño 6 es imposible. .
Timwi
44

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.

Dennis
fuente
38

Unario , ~ 1.86 × 10 222

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:

++++[++++>---<]>+.[--->+<]>+++.[--->+<]>-----.+[----->+<]>+.+.+++++.[---->+<]>+++.---[----->++<]>.-------------.+++++++++++.-----------.----.--[--->+<]>-.[---->+<]>+++.--[->++++<]>+.----------.++++++.---.+.++++[->+++<]>.+++++++.------.[--->+<]>-.
Maltysen
fuente
3
Ninguno de los bloques de código que ha proporcionado cumple la regla de duplicación. ¿Qué me estoy perdiendo?
doppelgreener
26
@doppelgreener: El primer bloque de "código" es simplemente un gran número. Específicamente, el número de 1s en el programa Unary que genera la cadena solicitada. El segundo bloque de código es el programa BF que se usó para producirlo. Como el programa Unary está completamente hecho de 1s, satisface trivialmente el requisito de repetición.
El'endia Starman
8
También el número de ceros es (¿afortunadamente?) Un número par :-)
Arnaud
1
Me he tomado la libertad de editar la respuesta para que el número no parezca que se supone que es el código.
Timwi
2
@Kametrixom es una descripción Golunar del programa Unary. El programa Golunar tal como está escrito no cumple las condiciones.
Paŭlo Ebermann
34

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!"
SztupY
fuente
¿Podría aclarar por qué esto no es totalmente compatible? Me parece perfecto, e incluso la ppgema es una letra doble ...
trichoplax
3
@trichoplax: está en la publicación: 1. "caracteres adicionales en la salida y 2. la necesidad de la -rppbandera (que no es como --rrpp)
SztupY
1
Esta respuesta es genial, pero las respuestas que no cumplen con las especificaciones están sujetas a eliminación.
Wheat Wizard
1
@SztupY Para ser absolutamente claro, es política del sitio eliminar las respuestas que no siguen las reglas del desafío.
Mike Bufardeci
23

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

Sp3000
fuente
1
La herramienta adecuada para el trabajo ...
Erik the Outgolfer
20

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.

Timwi
fuente
3
Umm ... ¿por qué no usaste el formato de código aquí? ¿Son los caracteres chinos?
Erik the Outgolfer
@EriktheOutgolfer Me preguntaba lo mismo (y son caracteres coreanos, no chinos).
Kevin Cruijssen
@KevinCruijssen Creo que también hay algunos caracteres chinos. De hecho, la especificación dice que usa Hangul para datos y chino para instrucciones.
Erik the Outgolfer
@EriktheOutgolfer Ah, de hecho tienes razón. Debería tener rtfm .. :)
Kevin Cruijssen
12

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.

Sp3000
fuente
Me encanta el truco que usaste para ejecutar el comando de impresión solo una vez. Eso es extremadamente inteligente.
Timwi
11

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í

Arnaud
fuente
1
¿Generaste esto con un programa? Por lo menos, el final puede ser 33cc, pero estoy seguro de que hay mejores maneras para algunos de los otros
Sp3000
@ Sp3000 sí, solo ejecuté un programa que probó varias combinaciones con ++. No he probado otros operadores ...
Arnaud
3
Otra nota: en lugar de en cctodas partes, hazlo ]]{{cc}}//al final
Sp3000
11

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.

mbomb007
fuente
¿No saldrá esto DDoo nnoott rreeppeeaatt yyoouurrsseellff!!(espacios dobles)? Veo dos .s.
Erik the Outgolfer
@EriktheGolfer Tiempo para que leas mi respuesta. Change first '.' to '0'. Cambié la explicación para mostrar (nuevamente) que el primero .se cambió a cero.
mbomb007
7

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.
Dennis
fuente
¿Por qué no competir?
justhalf
1
Debido a que Jelly se creó en diciembre de 2015, es posterior a este desafío por tres meses.
Dennis
Vaya, no me di cuenta de que este es un viejo desafío
solo el
5

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.

jimmy23013
fuente
5

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

nimi
fuente
5

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
Hactar
fuente
Puede guardar cuatro bytes utilizando un carácter no imprimible (punto de código 23) dentro de la cadena en lugar de 8f+: tio.run/nexus/…
Martin Ender
4

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!
yeti
fuente
3

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

>>  ^^
SuperJedi224
fuente
3

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

Jo King
fuente
2

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.

Conor O'Brien
fuente
Bounty termina en 5 días, @ConorOBrien, ¡espero que no te importe esperar! Pero la recompensa es tuya.
WallyWest
2

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.

Martin Ender
fuente
2

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.

Mugriento
fuente
1
Buena respuesta, ¡estoy impresionado de que pudieras apretar las cadenas del diccionario de esa manera! Desafortunadamente, áno se vectoriza en las cadenas internas, de lo contrario podría usarse después de ))... Eliminar todo áy usar εεáá}}después de los ))trabajos como alternativa, pero desafortunadamente no guarda ningún byte (pero ¿tal vez puedas encontrar inspiración en él? ) .. Y en „„!!lugar de ……!!trabajar también, ya que el !incorporado deja las cuerdas aparentemente igual. Ah bueno, lo intenté. xD
Kevin Cruijssen
1
@KevinCruijssen He estado tratando de refactorizar los repetidos ##θθáápor un tiempo, y por alguna razón no lo consideré εε}}... Lo intenté €€, lo que no funciona ... Esta es la respuesta más corta, ¡gracias!
Grimmy
1

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.

Khuldraeseth na'Barya
fuente