Było kilka wyzwań związanych z podwojeniem kodu źródłowego: tu i tutaj . Zadanie, które tu mamy, jest nieco trudniejsze, ale powinno być wykonalne w prawie każdym języku.

W tym wyzwaniu przyjmiesz dowolną liczbę całkowitą dodatnią. Twój program musi podwoić liczbę całkowitą dwukrotnie . Kiedy kod źródłowy zostanie podwojony, przyjmie dodatnią liczbę całkowitą i wyśle ​​go do kwadratu .

Jak podwoić swój kod źródłowy? Cóż, możesz mieć to na swój sposób . Oznacza to, że możesz podzielić swój kod źródłowy na ciągi bajtów lub znaków (lub tokenów w tokenizowanych językach) o dowolnej żądanej długości i powtarzać każdą porcję dwa razy z rzędu.

W przypadku programu początkowego ABCDEFGHIJKL(długość 12) wszystkie możliwe programy podwojone:

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

Zauważ, że oznacza to, że programy liczb pierwszych można podwoić tylko na dwa sposoby: podwoić każdą postać lub cały program powtórzyć dwukrotnie.

Zasady:

• Kod musi być pełnym programem lub funkcją.
• Standardowe luki są zabronione.
• Standardowe metody we / wy są dozwolone.
• Wszystkie znaki / bajty, w tym białe znaki i znaki nowej linii, są liczone w długości kodu i przyczyniają się do fragmentów.
• Państwo może zakładać, że wejście i jej kwadrat może być reprezentowany przez typ int / całkowitej Twojego języka.
• Nie możesz zakładać końcowego znaku nowej linii lub innego znaku.
• Podaj wielkość porcji w nagłówku po liczbie bajtów.
• To jest golf golfowy , więc krótsze programy są lepsze! Jeśli dwa programy mają tę samą długość, wygrywa ten, który używa mniejszej długości porcji. (Jeśli masz dłuższy program, który używa mniejszej długości fragmentu, również warto go opublikować!)
• Jeśli twój program wymaga drugiego wejścia / linii, możesz nie przyjmować żadnych założeń co do jego wartości. W szczególności twój program powinien działać, jeśli drugie wejście jest puste, takie samo jak pierwsze lub inna liczba całkowita. Jeśli twój program nie wymaga drugiego wejścia / linii, możesz zignorować to ograniczenie.

Link do piaskownicy

Perl 5 , 8 bajtów (wielkość porcji 4)

$_*=~~+2

Wypróbuj online lub wypróbuj wersję podwójną .

Unary ~jest bitową negacją, więc dwukrotne zastosowanie jest noop. W ten sposób program podstawowy po prostu się mnoży$_ (niejawna zmienna wejścia-wyjścia) przez 2.

Binary ~~to smartmatch, który zwraca wartość logiczną. ~~+2~~+2parsuje jako (~~+2) ~~ (+2). Ponieważ 2 równa się 2, daje to wartość true (1). Zatem podwójny program najpierw mnoży się $_przez 1, a następnie mnoży $_się sam.

05AB1E , 4 bajty (wielkość porcji 2 lub 4)

·Inr

Wypróbuj online lub podwojony jako pojedynczy 4-bajtowy fragment lub podwojony jako dwa 2-bajtowe fragmenty .

·        # 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 bajtów (wielkość porcji 13)

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

Wypróbuj online!

Podwojony:

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

To rozwiązanie zapewnia @Grimy.

Python 3 , 32 30 28 bajtów (wielkość porcji 16 15 14)

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

Wypróbuj online!

-4 bajty dzięki @negativeSeven

Podwojony:

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

Wypróbuj online!

Funkcja wykorzystuje unikalną regułę dla tego wyzwania.

Befunge-98 (FBBI) , 8 bajtów (długość fragmentu 2)

;&:#* +q

Wypróbuj online!

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

Wypróbuj online! (podwojony)

Z wyłączeniem przepływu sterowania, pierwszy program wykonuje &:+q(wejście, zduplikowanie góry stosu, dodanie, wyjście z kodem powrotu), a drugi wykonuje &:*+q(wejście, zduplikowanie góry stosu, pomnożenie, dodanie (suma z niejawną wartością 0), wyjście ze znakiem powrotu kod)

Sześciokąt , 14 bajtów (wielkość porcji 14)

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

Rozszerzony:

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

Wypróbuj online!

Podwojony

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

Rozszerzony:

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

Wypróbuj podwojony online!

Sześciokąty znajdują się w nieco dziwnej pozycji w tym wyzwaniu, ponieważ faktyczne wykonanie zadania nie jest znacznie trudniejsze niż po prostu możliwość napisania dwóch pojedynczych programów. Gra w golfa okazała się jednak dość trudna.

