Il y a eu quelques défis liés au doublement du code source: ici et ici . La tâche que nous avons ici est un peu plus difficile, mais devrait être réalisable dans presque toutes les langues.

Dans ce défi, vous prendrez un entier positif arbitraire. Votre programme doit sortir cet entier doublé . Lorsque votre code source est doublé, il prend un entier positif et le sort au carré .

Comment votre code source est-il doublé? Eh bien, vous pouvez l'avoir à votre guise . C'est - à - dire que vous pouvez diviser votre code source vers le haut dans les chaînes d'octets ou des caractères (ou jetons dans Langs lexicalisés) de toute égale longueur que vous voulez , et répéter chaque morceau deux fois de suite.

Pour un programme initial de ABCDEFGHIJKL, (longueur 12) voici tous les programmes doublés possibles:

Chunk length |   Doubled source code
-------------+-------------------------
           1 | AABBCCDDEEFFGGHHIIJJKKLL
           2 | ABABCDCDEFEFGHGHIJIJKLKL
           3 | ABCABCDEFDEFGHIGHIJKLJKL
           4 | ABCDABCDEFGHEFGHIJKLIJKL
           6 | ABCDEFABCDEFGHIJKLGHIJKL
          12 | ABCDEFGHIJKLABCDEFGHIJKL

Notez que cela signifie que les programmes de première longueur ne peuvent être doublés que de deux manières: chaque caractère est doublé ou le programme complet est répété deux fois.

Règles:

• Le code doit être un programme ou une fonction complète.
• Les failles standard sont interdites.
• Les méthodes d'E / S standard sont autorisées.
• Tous les caractères / octets, y compris les espaces et les sauts de ligne, sont comptés dans la longueur du code et contribuent aux morceaux.
• Vous pouvez supposer que l'entrée et son carré peuvent être représentés par le type int / entier de votre langue.
• Vous ne pouvez pas assumer un retour à la ligne ou un autre caractère.
• Indiquez votre taille de bloc dans l'en-tête après le nombre d'octets.
• C'est du golf de code , donc des programmes plus courts sont meilleurs! Si deux programmes ont la même longueur, celui qui utilise la plus petite longueur de morceau l'emporte. (Si vous avez un programme plus long qui utilise une plus petite longueur de morceau, cela vaut également la peine d'être publié!)
• Si votre programme nécessite une deuxième entrée / ligne, vous ne pouvez faire aucune hypothèse sur sa valeur. En particulier, votre programme devrait fonctionner si la deuxième entrée est vide, la même que la première, ou un entier différent. Si votre programme ne nécessite pas de deuxième entrée / ligne, vous pouvez ignorer cette restriction.

Lien Sandbox

Perl 5 , 8 octets (taille de bloc 4)

$_*=~~+2

Essayez-le en ligne ou essayez la version doublée .

Unaire ~est la négation au niveau du bit, donc l'appliquer deux fois est un noop. Ainsi, le programme de base multiplie simplement $_(la variable d'entrée-sortie implicite) par 2.

Le binaire ~~est smartmatch, qui renvoie un booléen. ~~+2~~+2analyse comme (~~+2) ~~ (+2). Puisque 2 est égal à 2, cela donne vrai (1). Ainsi, le programme doublé se multiplie d'abord $_par 1, puis se multiplie $_par lui-même.

05AB1E , 4 octets (taille de bloc 2 ou 4)

·Inr

Essayez-le en ligne ou doublé en un seul morceau de 4 octets ou doublé en deux morceaux de 2 octets .

·        # 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 octets (taille de bloc 13)

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

Essayez-le en ligne!

Doublé:

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

Cette solution est fournie par @Grimy.

Python 3 , 32 30 28 octets (taille de bloc 16 15 14)

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

Essayez-le en ligne!

-4 octets grâce à @negativeSeven

Doublé:

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

Essayez-le en ligne!

La fonction tire parti de la règle de bloc unique de ce défi.

Befunge-98 (FBBI) , 8 octets (longueur de bloc 2)

;&:#* +q

Essayez-le en ligne!

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

Essayez-le en ligne! (doublé)

