Було кілька проблем, пов'язаних із подвоєнням вихідного коду: тут і тут . Завдання, яке ми маємо тут, трохи складніше, але воно повинно бути виконане майже на всіх мовах.

У цьому виклику ви візьмете довільне додатне ціле число. Ваша програма повинна вивести це ціле число вдвічі . Коли ваш вихідний код збільшиться удвічі, він візьме додатне ціле число та виведе його у квадрат .

Як ваш вихідний код подвоїться? Ну, ви можете мати це по-своєму . Тобто, ви можете розділити ваш вихідний код до в рядки байт або символів (або жетони в токенізірованной LANGS) з будь-якої рівної довжини ви хочете , і повторювати кожен шматок в два раз підряду.

Для початкової програми ABCDEFGHIJKL(довжина 12) тут є всі можливі подвоєні програми:

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

Зауважте, що це означає, що програми простих розмірів можна подвоїти лише двома способами: кожен символ подвоюється або повна програма повторюється двічі.

Правила:

• Код повинен бути повноцінною програмою або функцією.
• Стандартні лазівки заборонені.
• Дозволені стандартні методи вводу / виводу.
• Усі символи / байти, включаючи пробіли та нові рядки, підраховуються за довжиною коду та вносять у груди фрагменти.
• Ви можете припустити, що введення та його квадрат можуть бути представлені типом int / integer вашої мови.
• Ви не можете припустити, що є новим рядком чи іншим символом.
• Укажіть розмір вашої частини в заголовку після підрахунку байтів.
• Це код-гольф , тому кращі програми краще! Якщо дві програми однакової довжини, виграє та, яка використовує меншу довжину шматка. (Якщо у вас є довша програма, яка використовує меншу довжину шматка, то це теж варто опублікувати!)
• Якщо вашій програмі потрібен другий вхід / рядок, ви можете не робити припущень щодо її значення. Зокрема, ваша програма повинна працювати, якщо другий вхід порожній, такий же, як перший або інше ціле число. Якщо вашій програмі не потрібен другий вхід / рядок, ви можете проігнорувати це обмеження.

Посилання в пісочниці

Perl 5 , 8 байт (розмір шматка 4)

$_*=~~+2

Спробуйте в Інтернеті або спробуйте подвоєну версію .

Унарна ~є побітним запереченням, тому застосовувати її двічі - це сопілка. Таким чином, базова програма просто множиться $_(неявна змінна вхід-вихід) на 2.

Бінарний ~~- це smartmatch, який повертає булеву форму. ~~+2~~+2розбирає як (~~+2) ~~ (+2). Оскільки 2 дорівнює 2, це дає істину (1). Таким чином, подвоєна програма спочатку множується $_на 1, потім множується $_сама.

05AB1E , 4 байти (розмір шматка 2 або 4)

·Inr

Спробуйте в Інтернеті або подвійно, як один 4-байтний фрагмент або подвійний, як два 2-байтних шматки .

·        # 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 байт (розмір шматка 13)

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

Спробуйте в Інтернеті!

Удвічі:

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

Це рішення надає @Grimy.

Python 3 , 32 30 28 байт (розмір шматка 16 15 14)

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

Спробуйте в Інтернеті!

-4 байти завдяки @negativeSeven

Удвічі:

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

Спробуйте в Інтернеті!

Функція використовує унікальне правило цього завдання.

Befunge-98 (FBBI) , 8 байт (довжина шматка 2)

;&:#* +q

Спробуйте в Інтернеті!

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

Спробуйте в Інтернеті! (удвічі)

Виключаючи потік управління, перша програма виконує &:+q(введення, дублювання верхньої частини стека, додавання, вихід із поверненням коду), а друга виконує &:*+q(введення, дублювання верхньої частини стека, множення, додавання (сум з неявним 0), вихід із поверненням код)

Шестикутник , 14 байт (розмір шматка 14)

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

Розширено:

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

Спробуйте в Інтернеті!

Удвічі

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

Розширено:

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

Спробуйте подвоїти онлайн!

У цьому виклику "Гексагонія" трохи дивна, адже реально досягти завдання не набагато складніше, ніж просто вміти писати дві окремі програми. Однак рішення для гольфу виявилося досить важким.

Це рішення є тривіальною ідеєю у найкоротшій формі, до якої я міг би підходити, але я підозрюю, що є більш короткі, розумніші відповіді. Ця версія дуже наївно встановлює два значення на вхід і підсумовує їх або множує їх, залежно від того, чи джерело подвоєне. Єдине повторне використання коду - це те, "+що робить код копії для подвоєної програми достатньо коротким, щоб вміститися у невикористаному просторі з вихідної програми.