To rozwiązanie jest trywialną ideą w najkrótszej formie, jaką mogłem zmieścić, ale podejrzewam, że istnieją krótsze, mądrzejsze odpowiedzi. Ta wersja bardzo naiwnie ustawia dwie wartości na wejściu i sumuje je lub mnoży, w zależności od tego, czy źródło zostanie podwojone. Jedynym ponownym użyciem kodu jest"+ co sprawia, że ​​kopiowanie kodu podwójnego programu jest wystarczająco krótkie, aby zmieściło się w nieużywanej przestrzeni z oryginalnego programu.

Podejrzewam, że użycie instrukcji zmiany adresu IP []ułatwi izolację części, ale naprawdę idealne rozwiązanie wykorzysta wiele kodu między nimi. Zrobiłem program pomocniczy do podwójnego heksagonalnego kodu źródłowego. Zauważ, że usuwa końcowe brakujące operacje, więc jeśli chcesz mieć zastępczy brak operacji na końcu, po prostu wpisz inną postać i zmień ją później. Może obsługiwać różne wielkości porcji, chociaż nie napisałem jeszcze kodu, aby wyprowadzać każdy możliwy program (Hexagony wydaje się nadawać do korzystania z pełnego rozmiaru porcji).

Sześciokąt , 12 bajtów (wielkość porcji 4)

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

Wypróbuj online!

Sformatowany:

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

I podwojony , a następnie sformatowany:

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

Zasadniczo ustawia to pierwszą krawędź na wejściu, a następnie drugą krawędź na jedną 2lub kopię danych wejściowych, a następnie mnoży te dwie krawędzie na trzeciej krawędzi, drukuje to i kończy. Lista wykonanych instrukcji jest tylko

?"2}=*!@

i

?"2+}=*!@

Jedyną różnicą jest +nadpisanie 2drugiego programu.

JavaScript (ES6),  24  22 bajtów

Mimo niezwykłego formatu jest to definicja funkcji anonimowej, którą można wywołać bezpośrednio lub przypisać do zmiennej.

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

Wypróbuj online!

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

Wypróbuj online dwukrotnie!

W jaki sposób?

Zastosowanie jedności +do funkcji jest interpretowane jako próba wymuszenia jej na liczbie i daje NaN . Dlatego +(g=x=>x*x)w obu wersjach wiodącym jest fałsz.

Z drugiej strony zastosowanie binarnego +między 2 funkcjami daje ciąg znaków. Dlatego (x=>x*2)+(g=x=>x*x)jest prawdą w wersji podwójnej.

Perl 6 , 8 bajtów (wielkość porcji 1)

* *<1 2>

Wypróbuj online! Spróbuj dwukrotnie!

Cokolwiek / HyperWhthing lambda, która pobiera liczbę i zwraca liczbę dla pierwszego programu oraz listę singletonów dla drugiego programu. Zasadniczo zachowuje to tę samą logikę, z tym wyjątkiem, że operator mnożenia ( *) jest zastępowany przez wykładniczy ( **).

**  **<<11  22>>

Cokolwiek dosłowne (myląco również reprezentowane przez a *) jest podwojone do HyperWhthing ( **), który jest w zasadzie taki sam, z wyjątkiem tego, że mapuje listy. Spacja jest potrzebna do oddzielenia literału „cokolwiek” od mnożenia i jest ignorowana, gdy zostanie podwojona. Zamiast po prostu 2(do którego byśmy się podwoili 22) używamy listy zawierającej dwa elementy, której wynikiem jest 2 w kontekście numerycznym). <>Może być podwojona do listy z interpolacją, a dwa elementy wewnątrz są podwojone, ale żadna z tych zmian długość listy.

Runiczne Zaklęcia , 9 bajtów (rozmiar 3)

i3?:*@:+@

Wypróbuj online!
Spróbuj dwukrotnie!

3?Pomija następne 3 instrukcji, w wyniku (wykonany) i3?...:+@. Po podwojeniu powoduje wykonanie, i3?...:*@gdzie .reprezentuje 3 instrukcje NOP. @to „wydrukuj cały stos i zakończ”.

C # (Visual C # Interactive Compiler) / JavaScript, 22 bajty, wielkość porcji 11

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

Wypróbuj online!

Brain-Flak , 48 30 bajtów (wielkość porcji 10)

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

Wypróbuj online! Spróbuj dwukrotnie!

Zasadniczo zajmuje to trzy kroki, a następnie po dwukrotnym wykonaniu tych kroków dwukrotnie. Program początkowy to:

1. Powiel TOS, zamień stosy i zacznij wypychać wartość
2. Uzyskaj trójkątną liczbę warunków N * (n-1) / 2
3. Pop TOS, przełącz stos i pop dwa razy, a następnie wypuść wynik.