À l'exclusion du flux de contrôle, le premier programme s'exécute &:+q(entrée, sommet de la pile en double, ajout, sortie avec code retour) et le second exécute &:*+q(entrée, haut de la pile en double, multiplication, ajout (sommes avec un 0 implicite), sortie avec retour code)

Hexagonie , 14 octets (taille de bloc 14)

?"+==*/}=+!@!<

Étendu:

  ? " +
 = = * /
} = + ! @
 ! < . .
  . . .

Essayez-le en ligne!

Doublé

?"+==*/}=+!@!<?"+==*/}=+!@!<

Étendu:

   ? " + =
  = * / } =
 + ! @ ! < ?
" + = = * / }
 = + ! @ ! <
  . . . . .
   . . . .

Essayez-le doublé en ligne!

L'hexagonie est dans une position un peu bizarre dans ce défi, en ce sens que la réalisation de la tâche n'est pas beaucoup plus difficile que de simplement écrire les deux programmes individuels. Cependant, jouer au golf avec la solution s'est avéré plutôt difficile.

Cette solution est l'idée triviale sous la forme la plus courte que je pourrais adapter, mais je soupçonne qu'il y a des réponses plus courtes et plus intelligentes. Cette version définit très naïvement deux valeurs à l'entrée et les additionne ou les multiplie, selon que la source est doublée. La seule réutilisation de code est celle "+qui rend le code de copie pour le programme doublé suffisamment court pour tenir dans l'espace inutilisé du programme d'origine.

