Ha habido un par de desafíos que implican duplicar el código fuente: aquí y aquí . La tarea que tenemos aquí es un poco más difícil, pero debería ser posible en casi todos los idiomas.
En este desafío, tomarás un entero positivo arbitrario. Su programa debe generar ese número entero duplicado . Cuando su código fuente se duplica, tomará un entero positivo y lo generará al cuadrado .
¿Cómo se duplica su código fuente? Bueno, puedes hacerlo a tu manera . Es decir, se puede dividir el código fuente hasta en cadenas de bytes o caracteres (o fichas en langs tokenizados) de cualquier igual longitud que desee , y repetir cada trozo dos veces seguidas.
Para un programa inicial de ABCDEFGHIJKL
(longitud 12) aquí están todos los posibles programas duplicados:
Chunk length | Doubled source code
-------------+-------------------------
1 | AABBCCDDEEFFGGHHIIJJKKLL
2 | ABABCDCDEFEFGHGHIJIJKLKL
3 | ABCABCDEFDEFGHIGHIJKLJKL
4 | ABCDABCDEFGHEFGHIJKLIJKL
6 | ABCDEFABCDEFGHIJKLGHIJKL
12 | ABCDEFGHIJKLABCDEFGHIJKL
Tenga en cuenta que esto significa que los programas de longitudes principales solo se pueden duplicar de dos maneras: cada carácter se duplica o el programa completo se repite dos veces.
Reglas:
- El código debe ser un programa o función completa.
- Las lagunas estándar están prohibidas.
- Los métodos estándar de E / S están permitidos.
- Todos los caracteres / bytes, incluidos los espacios en blanco y las nuevas líneas, se cuentan en la longitud del código y contribuyen a los fragmentos.
- Usted puede asumir que la entrada y su plaza pueden ser representados por tipo int / número entero de su idioma.
- No puede asumir una nueva línea final u otro personaje.
- Proporcione el tamaño de su fragmento en el encabezado después del recuento de bytes.
- Este es el código de golf , ¡así que los programas más cortos son mejores! Si dos programas tienen la misma duración, gana el que usa la parte más pequeña. (Si tiene un programa más largo que usa una longitud de fragmento más pequeña, ¡también vale la pena publicarlo!)
- Si su programa requiere una segunda entrada / línea, no puede hacer suposiciones sobre su valor. En particular, su programa debería funcionar si la segunda entrada está vacía, igual que la primera o un número entero diferente. Si su programa no requiere una segunda entrada / línea, puede ignorar esta restricción.
fuente
.0
al final)?5 -> 10
; doble código:5 -> 25 25
.Respuestas:
Perl 5 , 8 bytes (tamaño de fragmento 4)
Pruébelo en línea o pruebe la versión duplicada .
Unario
~
es el negado bit a bit, por lo que aplicarlo dos veces es un noop. Por lo tanto, el programa base simplemente se multiplica$_
(la variable de entrada-salida implícita) por 2.Binary
~~
es smartmatch, que devuelve un valor booleano.~~+2~~+2
analiza como(~~+2) ~~ (+2)
. Como 2 es igual a 2, esto produce verdadero (1). Por lo tanto, el programa duplicado primero se multiplica$_
por 1, luego se multiplica$_
por sí mismo.fuente
05AB1E , 4 bytes (tamaño de fragmento 2 o 4)
Pruébelo en línea o duplique como un solo fragmento de 4 bytes o duplique como dos fragmentos de 2 bytes .
fuente
Python 3 , 26 bytes (tamaño de fragmento 13)
Pruébalo en línea!
Doblado:
Esta solución es proporcionada por @Grimy.
Python 3 ,
323028 bytes (tamaño de fragmento161514)Pruébalo en línea!
-4 bytes gracias a @negativeSeven
Doblado:
Pruébalo en línea!
La función aprovecha la única regla del fragmento de este desafío.
fuente
Befunge-98 (FBBI) , 8 bytes (longitud del fragmento 2)
Pruébalo en línea!
Pruébalo en línea! (duplicado)
Excluyendo el flujo de control, el primer programa se ejecuta
&:+q
(entrada, duplicar la parte superior de la pila, agregar, salir con el código de retorno), y el segundo se ejecuta&:*+q
(entrada, duplicar la parte superior de la pila, multiplicar, agregar (sumas con un 0 implícito), salir con el retorno código)fuente
Hexagonia , 14 bytes (tamaño de fragmento 14)
Expandido:
Pruébalo en línea!
Doblado
Expandido:
¡Pruébelo duplicado en línea!
Hexagony está en una posición un poco extraña en este desafío, ya que lograr la tarea no es mucho más difícil que simplemente poder escribir los dos programas individuales. Sin embargo, jugar al golf la solución resultó bastante difícil.
Esta solución es la idea trivial en la forma más corta que podría encajar, pero sospecho que hay respuestas más cortas e inteligentes. Esta versión establece ingenuamente dos valores en la entrada y los suma o los multiplica, dependiendo de si la fuente se duplica. La única reutilización de código es la
"+
que hace que el código de copia para el programa duplicado sea lo suficientemente corto como para caber en el espacio no utilizado del programa original.Sospecho que el uso de las instrucciones de cambio de IP
[]
facilitará el aislamiento de las partes, pero una solución realmente ideal reutilizará una gran cantidad de código entre las dos. Hice un programa auxiliar para duplicar el código fuente de hexagonía. Tenga en cuenta que elimina las no-operaciones finales, por lo que si desea tener no-opciones de marcador de posición al final, simplemente complete algún otro carácter y cámbielo nuevamente después. Puede manejar diferentes tamaños de fragmentos, aunque todavía no escribí código para generar cada programa posible (Hexagony parece prestarse para usar el tamaño de fragmento completo).fuente
Hexagonía , 12 bytes (tamaño de fragmento 4)
Pruébalo en línea!
Formateado:
Y doblado , luego formateado:
Básicamente, esto establece el primer borde en la entrada, luego el segundo borde en una
2
o una copia de la entrada, luego multiplica esos dos bordes en el tercer borde, imprime eso y termina. La lista de instrucciones ejecutadas son soloy
La única diferencia es
+
anular2
el segundo programa.fuente
JavaScript (ES6),
2422 bytesA pesar de su formato inusual, esta es la definición de una función anónima, que puede llamarse directamente o asignarse a una variable.
Pruébalo en línea!
¡Pruébelo en línea duplicado!
¿Cómo?
Aplicar el unario
+
a una función se interpreta como un intento de obligarlo a un número y da como resultado NaN . Por lo tanto, la guía+(g=x=>x*x)
es falsa en ambas versiones.Por otro lado, la aplicación del binario
+
entre 2 funciones da como resultado una cadena. Por lo tanto,(x=>x*2)+(g=x=>x*x)
es verdad en la versión duplicada.fuente
Perl 6 , 8 bytes (tamaño de fragmento 1)
Pruébalo en línea! ¡Pruébalo doblado!
Una lambda Whatever / HyperWhatever que toma un número y devuelve un número para el primer programa y una lista singleton para el segundo programa. Básicamente, esto mantiene exactamente la misma lógica, excepto que el operador de multiplicación (
*
) se reemplaza por el exponencial (**
).El literal
*
Everything (confusamente también representado por a ) se duplica a HyperWhatever (**
), que es básicamente el mismo, excepto que se asigna sobre listas. El espacio es necesario para separar el literal Lo que sea de la multiplicación y se ignora cuando se duplica. En lugar de solo2
(que se duplicaría22
), usamos una lista que contiene dos elementos, que se evalúa como 2 en un contexto numérico). Se<>
puede duplicar a una lista con interpolación, y los dos elementos dentro se duplican, pero ninguno de los dos cambia la longitud de la lista.fuente
Encantamientos rúnicos , 9 bytes (tamaño de fragmento 3)
Pruébalo en línea!
¡Pruébalo doblado!
El
3?
Omite los próximos 3 instrucciones, resultando en un (ejecutado)i3?...:+@
. Cuando se duplica da como resultado un ejecutadoi3?...:*@
donde.
representa las 3 instrucciones NOP'd.@
es "imprimir toda la pila y terminar".fuente
C # (compilador interactivo de Visual C #) / Javascript, 22 bytes, tamaño de fragmento 11
Pruébalo en línea!
fuente
=
a-
. ¡Buena respuesta!Brain-Flak ,
4830 bytes (tamaño de fragmento 10)Pruébalo en línea! ¡Pruébalo doblado!
Básicamente, esto lleva tres pasos, luego, cuando se duplica, ejecuta esos pasos dos veces cada uno. El programa inicial es:
Para una entrada
n
en un programa no duplicado, esto resulta en:Para el programa duplicado:
fuente
Brain-Flak , 76 bytes, fragmentos de 76 bytes
Pruébalo en línea!
Doblado (con nueva línea para mayor claridad)
Pruébalo en línea!
Aquí hay una versión que utiliza un procedimiento de duplicación más complejo. Tiene 5 fragmentos de tamaño 15. El código aquí es de 46 bytes, sin embargo, debido al relleno requerido, es sustancialmente más largo.
10590 bytes, fragmentos de 15 bytesPruébalo en línea!
Doblado (con nuevas líneas para mayor claridad)
Pruébalo en línea!
fuente
Cubix ,
1814 bytes (longitud de fragmento97)Tenga en cuenta el espacio final. Pruébalo en línea!
Doblado:
De nuevo, hay un espacio final. Pruébalo en línea!
Explicación
La idea principal es que duplicar el código hace que el cubo se haga más grande, por lo que el puntero de instrucción comienza en un símbolo diferente. Como el programa de adición no puede colocarse en un cubo de longitud lateral 1, la longitud lateral será 2. Además, el código duplicado debe estar en un cubo de longitud lateral 3, por lo que el código duplicado debe tener al menos 25 bytes. . Esto significa que el código debe tener al menos 13 bytes de longitud. Como tal, como máximo se puede guardar 1 byte más.
Ahora al código real. La primera observación es que el programa de adición no usa la cara superior (es decir, los primeros 4 caracteres). Además, si hacemos que el quinto carácter refleje la IP alrededor del cubo, podemos liberar 2 caracteres más. Utilizaremos estos personajes para poner el programa de cuadratura.
fuente
Mornington Crescent , 656 Bytes (tamaño de fragmento 328)
Solo para agregar peso a la teoría de que esto se puede resolver en casi cualquier idioma ...
(La nueva línea final es importante)
¡Prueba la versión individual! ... o ... ¡ Prueba la versión duplicada!
Este fue un desafío particularmente complicado en Mornington Crescent porque el programa debe tener una estructura tan rígida. También es importante observar dónde se produciría la duplicación, porque teletransportarse entre estaciones es ilegal en Londres.
La teoría aquí es simple: en la versión individual, 'Bounds Green' se llena con una cadena aleatoria, pero en la versión duplicada se llena con la entrada al cuadrado. Una vez que finaliza el fragmento, ambas versiones duplican la 'entrada', pero en la versión duplicada del código, la entrada ha sido reemplazada por 0.
Este resultado se devuelve a Bounds Green, que realiza una operación max () dos veces, antes de llevar el resultado a la salida. En la versión individual, esto deja la duplicación inalterada (el int y la cadena simplemente se cambian de un lado a otro), pero en la versión duplicada, esto reemplaza el 0 con el resultado cuadrado ya almacenado en Bounds Green.
Si mi explicación no fue lo suficientemente buena, le sugiero que visite Londres y pruebe las dos rutas usted mismo.
fuente
JavaScript (Node.js) ,
1512 bytes (tamaño del fragmento: 6)Pruébalo en línea!
Caso único:
Doble caso:
Parece que también funciona en C #, y Java si cambia
=>
a->
?fuente
R ,
423528 bytes (tamaño de fragmento 4)Ahora con un trozo más pequeño y sin error. También tengo una solución más larga con el tamaño de fragmento 3; vea abajo.
No creo que sea posible escribir una respuesta R con un tamaño de fragmento 1 o 2; Felizmente daré una recompensa a cualquiera que demuestre que estoy equivocado.
Pruébalo en línea!
los
#
es para comentarios en R. La tercera línea es solo espacios, haciendo un trozo de nueva línea + 2 espacios + nueva línea, de modo que el fragmento anterior y el siguiente no pueden tener nueva línea.Doblado, se convierte en:
Pruébalo en línea!
La versión única calculanorte2× 4 = 2 n ; la versión doble calculanorte2× n2× 4 = n2 .
Aquí hay una solución un poco más larga, pero con un tamaño de fragmento 3:
R , 39 bytes (tamaño de fragmento 3)
Pruébalo en línea!
Doblado:
Pruébalo en línea!
Tenga en cuenta que Giuseppe tiene otra respuesta R, con un fragmento de 30 bytes.
fuente
R ,
5930 bytes (tamaño de fragmento5930)Pruébalo en línea!
Gracias a Robin Ryder por inspirar esto; incrementa
F
cada vez, y la funciónf
selecciona la salida apropiada.Esto no es particularmente interesante, pero sin duda se inventará algo inteligente manipulando el tamaño del fragmento.Como se esperaba, a Robin Ryder se le ocurrió esto, que es más corto y tiene una buena manipulación de fragmentos.fuente
PowerShell , 22 bytes (tamaño de fragmento 11)
Pruébalo en línea .
Doblado:
Esta solución se basa en @ ShieruAsakoto's solución de .
Solución @Grimy que se ha convertido a PowerShell, 26 bytes (tamaño de fragmento 13)
Pruébalo en línea .
Doblado:
fuente
Perl 5 (
-p
),2215 bytes-7 bytes gracias a Grimy
TIO
fuente
$_*=/@F/?2:$_/4;
Carbón , 13 bytes
Pruébalo en línea! Explicación: La lista vacía predefinida es falsey, por lo que la entrada se multiplica por 2. Cuando se duplica la segunda pasada, la cadena vacía se ha empujado a la lista, por lo que multiplica la entrada por sí misma. Pruébalo en línea! En sintaxis detallada esto corresponde a
Multiprint(Cast(Times(Cast(q), Ternary(u, Cast(q), 2)))); Push(u, w);
.fuente
Python 3,
5653 bytesMis habilidades en Python son un poco malas, por lo que definitivamente se puede jugar al golf ... Según la respuesta de Python en el desafío " ¡ Doblo la fuente, doblas la salida! " .
Longitud del trozo 53.
Pruébelo en línea o pruébelo en línea duplicado .
fuente
Java 8, 62 bytes
Longitud del trozo 62.
Pruébelo en línea o pruébelo en línea duplicado .
Explicación:
En Java, los comentarios disponibles son
// comment
y/* comment */
. Que se combinan aquí para sobrescribir ciertas partes. Vea cómo funcionan estos comentarios gracias al resaltado de Java:El programa duplicado creó una
Byte
clase personalizada y su valorSIZE=9
, que sobrescribe lajava.lang.Byte
clase predeterminada y su valorSIZE=8
.fuente
Japt ,
75 bytesPruébalo |Doblado
²
empuja 2 a la matriz de entradas,N
luegoj
elimina y devuelve el elemento en el índiceJ=-1
(es decir, el recién insertado2
) y multiplica la entrada por eso.Cuando se duplica, se
J
multiplica por2
, por lo que el elemento en el índice-2
(es decir, la entrada) se devuelvej
y se utiliza como multiplicador.fuente
Gelatina ,
86 bytes (longitud de fragmento 3)Pruébalo en línea!
Doblado
fuente
Buena solución: Lua , 66 bytes (tamaño de fragmento 66 bytes)
Pruébalo en línea!(duplícalo tú mismo, no es tan difícil)
Ah, sí, estoy bastante seguro de que hay una solución más corta para esto, pero es lo mejor que se me ocurrió de esta manera. Tomar entrada como primer argumento.
Breve explicación: todo el negocio con
a
es bastante obvio para todos, mientras que la segunda partex
es más interesante. Básicamente, creo una tabla (o actualizo una existente en el segundo paso) con el finalizador (__gc
metametodo) que se llama cuando sale el programa.Solución poco convincente: Lua , 60 bytes (tamaño de fragmento 30 bytes)
Pruébalo en línea! o Pruébalo doblado!
Más pequeño y con mejor fragmentación, pero en última instancia aburrido y cojo sin ningún truco inteligente. Estoy bastante seguro de que no se requieren comentarios para este.
fuente
J ,
15109 bytesPruébalo en línea!
Versión duplicada: ¡ Pruébelo en línea!
f : g
crea un verbo que se ejecutaf
cuando se llama con un argumento yg
cuando se llama con 2 argumentos. Entonces el nuestro se ejecuta doble+:
con la fuente original y*-:
cuando la fuente se duplica.Esto funciona porque un tren de dos verbos en J se convierte en un gancho, y por lo tanto
f f
se ejecuta comoy f (f y)
donde y es la entrada original. Además,*-:
es en sí mismo un "gancho diádico" que funciona multiplicando*
el argumento izquierdo por la mitad-:
del argumento derecho. El argumento izquierdo será la entrada original, y el argumento derecho será la entrada duplicada, por lo que esto producirá el cuadrado de la entrada original.respuesta original
J , 15 bytes
Pruébalo en línea!
Versión duplicada: Pruébelo en línea!
En la versión única, tenemos un solo verbo que usa Agenda
@.
para hacer el if ... luego la lógica: si el argumento es igual a sí mismo=~
, entonces tome el argumento y duplíquelo(+:@[)
.Sin embargo, cuando duplicamos el código, obtenemos un gancho J. Llama al verbo
f
y la entraday
. Entonces el gancho sef f
ejecuta así:Lo que significa que ahora la entrada original es el argumento izquierdo, y el argumento derecho es la entrada duplicada. Dado que estos no serán iguales,
=~
esta vez devolverá falso, y ahora ejecutaremos la otra bifurcación de la Agenda, es decir*:@]
, que significa "al cuadrado el argumento correcto". Y dado que~
invierte las entradas de un verbo diádico, el argumento correcto será la entrada original.fuente
Python 3 , 60 bytes
Tamaño del fragmento 6.
No es una gran solución, pero funciona. Este es un desafío único, realmente te hace pensar desde una perspectiva diferente.
Pruébalo en línea!
Doblado:
Pruébalo en línea!
fuente
Cascada , 13 bytes (tamaño de fragmento 13)
Pruébalo en línea!
¡Pruébalo doblado!
Esto fue bastante difícil. La esencia básica de esto es imprimir la entrada multiplicada por
2
para el primer programa y reemplazar el2
por una copia de la entrada para el segundo.Explicación:
La parte ejecutada del primer programa parece
El programa duplicado básicamente agrega el primero
]
al final de la última línea, por lo que el programa se ajusta a eso en lugar de al&
. Esto lo convierte enfuente
Zsh , 30 bytes (tamaño de fragmento 10)
Pruébalo en línea! ¡Pruébalo doblado!
Abusos el hecho de que
$var
en$[$var]
obtiene expandieron primero, y luego evalúa en el contexto aritmética.Si alguien quiere una grieta para reducir esto, esta es la
24/8
solución más cercana que he obtenido (salidasx^2+2
cuando se duplica)fuente