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.

Enlace de caja de arena

Perl 5 , 8 bytes (tamaño de fragmento 4)

$_*=~~+2

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~~+2analiza 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.

05AB1E , 4 bytes (tamaño de fragmento 2 o 4)

·Inr

Pruébelo en línea o duplique como un solo fragmento de 4 bytes o duplique como dos fragmentos de 2 bytes .

·        # double the implicit input
 In      # square the input
   r     # reverse the stack: it's now [input ** 2, input * 2]
         # if we stop here: implicitly output the top of the stack (input * 2)
·        # double the top of the stack (giving input * 4, not that it matters)
 In      # square the input
   r     # reverse the stack: it's now [input ** 2, input * 4, input ** 2]
         # implicitly the top of the stack (input ** 2)

Python 3 , 26 bytes (tamaño de fragmento 13)

lambda n:"and n*n#"and 2*n

Pruébalo en línea!

Doblado:

lambda n:"andlambda d:"and n*n#"and 2*n n*n#"and 2*n

Esta solución es proporcionada por @Grimy.

Python 3 , 32 30 28 bytes (tamaño de fragmento 16 15 14)

lambda n:bool(0)*n*n or  2*n

Pruébalo en línea!

-4 bytes gracias a @negativeSeven

Doblado:

lambda n:bool(lambda n:bool(0)*n*n or  2*n0)*n*n or  2*n

Pruébalo en línea!

La función aprovecha la única regla del fragmento de este desafío.

Befunge-98 (FBBI) , 8 bytes (longitud del fragmento 2)

;&:#* +q

Pruébalo en línea!

;&;&:#:#* * +q+q

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)

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

Hexagonía , 12 bytes (tamaño de fragmento 4)

?"2+...}=*!@

Pruébalo en línea!

Formateado:

  ? " 2
 + . . .
} = * ! @
 . . . .
  . . .

Y doblado , luego formateado:

   ? " 2 +
  ? " 2 + .
 . . } . . .
} = * ! @ = *
 ! @ . . . .
  . . . . .
   . . . .

Básicamente, esto establece el primer borde en la entrada, luego el segundo borde en una 2o una copia de la entrada, luego multiplica esos dos bordes en el tercer borde, imprime eso y termina. La lista de instrucciones ejecutadas son solo

?"2}=*!@

y

?"2+}=*!@

La única diferencia es +anular 2el segundo programa.

JavaScript (ES6),  24  22 bytes

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

+(g=x=>x*x)?g:(x=>x*2)

Pruébalo en línea!

+(g=x=>x*x)?g:(x=>x*2)+(g=x=>x*x)?g:(x=>x*2)

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

Perl 6 , 8 bytes (tamaño de fragmento 1)

* *<1 2>

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 ( **).

**  **<<11  22>>

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 solo 2(que se duplicaría 22), 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.

Encantamientos rúnicos , 9 bytes (tamaño de fragmento 3)

i3?:*@:+@

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 ejecutado i3?...:*@donde .representa las 3 instrucciones NOP'd. @es "imprimir toda la pila y terminar".

C # (compilador interactivo de Visual C #) / Javascript, 22 bytes, tamaño de fragmento 11

m=>/*      /2*m//*/m*2

Pruébalo en línea!

Brain-Flak , 48 30 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:

1. Duplicar TOS, cambiar pilas y comenzar a empujar un valor
2. Obtenga el número triangular de TOS n * (n-1) / 2
3. Pop TOS, cambiar pila y pop dos veces, luego empujar el resultado.

Para una entrada nen un programa no duplicado, esto resulta en:

1.  Start stack: n n
    Other stack: <
    Third stack: 
2.  Start stack: n n
    Other stack: 0 <
    Third stack: tri(0) = 0
3.  Start stack: n+n+tri(0) = 2n <
    Other stack:
    Third stack:

Para el programa duplicado:

1a. Start stack: n n
    Other stack: <
    Third stack: 
1b. Start stack: n n <
    Other stack: 0 0
    Third stack: 
2a. Start stack: n 0 <
    Other stack: 0 0
    Third stack: tri(n)
2b. Start stack: n 0 <
    Other stack: 0 0
    Third stack: tri(n)+tri(0) = tri(n)