Je soupçonne que l'utilisation des instructions de changement IP []facilitera l'isolement des pièces, mais une solution vraiment idéale réutilisera beaucoup de code entre les deux. J'ai créé un programme d'aide pour doubler le code source hexagone. Notez qu'il supprime les no-ops de fin, donc si vous voulez avoir des no-ops à la fin, remplissez simplement un autre caractère et changez-le après. Il peut gérer différentes tailles de morceaux, même si je n'ai pas encore écrit de code pour sortir chaque programme possible (Hexagony semble se prêter à l'utilisation de la taille complète des morceaux).

Hexagonie , 12 octets (taille de bloc 4)

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

Essayez-le en ligne!

Formaté:

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

Et doublé , puis formaté:

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

Fondamentalement, cela définit le premier bord à l'entrée, puis le deuxième bord à l'une 2ou à une copie de l'entrée, puis multiplie ces deux bords dans le troisième bord, imprime cela et se termine. La liste des instructions exécutées est juste

?"2}=*!@

et

?"2+}=*!@

La seule différence étant le +dépassement 2du deuxième programme.

JavaScript (ES6),  24  22 octets

Malgré son format inhabituel, il s'agit de la définition d'une fonction anonyme, qui peut être appelée directement ou affectée à une variable.

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

Essayez-le en ligne!

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

Essayez-le en ligne doublé!

Comment?

L'application de l'unaire +à une fonction est interprétée comme une tentative de la contraindre à un nombre et donne NaN . Par conséquent, le principal +(g=x=>x*x)est faux dans les deux versions.

Par contre, l'application du binaire +entre 2 fonctions donne une chaîne. Par conséquent, (x=>x*2)+(g=x=>x*x)est vrai dans la version doublée.

Perl 6 , 8 octets (taille de bloc 1)

* *<1 2>

Essayez-le en ligne! Essayez-le doublé!

Un lambda Whats / HyperWwhat qui prend un nombre et renvoie un nombre pour le premier programme et une liste singleton pour le deuxième programme. Fondamentalement, cela conserve la même logique exacte, sauf que l'opérateur de multiplication ( *) est remplacé par l' opérateur exponentiel ( **).

**  **<<11  22>>

Le littéral *Whats ( également confondu par a ) est doublé en un HyperWwhat ( **) qui est fondamentalement le même, sauf qu'il mappe sur des listes. L'espace est nécessaire pour séparer le littéral Quoi que ce soit de la multiplication et est ignoré lorsqu'il est doublé. Au lieu de simplement 2(ce qui serait doublé 22), nous utilisons une liste contenant deux éléments, qui est évaluée à 2 dans un contexte numérique). Le <>peut être doublé en une liste avec interpolation, et les deux éléments à l'intérieur sont doublés, mais aucun de ceux-ci ne modifie la longueur de la liste.

Enchantements runiques , 9 octets (taille de bloc 3)

i3?:*@:+@

Essayez-le en ligne!
Essayez-le doublé!

Le 3?saute les 3 instructions suivantes, ce qui donne un (exécuté) i3?...:+@. Lorsqu'il est doublé, il en résulte un exécuté i3?...:*@où .représente les 3 instructions NOP'd. @est "imprimer la pile entière et terminer".

C # (Visual C # Interactive Compiler) / Javascript, 22 octets, taille de bloc 11

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

Essayez-le en ligne!

Brain-Flak , 48 30 octets (taille de bloc 10)

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

Essayez-le en ligne! Essayez-le doublé!

Cela prend essentiellement trois étapes, puis lorsque doublé exécute ces étapes deux fois chacune. Le programme initial est le suivant:

1. Dupliquer TOS, changer de pile et commencer à pousser une valeur
2. Obtenez le numéro triangulaire du TOS n * (n-1) / 2
3. Pop TOS, changez de pile et pop deux fois, puis poussez le résultat.

Pour une entrée ndans un programme sans problème, cela se traduit par:

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:

Pour le programme doublé:

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 octets, morceaux de 76 octets

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

Essayez-le en ligne!

Doublé (avec une nouvelle ligne pour plus de clarté)

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

Essayez-le en ligne!

Voici une version qui utilise une procédure de doublage plus complexe. Il fait 5 morceaux de taille 15. Le code ici est de 46 octets mais en raison du remplissage requis, il est sensiblement plus long.

105 90 octets, morceaux de 15 octets

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

Essayez-le en ligne!

Doublé (avec de nouvelles lignes pour plus de clarté)

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

Essayez-le en ligne!

Cubix , 18 14 octets (longueur de bloc 9 7)

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

Notez l'espace de fin. Essayez-le en ligne!

Doublé:

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

Encore une fois, il y a un espace de fuite. Essayez-le en ligne!

Explication

L'idée principale est que le doublement du code augmente la taille du cube, de sorte que le pointeur d'instruction commence à un symbole différent. Étant donné que le programme d'addition ne peut pas être placé sur un cube de longueur latérale 1, la longueur latérale sera de 2. En outre, le code doublé doit être sur un cube de longueur latérale 3, donc le code doublé doit être d'au moins 25 octets. . Cela signifie que le code doit être d'au moins 13 octets. En tant que tel, au plus 1 octet de plus peut être enregistré.

Passons maintenant au code réel. La première observation est que la face supérieure (c'est-à-dire les 4 premiers caractères) n'est pas utilisée par le programme d'addition. De plus, si nous faisons en sorte que le 5ème caractère reflète l'IP autour du cube, nous pouvons libérer 2 caractères supplémentaires. Nous utiliserons ces caractères pour mettre le programme de quadrature.

Mornington Crescent , 656 octets (taille de bloc 328)

Juste pour ajouter du poids à la théorie selon laquelle cela peut être résolu dans presque toutes les langues ...

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 nouvelle ligne de fin est importante)

Essayez la version unique! ... ou ... Essayez la version doublée!

La théorie ici est simple: dans la version simple, «Bounds Green» est rempli avec une chaîne aléatoire, mais dans la version doublée, il est rempli avec l'entrée au carré. Une fois le bloc terminé, les deux versions doublent l '«entrée», mais dans la version doublée du code, l'entrée a été remplacée par 0.

Ce résultat est ramené à Bounds Green, qui effectue une opération max () deux fois, avant de prendre le résultat en sortie. Dans la version simple, cela laisse le doublage inchangé (l'int et la chaîne sont simplement commutés d'avant en arrière), mais dans la version doublée, cela remplace le 0 par le résultat au carré déjà stocké dans Bounds Green.

JavaScript (Node.js) , 15 12 octets (taille de bloc: 6)

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

Essayez-le en ligne!

Cas unique:

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

Double étui:

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

Semble également fonctionner en C # et en Java si vous passez =>à ->?

R , 42 35 28 octets (taille de bloc 4)

Maintenant avec un plus petit morceau et aucune erreur. J'ai également une solution plus longue avec la taille de bloc 3; voir ci-dessous.

Je ne pense pas qu'il soit possible d'écrire une réponse R avec une taille de bloc 1 ou 2; Je donnerai volontiers une prime à tous ceux qui me prouveront le contraire.

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

Essayez-le en ligne!

le # pour les commentaires dans R. La 3ème ligne est seulement des espaces, ce qui fait un bloc de retour à la ligne + 2 espaces + retour à la ligne, de sorte que le bloc précédent et suivant ne puisse pas avoir de retour à la ligne.

Doublé, il devient:

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

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

Essayez-le en ligne!

La version unique calcule $\frac n2\times4=2n$; la version double calcule$\frac n2\times \frac n2\times4=n^2$.

Voici une solution légèrement plus longue, mais avec une taille de bloc 3:

R , 39 octets (taille de bloc 3)

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

Essayez-le en ligne!

Doublé:

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

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

Essayez-le en ligne!

Notez que Giuseppe a une autre réponse R, avec un bloc de 30 octets.

R , 59 30 octets (taille de bloc 59 30)

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

Essayez-le en ligne!

Nous remercions Robin Ryder d' avoir inspiré cela; incrémente à Fchaque fois et la fonction fsélectionne la sortie appropriée.

Ce n'est pas particulièrement intéressant, mais sans doute quelque chose d'intelligent manipulant la taille des morceaux sera imaginé. Comme prévu, Robin Ryder est venu avec ce qui est à la fois plus court et a une certaine manipulation des morceaux.

PowerShell , 22 octets (taille de bloc 11)

param($p)
#   /
2 * $p

Essayez-le en ligne .

Doublé:

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

Cette solution est basée sur la solution de @ ShieruAsakoto .

Solution @Grimy qui a été convertie en PowerShell, 26 octets (taille de bloc 13)

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

Essayez-le en ligne .

Doublé:

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

Perl 5 ( -p), 22 15 octets

-7 octets grâce à Grimy

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

TIO

charbon , 13 octets

ＰＩ×Ｉθ⎇υＩθ²⊞υω

Essayez-le en ligne! Explication: La liste vide prédéfinie est falsey, donc l'entrée est multipliée par 2. Lorsqu'elle est doublée, la deuxième passe voit que la chaîne vide a été poussée dans la liste afin qu'elle multiplie l'entrée par elle-même à la place. Essayez-le en ligne! En syntaxe verbeuse, cela correspond à Multiprint(Cast(Times(Cast(q), Ternary(u, Cast(q), 2)))); Push(u, w);.

Python 3, 56 53 octets

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

Mes compétences en python sont un peu nulles, donc je peux certainement jouer au golf. Basé sur la réponse de Python dans le " je défi Je double la source, vous doublez la sortie! " .

Longueur de morceau 53.

Essayez-le en ligne ou essayez-le en ligne doublé .

Java 8, 62 octets

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

Longueur de morceau 62.

Essayez-le en ligne ou essayez-le en ligne doublé .

Explication:

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, les commentaires disponibles sont // commentet /* comment */. Qui sont combinés ici pour écraser certaines parties. Découvrez comment ces commentaires fonctionnent grâce à la mise en évidence 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;}/**///

Le programme doublé a créé une Byteclasse personnalisée et sa valeur SIZE=9, qui écrase la java.lang.Byteclasse par défaut et sa valeur SIZE=8.

Japt , 7 5 octets

*N²jJ

Essayez-le | Doublé

²pousse 2 dans le tableau des entrées, Npuis jsupprime et renvoie l'élément à l'index J=-1(c'est-à-dire le nouvel inséré 2) et multiplie l'entrée par cela.

Lorsqu'il est doublé, il Jest multiplié par 2, donc l'élément à l'index -2(c'est-à-dire l'entrée) est renvoyé par jet utilisé comme multiplicateur.

Gelée , 8 6 octets (longueur de morceau 3)

Ḥ;²3ị 

Essayez-le en ligne!

Doublé

Bonne solution: Lua , 66 octets (taille de bloc 66 octets)

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

Essayez-le en ligne! (doublez-le vous-même, ce n'est pas si difficile)

Oh oui, je suis sûr qu'il existe une solution plus courte à cela, mais c'est le mieux que j'ai pu trouver de cette façon. Prenez l'entrée comme premier argument.

Brève explication: toute l'entreprise avec aest assez évidente pour tout le monde, tandis que la deuxième partie avecx est plus intéressante. Fondamentalement, je crée un tableau (ou en mets à jour un existant lors du deuxième passage) avec le finaliseur (__gc métaméthode) qui est appelé lorsque le programme se termine.

Lame solution: Lua , 60 bytes (chunk size 30 bytes)

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

Essayez-le en ligne! ou Essayez-le doublé!

Plus petit et avec de meilleurs morceaux, mais finalement ennuyeux et boiteux sans astuces intelligentes. Je suis presque sûr qu'aucun commentaire n'est requis pour celui-ci.

J , ^{15 10} 9 octets

+: :(*-:)

Essayez-le en ligne!

Version doublée: essayez-la en ligne!

f : gcrée un verbe qui s'exécute florsqu'il est appelé avec un argument et glorsqu'il est appelé avec 2 arguments. Ainsi, la nôtre s'exécute en double +:avec la source d'origine et *-:lorsque la source est doublée.

Cela fonctionne car un train de deux verbes en J devient un crochet, et f fest donc exécuté comme y f (f y)où y est l'entrée d'origine. De plus, *-:est lui-même un "crochet dyadique" qui fonctionne en multipliant* l'argument de gauche par deux-: l'arg droit. L'argument de gauche sera l'entrée d'origine et l'argument de droite sera l'entrée doublée, ce qui produira le carré de l'entrée d'origine.

réponse originale

J , 15 octets

*:@]`(+:@])@.=~

Essayez-le en ligne!

Version doublée: essayez-la en ligne!

Dans la version unique, nous avons un seul verbe qui utilise Agenda @.pour faire la logique if ... then: Si l'argument est égal à lui =~- même , alors prenez l'argument et doublez-le(+:@[) .

Cependant, lorsque nous doublons le code, nous obtenons un crochet J. Appelez le verbe fet l'entrée y. Ensuite, le crochet f fs'exécute comme ceci:

y f (f y)

Ce qui signifie que maintenant l'entrée d'origine est l'argument de gauche et l'argument de droite est l'entrée doublée. Puisque ceux-ci ne seront pas égaux, =~retourneront faux cette fois-ci, et maintenant nous allons exécuter l'autre fork de l'Agenda, c'est-à-dire *:@], ce qui signifie "cadrer l'argument de droite". Et puisque ~inverse les entrées d'un verbe dyadique, l'argument de droite sera l'entrée d'origine.

Python 3 , 60 octets

Taille du morceau 6.
Pas une bonne solution, mais ça marche. C'est un défi tellement unique qu'il vous fait vraiment réfléchir sous un angle différent.

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

Essayez-le en ligne!

Doublé:

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

Essayez-le en ligne!

Cascade , 13 octets (taille de bloc 13)

]
&/2
#
*
 2&

Essayez-le en ligne!

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

Essayez-le doublé!

C'était assez difficile. L'essentiel de base est d'imprimer l'entrée multipliée par 2pour le premier programme, et de la remplacer 2par une copie de l'entrée pour le second.

Explication:

La partie exécutée du premier programme ressemble à

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

Le programme doublé ajoute essentiellement le premier ]à la fin de la dernière ligne, donc le programme s'enroule autour de cela au lieu de &. Cela en fait

]     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 octets (taille de bloc 10)

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

Essayez-le en ligne! Essayez-le doublé!

Abuse le fait que $varin $[$var]est développé en premier, puis évalué dans le contexte arithmétique.

             # 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 quelqu'un veut une fissure pour abaisser cela, voici le plus proche d'une 24/8solution que j'ai obtenue (les sorties x^2+2sont doublées)