Я підозрюю, що використання інструкцій щодо зміни IP []полегшить ізоляцію деталей, але справді ідеальне рішення дозволить повторно використовувати багато коду між ними. Я зробив програму- помічник, щоб подвоїти вихідний код із шестикутником. Зауважте, що він видаляє затримку відключення, тому, якщо ви хочете, щоб в кінці не було заповнення заповнювача, просто заповніть якийсь інший символ і змініть його після цього. Він може працювати з різними розмірами шматка, хоча я ще не писав код для виведення кожної можливої ​​програми (здається, що Hexagony піддається використанню повного розміру шматка).

Шестикутник , 12 байт (розмір шматка 4)

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

Спробуйте в Інтернеті!

Відформатовано:

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

І подвоївся , а потім відформатував:

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

В основному, це встановлює перший край на вхід, потім другий край до 2або копії вводу, потім примножує ці два ребра на третій край, друкує це і закінчується. Список виконаних інструкцій справедливий

?"2}=*!@

і

?"2+}=*!@

З тією лише різницею, що +перевищує 2значення другої програми.

JavaScript (ES6),  24  22 байти

Незважаючи на незвичний формат, це визначення анонімної функції, яку можна або викликати безпосередньо, або призначити змінній.

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

Спробуйте в Інтернеті!

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

Спробуйте його вдвічі!

Як?

Застосування унарної +до функції трактується як спроба примусити її до числа і приводить до NaN . Тому лідером +(g=x=>x*x)є хибність в обох версіях.

З іншого боку, застосування двійкового +між двома функціями призводить до рядка. Таким чином, (x=>x*2)+(g=x=>x*x)є truthy у подвоєному варіанті.

Perl 6 , 8 байт (розмір шматка 1)

* *<1 2>

Спробуйте в Інтернеті! Спробуйте вдвічі!

Що б там не було / HyperWever лямбда, яка приймає число і повертає номер для першої програми та однотонний список для другої програми. В основному це зберігає абсолютно таку ж логіку, за винятком того, що оператор множення ( *) замінюється експоненціальним ( **).

**  **<<11  22>>

Що б то не було буквальне (заплутане також представлене a *), подвоюється до HyperWever ( **), який в основному такий же, за винятком того, що він відображає список. Простір необхідний для відокремлення Будь-якого буквального від множення і ігнорується при подвоєнні. Замість того, щоб просто 2(який би подвоївся 22), ми використовуємо список, що містить два елементи, який у числовому контексті оцінює до 2). <>Може бути подвоєні до списку з інтерполяцією, а також два елементи всередині подвоюється, але ні один з цих змін довжини списку.

Руні чари , 9 байт (розмір шматка 3)

i3?:*@:+@

Спробуйте в Інтернеті!
Спробуйте вдвічі!

3?Пропускає наступні 3 інструкції, в результаті чого (виконується) i3?...:+@. При подвоєнні це призводить до виконання, i3?...:*@де .представлено 3 інструкції NOP'd. @є "надрукувати весь стек і завершити".

C # (Visual C # Interactive Compiler) / Javascript, 22 байти, розмір 11

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

Спробуйте в Інтернеті!

Мозок-Флак , 48 30 байт (розмір шматка 10)

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

Спробуйте в Інтернеті! Спробуйте вдвічі!

Це, в основному, три кроки, а тоді, коли вдвічі виконує ці дії двічі кожен. Початкова програма:

1. Скопіюйте TOS, переключіть стеки та почніть натискати значення
2. Отримайте трикутне число TOS n * (n-1) / 2
3. Поп TOS, перемикайте стек та двічі, а потім натисніть результат.

Для введення nв недіючу програму це призводить до:

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:

Для подвоєної програми:

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: 

Брейн-Флак , 76 байт, 76 байт шматки

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

Спробуйте в Інтернеті!

Удвічі (з новою лінією для наочності)

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

Спробуйте в Інтернеті!

Ось версія, яка використовує більш складну процедуру подвоєння. Він робить 5 шматочків розміром 15. Код тут - 46 байт, однак завдяки необхідній прокладці він значно довший.

105 90 байт, 15 байтних фрагментів

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

Спробуйте в Інтернеті!

Удвічі (з новими рядками для наочності)

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

Спробуйте в Інтернеті!

Cubix , 18 14 байт (довжина шматка 9 7)

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

Зверніть увагу на пробіл. Спробуйте в Інтернеті!

Удвічі:

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

Знову є один простір. Спробуйте в Інтернеті!

Пояснення