3a. Start stack: n
    Other stack: tri(n) <
    Third stack: tri(n)
3a. Start stack: 0+n+tri(n)+tri(n) = n + 2*tri(n) = n + n*(n-1) = n*n <
    Other stack: 
    Third stack: 

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.

105 90 bytes, fragmentos de 15 bytes

(              {<><({}()())><><><            <>>({})({}[()])}{}            )<>            

Pruébalo en línea!

Doblado (con nuevas líneas para mayor claridad)

(              (              
{<><({}()())><>{<><({}()())><>
<><            <><            
<>>({})({}[()])<>>({})({}[()])
}{}            }{}            
)<>            )<>            

Pruébalo en línea!

Cubix , 18 14 bytes (longitud de fragmento 9 7)

*OI$|:/@O+:I. 

Tenga en cuenta el espacio final. Pruébalo en línea!

Doblado:

*OI$|:/*OI$|:/@O+:I. @O+:I. 

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.

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

Take Northern Line to Bank
Take District Line to Bank
Take District Line to Parsons Green
Take District Line to Bank
Take District Line to Hammersmith
Take Piccadilly Line to Russell Square
Take Piccadilly Line to Bounds Green
Take Piccadilly Line to Hammersmith
Take District Line to Upminster
Take District Line to Embankment
Take District Line to Hammersmith
Take District Line to Upminster
Take District Line to Acton Town
Take District Line to Acton Town
Take Piccadilly Line to Bounds Green
Take Piccadilly Line to Bounds Green
Take Piccadilly Line to Leicester Square
Take Northern Line to Leicester Square
Take Northern Line to Mornington Crescent

(La nueva línea final es importante)

¡Prueba la versión individual! ... o ... ¡ Prueba la versión duplicada!

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.

JavaScript (Node.js) , 15 12 bytes (tamaño del fragmento: 6)

x=>/**/2*(x)

Pruébalo en línea!

Caso único:

x=>/**/2*(x)

Doble caso:

x=>/**x=>/**/2*(x)/2*(x)

Parece que también funciona en C #, y Java si cambia =>a ->?

R , 42 35 28 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.

s =scan#
n=s()# 
  
n/2*4#  

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:

s =ss =scan#can#
n=s
n=s()# ()# 
  

  
n/2*n/2*4#  4#  

Pruébalo en línea!

La versión única calcula $\frac n2\times4=2n$; la versión doble calcula$\frac n2\times \frac n2\times4=n^2$.

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)

s =bbb=scan#
n=s(#
 
)# 
n* 1/ 2/ 1* 4#

Pruébalo en línea!

Doblado:

s =s =bbbbbb=sc=scan#an#
n=
n=s(#s(#
 

 
)# )# 
n*
n* 1/ 1/ 2/ 2/ 1* 1* 4# 4#

Pruébalo en línea!

Tenga en cuenta que Giuseppe tiene otra respuesta R, con un fragmento de 30 bytes.

R , 59 30 bytes (tamaño de fragmento 59 30)

F=F+1;f=function(n)n*c(2,n)[F]

Pruébalo en línea!

Gracias a Robin Ryder por inspirar esto; incrementa Fcada vez, y la función fselecciona 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.

PowerShell , 22 bytes (tamaño de fragmento 11)

param($p)
#   /
2 * $p

Pruébalo en línea .

Doblado:

param($p)
#param($p)
#   /
2 * $p   /
2 * $p

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)

param($p)$t=';$p*$p#';$p*2

Pruébalo en línea .

Doblado:

param($p)$t=';param($p)$t=';$p*$p#';$p*2$p*$p#';$p*2

Perl 5 ( -p), 22 15 bytes

-7 bytes gracias a Grimy

$_*=$'/4||2;//;

TIO

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

Python 3, 56 53 bytes

print(eval(input()+"**2"[len(*open(__file__))%2:])) #

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

Java 8, 62 bytes

n->n*(Byte.SIZE>8?n:2);/*
class Byte{static int SIZE=9;}/**///

Longitud del trozo 62.

Pruébelo en línea o pruébelo en línea duplicado .

Explicación:

n->                    // Method with integer as both parameter and return-type
  n*                   //  The input, multiplied by:
    (Byte.SIZE>8?      //   If Byte.SIZE is larger than 8:
      n                //    Multiply by the input itself
     :                 //   Else:
      2);              //    Multiply by 2
class Byte{            // Class which overwrites Byte
  static int SIZE=9;}  //  And sets the SIZE to 9

En Java, los comentarios disponibles son // commenty /* comment */. Que se combinan aquí para sobrescribir ciertas partes. Vea cómo funcionan estos comentarios gracias al resaltado de Java:

n->n*(Byte.SIZE>8?n:2);/*
class Byte{static int SIZE=9;}/**///

n->n*(Byte.SIZE>8?n:2);/*
class Byte{static int SIZE=9;}/**///n->n*(Byte.SIZE>8?n:2);/*
class Byte{static int SIZE=9;}/**///

El programa duplicado creó una Byteclase personalizada y su valor SIZE=9, que sobrescribe la java.lang.Byteclase predeterminada y su valor SIZE=8.

Japt , 7 5 bytes

*N²jJ

Pruébalo |Doblado

²empuja 2 a la matriz de entradas, Nluego jelimina y devuelve el elemento en el índice J=-1(es decir, el recién insertado2 ) y multiplica la entrada por eso.

Cuando se duplica, se Jmultiplica por 2, por lo que el elemento en el índice -2(es decir, la entrada) se devuelve jy se utiliza como multiplicador.

Gelatina , 8 6 bytes (longitud de fragmento 3)

Ḥ;²3ị 

Pruébalo en línea!

Doblado

Buena solución: Lua , 66 bytes (tamaño de fragmento 66 bytes)

a,x=a and...^2 or ...*2,setmetatable(x or{},{__gc=load'print(a)'})

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 aes bastante obvio para todos, mientras que la segunda parte xes 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)

a=a and...^2 or ...*2;                     print(a)os.exit()

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.

J , ^{15 10} 9 bytes

+: :(*-:)

Pruébalo en línea!

Versión duplicada: ¡ Pruébelo en línea!

f : gcrea un verbo que se ejecuta fcuando se llama con un argumento y gcuando 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 fse ejecuta como y 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 fy la entrada y. Entonces el gancho se f fejecuta así:

y f (f y)

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.

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.

0;  i=input;0;  p=print;n=i()#
x=int(n)##
z=2*x#z=x*x
p(z)##

Pruébalo en línea!

Doblado:

0;  i=0;  i=input;input;0;  p=0;  p=print;print;n=i()#n=i()#
x=int
x=int(n)##
(n)##
z=2*x#z=2*x#z=x*x
z=x*x
p(z)##p(z)##

Pruébalo en línea!

Cascada , 13 bytes (tamaño de fragmento 13)

]
&/2
#
*
 2&

Pruébalo en línea!

]
&/2
#
*
 2&]
&/2
#
*
 2&

¡Pruébalo doblado!

Esto fue bastante difícil. La esencia básica de esto es imprimir la entrada multiplicada por 2para el primer programa y reemplazar el2 por una copia de la entrada para el segundo.

Explicación:

La parte ejecutada del primer programa parece

]     Redirection
 /
#     Print
*     The multiplication of
 2&   Input and 2 (wrapping around the left)

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 en

]     Redirection
 /
#     Print
*     The multiplication of
 2 ]  Set the value of
& 2   The variable '2' to the input
      Then multiply the result of that (input) by '2' (input)

Zsh , 30 bytes (tamaño de fragmento 10)

m=$m[1]*2
x=$[$1$m]
return $x

Pruébalo en línea! ¡Pruébalo doblado!

Abusos el hecho de que $varen $[$var]obtiene expandieron primero, y luego evalúa en el contexto aritmética.

             # each line is 9 characters long. when doubled, each is run twice.
m=$m[1]*2    # first time: m='*2'   second time: $m[1] is '*', so m='**2'
x=$[$1$m]    # single: x=$[$1*2]    doubled: x=$[$1**2];x=$[$1**2].
return $x    # zsh supports 32-bit return values from functions, unlike bash

Si alguien quiere una grieta para reducir esto, esta es la 24/8solución más cercana que he obtenido (salidas x^2+2cuando se duplica)