W przypadku wejścia ndo niewątpliwego programu powoduje to:

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:

W przypadku programu podwójnego:

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 bajtów, 76 bajtów

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

Wypróbuj online!

Podwójny (z nową linią dla przejrzystości)

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

Wypróbuj online!

Oto wersja, która wykorzystuje bardziej złożoną procedurę dublowania. Robi 5 kawałków o rozmiarze 15. Kod ma tutaj 46 bajtów, jednak ze względu na wymagane wypełnienie jest znacznie dłuższy.

105 90 bajtów, 15 bajtów

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

Wypróbuj online!

Podwójny (z nowymi liniami dla przejrzystości)

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

Wypróbuj online!

Cubix , 18 14 bajtów (długość porcji 9 7)

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

Zwróć uwagę na spację końcową. Wypróbuj online!

Podwojony:

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

Znów jest jedna spacja. Wypróbuj online!

Wyjaśnienie

Główną ideą jest to, że podwojenie kodu powoduje, że kostka staje się większa, więc wskaźnik instrukcji zaczyna się od innego symbolu. Ponieważ programu dodatkowego nie można umieścić na kostce o długości boku 1, długość boku będzie wynosić 2. Dodatkowo, podwójny kod musi znajdować się na kostce o długości boku 3, więc podwójny kod musi mieć co najmniej 25 bajtów . Oznacza to, że kod musi mieć co najmniej 13 bajtów. W związku z tym można zapisać maksymalnie 1 bajt.

Teraz do faktycznego kodu. Pierwszą obserwacją jest to, że górna ściana (tzn. Pierwsze 4 znaki) nie są używane przez program dodatkowy. Ponadto, jeśli sprawimy, że piąty znak będzie odzwierciedlał adres IP wokół sześcianu, możemy zwolnić jeszcze 2 znaki. Użyjemy tych znaków, aby umieścić program do kwadratu.

Mornington Crescent , 656 bajtów (rozmiar 328)

Żeby dodać wagę teorii, że można to rozwiązać w prawie każdym języku ...

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

(Ostatni znak nowej linii jest ważny)

Wypróbuj pojedynczą wersję! ... lub ... Wypróbuj wersję podwójną!

Teoria jest tutaj prosta: w wersji pojedynczej „Bounds Green” jest wypełniony losowym ciągiem znaków, ale w wersji podwójnej jest wypełniony kwadratowym wejściem. Po zakończeniu porcji obie wersje podwoją „wejście”, ale w podwójnej wersji kodu dane wejściowe zostały zastąpione przez 0.

Ten wynik jest przenoszony z powrotem do Bounds Green, który dwukrotnie wykonuje operację max (), zanim przejdzie do wyniku. W wersji pojedynczej pozostawia to podwojenie niezmienione (int i łańcuch są właśnie przełączane tam iz powrotem), ale w wersji podwójnej zastępuje 0 z kwadratem wyniku zapisanym już w Bounds Green.

JavaScript (Node.js) , 15 12 bajtów (wielkość porcji: 6)

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

Wypróbuj online!

Pojedyncza skrzynka:

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

Podwójna skrzynka:

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

Wydaje się działać również w C # i Java, jeśli zmieniasz =>na ->?

R , 42 35 28 bajtów (wielkość porcji 4)

Teraz z mniejszą porcją i bez błędu. Mam też dłuższe rozwiązanie z rozmiarem 3; patrz poniżej.

Nie sądzę, że można napisać odpowiedź R z porcją wielkości 1 lub 2; Z radością dam nagrodę każdemu, kto udowodni, że się mylę.

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

Wypróbuj online!

Dotyczy #komentarzy w R. Trzecia linia to tylko spacje, tworząc fragment nowej linii + 2 spacje + nowa linia, tak że poprzednia i następna część nie może mieć nowej linii.

Podwojony staje się:

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

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

Wypróbuj online!

Jedna wersja oblicza $\frac n2\times4=2n$; oblicza się podwójna wersja$\frac n2\times \frac n2\times4=n^2$.

Oto nieco dłuższe rozwiązanie, ale z rozmiarem 3:

R , 39 bajtów (wielkość porcji 3)

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

Wypróbuj online!

Podwojony:

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

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

Wypróbuj online!

Zauważ, że Giuseppe ma inną odpowiedź R, z jednym kawałkiem 30 bajtów.

R , 59 30 bajtów (wielkość porcji 59 30)

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

Wypróbuj online!

Podziękowania dla Robina Rydera za inspirację; zwiększa za Fkażdym razem, a funkcja fwybiera odpowiednie wyjście.