Основна ідея полягає в тому, що подвоєння коду призводить до того, що куб стає більшим, тому вказівник інструкції починається з іншого символу. Оскільки програма додавання не може бути поміщена на куб довжиною сторони 1, довжина сторони буде дорівнює 2. Крім того, подвоєний код повинен бути на кубі бічної довжини 3, тому подвоєний код повинен бути не менше 25 байт . Це означає, що код повинен бути не менше 13 байт. Таким чином, можна зберегти не більше ніж 1 байт.

Тепер до фактичного коду. Перше спостереження полягає в тому, що верхня грань (тобто перші 4 символи) не використовується програмою додавання. Крім того, якщо ми зробимо п'ятий символ відображенням IP навколо куба, ми можемо звільнити ще 2 символи. Ми будемо використовувати ці символи для розміщення програми квадратування.

Півмісяць Морнінгтон , 656 байт (розмір шматка 328)

Просто, щоб додати ваги теорії, що це можна вирішити майже будь-якою мовою ...

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

(Новий рядок важливий)

Спробуйте єдину версію! ... або ... Спробуйте подвоєну версію!

Теорія тут проста: У єдиній версії 'Bounds Green' заповнюється випадковим рядком, але у подвоєній версії він заповнюється введенням у квадрат. Після того, як фрагмент закінчується, обидві версії подвоюють "введення", але в подвоєній версії коду введення було замінено на 0.

Цей результат повертається до Bounds Green, який виконує макс () операцію двічі, перш ніж вивести результат на вихід. У єдиній версії це залишає подвоєння незмінним (int і string просто перемикаються вперед і назад), але в подвоєній версії це замінює 0 на результат у квадраті, який вже зберігається в Bounds Green.

JavaScript (Node.js) , 15 12 байт (розмір шматка: 6)

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

Спробуйте в Інтернеті!

Одиничний випадок:

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

Подвійний чохол:

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

Здається, він також працює в C # і Java, якщо зміниться =>на ->?

R , 42 35 28 байт (розмір шматка 4)

Тепер з меншим куском і без помилок. У мене також є довший розчин з розміром 3; Дивись нижче.

Я не думаю, що можна написати відповідь на R розміром з розміром 1 або 2; Я із задоволенням дарую винагороду тому, хто докаже мені неправильність.

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

Спробуйте в Інтернеті!

Примітка #для коментарів у Р. Третій рядок - це лише пробіли, створюючи шматок нового рядка + 2 пробіли + новий рядок, так що попередній та наступний фрагменти не можуть мати нового рядка.

Удвічі він стає:

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

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

Спробуйте в Інтернеті!

$\frac n2\times4=2n$$\frac n2\times \frac n2\times4=n^2$

Ось трохи довше рішення, але з розміром 3:

R , 39 байт (розмір шматка 3)

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

Спробуйте в Інтернеті!

Удвічі:

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

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

Спробуйте в Інтернеті!

Зауважте, що у Джузеппе є ще одна відповідь R, один шматок - 30 байт.

R , 59 30 байт (розмір шматка 59 30)

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

Спробуйте в Інтернеті!

Подяка Робіну Райдер за натхнення на це; з Fкожним кроком , і функція fвибирає відповідний вихід.

Це не особливо цікаво, але, безсумнівно, придумається щось розумне, що маніпулює розміром шматка. Як і очікувалося, Робін Райдер придумав це, що і коротше, і має деякі акуратні маніпуляції.

PowerShell , 22 байти (розмір шматка 11)

param($p)
#   /
2 * $p

Спробуйте в Інтернеті .

Удвічі:

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

Це рішення засноване на @ ShieruAsakoto в розчині .

@Grimy рішення , яке було перетворено на PowerShell, 26 байт (розмір шматка 13)

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

Спробуйте в Інтернеті .

Удвічі:

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

Perl 5 ( -p), 22 15 байт

-7 байт завдяки Гримі

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

ТІО

Вугілля деревне , 13 байт

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

Спробуйте в Інтернеті! Пояснення: Заздалегідь заданий порожній список є фальсієм, тому вхід множиться на 2. При подвоєнні другого проходу бачить, що порожній рядок був висунутий до списку, тож він замість цього вмножує сам вхід. Спробуйте в Інтернеті! У багатослівному синтаксисі це відповідає Multiprint(Cast(Times(Cast(q), Ternary(u, Cast(q), 2)))); Push(u, w);.

Python 3, 56 53 байти

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

Мій пітон навички свого роду смоктати, так що, безумовно , може бути golfed .. На підставі відповіді Python в « Я подвоєнні джерела, ви подвоїти вихід! » Виклик .

Довжина шматка 53.

Спробуйте в Інтернеті або спробуйте вдвічі .

Java 8, 62 байти

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

Довжина шматка 62.

Спробуйте в Інтернеті або спробуйте вдвічі .