Nie jest to szczególnie interesujące, ale niewątpliwie wymyśli się coś sprytnego, manipulującego rozmiarem. Zgodnie z oczekiwaniami, Robin Ryder wymyślił to, co jest zarówno krótsze, jak i ma porządną manipulację kawałkami.

PowerShell , 22 bajty (wielkość porcji 11)

param($p)
#   /
2 * $p

Wypróbuj online .

Podwojony:

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

To rozwiązanie jest oparte na rozwiązaniu @ ShieruAsakoto .

@Grimy rozwiązanie, które zostało przekonwertowane na PowerShell, 26 bajtów (wielkość porcji 13)

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

Wypróbuj online .

Podwojony:

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

Perl 5 ( -p), 22 15 bajtów

-7 bajtów dzięki Grimy

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

TIO

Węgiel drzewny , 13 bajtów

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

Try it online! Explanation: The predefined empty list is falsey so the input is multiplied by 2. When doubled the second pass sees the empty string has been pushed to the list so it multiplies the input by itself instead. Try it online! In verbose syntax this corresponds to 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:])) #

My python skills kinda suck, so can definitely be golfed.. Based on the Python answer in the "I double the source, you double the output!" challenge.

Chunk length 53.

Try it online or try it online doubled.

Java 8, 62 bytes

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

Chunk length 62.

Try it online or try it online doubled.

Explanation:

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

In Java, the available comments are // comment and /* comment */. Which are combined here to overwrite certain parts. See how these comments work thanks to the Java highlighting:

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;}/**///

The doubled program created a custom Byte class and its value SIZE=9, which overwrites the default java.lang.Byte class and its value SIZE=8.

Japt, 7 5 bytes

*N²jJ

Try it | Doubled

² pushes 2 to the array of inputs N then j removes & returns the element at index J=-1 (i.e., the newly inserted 2) and multiplies the input by that.

When doubled it results in J being multiplied by 2, so the element at index -2 (i.e., the input) is returned by j and used as the multiplier.

Jelly, 8 6 bytes (chunk length 3)

Ḥ;²3ị 

Try it online!

Doubled

Nice solution: Lua, 66 bytes (chunk size 66 bytes)

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

Try it online! (double it yourself, it is not so hard)

Oh yeah, pretty sure that there is shorter solution to this, but it's the best I was able to came up with this way. Take input as first argument.

Brief explanation: whole business with a is quite obvious for everyone, while the second part with x is more interesting. Basically, I create a table (or update existing one on second pass) with finalizer (__gc metamethod) which gets called when program exits.

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

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

Try it online! or Try it doubled!

Smaller and with better chunking, but ultimately boring and lame without any clever tricks. I'm pretty sure no comments are required to this one.

J, ^{15 10} 9 bytes

+: :(*-:)

Try it online!

Doubled version: Try it online!

f : g creates a verb that executes f when called with one argument, and g when called with 2 arguments. So ours executes double +: with the original source and *-: when the source is doubled.

This works because a train of two verbs in J becomes a hook, and thus f f is executed as y f (f y) where y is the original input. Additionally, *-: is itself a "dyadic hook" which works by multiplying * the left arg by half -: the right arg. The left arg will be the original input, and the right arg will be the input doubled, so this will produce the square of the original input.

original answer

J, 15 bytes

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

Try it online!

Doubled version: Try it online!

In the single version, we have a single verb which uses Agenda @. to do the if... then logic: If the argument is equal to itself =~, then take the argument and double it (+:@[).

However, when we double the code, we get a J hook. Call the verb f and the input y. Then the hook f f executes like this:

y f (f y)

Which means that now the original input is the left arg, and the right arg is the doubled input. Since these will not be equal, =~ will return false this time, and now we'll execute the other fork of the Agenda, ie, *:@], which means "square the right arg." And since ~ reverses the inputs of a dyadic verb, the right arg will be the original input.

Python 3, 60 bytes

Chunk size 6.
Not a great solution, but it works. This is such a unique challenge, it really makes you think from a different perspective.

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

Try it online!

Doubled:

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

Try it online!

Cascade, 13 bytes (chunk size 13)

]
&/2
#
*
 2&

Try it online!

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

Try it doubled!

This was quite difficult. The basic gist of this is to print the input multiplied by 2 for the first program, and replace the 2 by a copy of the input for the second.

Explanation:

The executed part of the first program looks like

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

The doubled program basically adds the first ] to the end of the last line, so the program wraps around to that instead of the &. This turns it into

]     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 (chunk size 10)

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

Try it online! Try it doubled!

Abuses the fact that $var in $[$var] gets expanded first, then evaluated in the arithmetic context.

             # 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

If anyone wants a crack at lowering this, here's the closest to a 24/8 solution I've gotten (outputs x^2+2 when doubled)