Пояснення:

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

На Java доступними коментарями є // commentі /* comment */. Які поєднуються тут, щоб перезаписати певні частини. Подивіться, як працюють ці коментарі завдяки виділенню 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;}/**///

Подвоєна програма створила спеціальний Byteклас та його значення SIZE=9, яке перезаписує java.lang.Byteклас за замовчуванням та його значення SIZE=8.

Japt , 7 5 байт

*N²jJ

Спробуйте | Удвічі

²натискає 2 на масив входів, Nпотім jвидаляє та повертає елемент у індекс J=-1(тобто, щойно вставлений 2) та помножує введення на це.

При подвоєнні це призводить до J множення на 2, тому елемент в індексі -2(тобто вхід) повертається jі використовується як множник.

Желе , 8 6 байт (довжина шматка 3)

Ḥ;²3ị 

Спробуйте в Інтернеті!

Удвічі

Чудове рішення: Луа , 66 байт (розмір шматка 66 байт)

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

Спробуйте в Інтернеті!(подвоїти це самостійно, це не так складно)

О так, майже впевнений, що для цього є коротше рішення, але це найкраще, що мені вдалося придумати. Візьміть дані як перший аргумент.

Коротке пояснення: весь бізнес з aцілком очевидний для всіх, а друга частина з x- більш цікава. В основному я створюю таблицю (або __gcоновлюю існуючу на другому проході) фіналізатором ( метаметодом), який викликається, коли програма закінчується.

Кульгаве рішення: Луа , 60 байт (розмір шматка 30 байт)

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

Спробуйте в Інтернеті! або Спробуйте подвоїти!

Менший і з кращим набором, але в кінцевому підсумку нудний і кульгавий без будь-яких хитромудрих хитрощів. Я впевнений, що коментарів до цього не потрібно.

J , ^{15 10} 9 байт

+: :(*-:)

Спробуйте в Інтернеті!

Подвійна версія: Спробуйте в Інтернеті!

f : gстворює дієслово, яке виконує, fколи викликається одним аргументом, а gколи викликається з 2 аргументами. Тож наш виконує подвійний+: з початковим джерелом і *-:коли джерело подвоєне.

Це працює, тому що поїзд з двох дієслів у J стає гачком, і таким чином f fвиконується так, y f (f y)де y - вихідний ввід. Додатково, *-:сам по собі є "діадичним гаком", який працює шляхом множення *лівого аргументу на половину-: правого аргументу. Лівий аргумент буде початковим входом, а правий аргумент - вводом удвічі, тому це дасть квадрат початкового вводу.

оригінальна відповідь

J , 15 байт

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

Спробуйте в Інтернеті!

Подвійна версія: Спробуйте в Інтернеті!

В єдиній версії у нас є одне дієслово, яке використовує Agenda @.для виконання if ... тоді логіка: Якщо аргумент дорівнює самому собі =~, тоді візьміть аргумент і подвійно його(+:@[) .

Однак, коли ми подвоюємо код, ми отримуємо J-гачок. Виклик дієслова fі вхід y. Потім гачок f fвиконується так:

y f (f y)

Що означає, що тепер початковий вхід - це лівий аргумент, а правий аргумент - подвоєний. Оскільки вони не будуть рівними, =~цього разу повернеться помилковими, і тепер ми виконаємо інший вил Порядку денного, тобто *:@], що означає "квадрат правильного аргументу". А оскільки ~реверсує входи діадіального дієслова, правильним аргументом буде початковий ввід.

Python 3 , 60 байт

Розмір шматка 6.
Не чудове рішення, але воно працює. Це така унікальна проблема, що насправді змушує задуматися з іншого погляду.

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

Спробуйте в Інтернеті!

Удвічі:

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

Спробуйте в Інтернеті!

Каскад , 13 байт (розмір шматка 13)

]
&/2
#
*
 2&

Спробуйте в Інтернеті!

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

Спробуйте вдвічі!

Це було досить складно. Основна суть цього полягає в тому, щоб надрукувати вхід, помножений 2на першу програму, і замінити на2 копію введення на другу.

Пояснення:

Виконана частина першої програми виглядає так

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

Подвоєна програма в основному додає перший ]до кінця останнього рядка, тому програма обертається навколо цього замість &. Це перетворює це на

]     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 байт (розмір шматка 10)

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

Спробуйте в Інтернеті! Спробуйте вдвічі!

Зловживання той факт , що $varв $[$var]отримує розширена, а потім оцінюється в арифметичному контексті.

             # 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

Якщо хтось хоче тріщини при зниженні цього, ось найближче до 24/8рішення, яке я отримав (виводиться x^2+2при подвоєнні)