Ada beberapa tantangan yang melibatkan penggandaan kode sumber: di sini dan di sini . Tugas yang kami miliki di sini sedikit lebih sulit, tetapi harus dapat dilakukan di hampir setiap bahasa.

Dalam tantangan ini, Anda akan menerima bilangan bulat positif yang berubah-ubah. Program Anda harus menampilkan bilangan bulat itu dua kali lipat . Ketika kode sumber Anda digandakan, itu akan mengambil bilangan bulat positif, dan mengeluarkannya kuadrat .

Bagaimana kode sumber Anda digandakan? Nah, Anda bisa mendapatkannya dengan cara Anda . Artinya, Anda dapat membagi kode sumber Anda menjadi string byte atau karakter (atau token di langs tokenized) dari setiap sama panjang yang Anda inginkan , dan ulangi setiap potongan dua kali berturut-turut.

Untuk program awal ABCDEFGHIJKL, (panjang 12) di sini adalah semua program yang mungkin digandakan:

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

Perhatikan bahwa ini berarti program dengan panjang prime hanya dapat digandakan dua cara: setiap karakter digandakan, atau program penuh diulang dua kali.

Aturan:

• Kode harus merupakan program atau fungsi lengkap.
• Celah standar dilarang.
• Metode I / O standar diizinkan.
• Semua karakter / byte, termasuk spasi dan baris baru, dihitung dalam panjang kode dan berkontribusi pada potongan.
• Anda dapat mengasumsikan bahwa input dan kuadratnya dapat diwakili oleh tipe int / integer bahasa Anda.
• Anda tidak boleh menganggap baris baru atau karakter lain tertinggal.
• Berikan ukuran chunk Anda di pos setelah hitungan byte.
• Ini kode-golf , jadi program yang lebih pendek lebih baik! Jika dua program memiliki panjang yang sama, yang menggunakan panjang chunk yang lebih kecil akan menang. (Jika Anda memiliki program yang lebih panjang yang menggunakan panjang chunk yang lebih kecil, itu juga layak diposkan!)
• Jika program Anda membutuhkan input / jalur kedua, Anda tidak boleh membuat asumsi tentang nilainya. Secara khusus, program Anda harus bekerja jika input kedua kosong, sama dengan yang pertama, atau integer yang berbeda. Jika program Anda tidak membutuhkan input / saluran kedua, Anda dapat mengabaikan pembatasan ini.

Tautan kotak pasir

Perl 5 , 8 byte (ukuran chunk 4)

$_*=~~+2

Cobalah online , atau coba versi yang berlipat ganda .

Unary ~adalah bitwise negate, jadi menerapkannya dua kali adalah noop. Dengan demikian, program dasar hanya mengalikan$_ (variabel input-output implisit) dengan 2.

Binary ~~adalah smartmatch, yang mengembalikan boolean. ~~+2~~+2mem-parsing sebagai (~~+2) ~~ (+2). Karena 2 sama dengan 2, ini menghasilkan true (1). Dengan demikian, program yang digandakan pertama kali mengalikan $_dengan 1, kemudian mengalikan $_dengan sendirinya.

05AB1E , 4 byte (ukuran chunk 2 atau 4)

·Inr

Cobalah secara online atau digandakan sebagai potongan 4-byte tunggal atau digandakan sebagai dua potongan 2-byte .

·        # 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 byte (ukuran potongan 13)

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

Cobalah online!

Dua kali lipat:

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

Solusi ini disediakan oleh @Grimy.

Python 3 , 32 30 28 byte (ukuran chunk 16 15 14)

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

Cobalah online!

-4 byte terima kasih kepada @negativeSeven

Dua kali lipat:

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

Cobalah online!

Fungsi mengambil keuntungan dari aturan potongan unik dari tantangan ini.

Befunge-98 (FBBI) , 8 byte (panjang chunk 2)

;&:#* +q

Cobalah online!

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

Cobalah online! (berlipat ganda)

Tidak termasuk aliran kontrol, program pertama dieksekusi &:+q(input, duplikat puncak stack, tambahkan, keluar dengan kode kembali), dan dijalankan kedua &:*+q(input, duplikat atas tumpukan, multiply, tambah (jumlah dengan 0 implisit), keluar dengan kembali kode)

Hexagony , 14 byte (ukuran bongkahan 14)

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

Diperluas:

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

Cobalah online!

Dua kali lipat

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

Diperluas:

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

Coba gandakan secara online!

Hexagony berada dalam posisi yang agak aneh dalam tantangan ini, dalam hal benar-benar mencapai tugas tidak jauh lebih sulit daripada hanya mampu menulis dua program individu. Namun, solusi golf terbukti agak sulit.

Solusi ini adalah ide sepele dalam bentuk terpendek yang dapat saya masukkan, tetapi saya curiga ada jawaban yang lebih pendek dan lebih pintar. Versi ini dengan sangat naif menetapkan dua nilai ke input dan menjumlahkannya atau mengalikannya, tergantung pada apakah sumbernya digandakan. Satu-satunya kode yang digunakan kembali adalah"+ yang membuat membuat kode salin untuk program ganda cukup pendek agar sesuai dengan ruang yang tidak digunakan dari program asli.

Saya menduga menggunakan instruksi perubahan IP []akan membuat mengisolasi bagian-bagian lebih mudah, tetapi solusi yang benar-benar ideal akan menggunakan kembali banyak kode di antara keduanya. Saya membuat program pembantu untuk menggandakan kode sumber hexagony. Perhatikan bahwa ini menghilangkan trailing no-op jadi jika Anda ingin memiliki no-op pengganti di akhir, cukup isi beberapa karakter lain dan ubah kembali setelahnya. Itu dapat menangani ukuran chunk yang berbeda, meskipun saya belum menulis kode untuk menampilkan setiap program yang mungkin (Hexagony tampaknya meminjamkan dirinya untuk menggunakan ukuran chunk penuh).

Hexagony , 12 byte (ukuran chunk 4)

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

Cobalah online!

Diformat:

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

Dan dua kali lipat , lalu diformat:

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

Pada dasarnya, ini menetapkan tepi pertama ke input, lalu tepi kedua ke salah satu 2atau salinan input, kemudian mengalikan kedua tepi ke tepi ketiga, mencetak itu dan berakhir. Daftar instruksi yang dijalankan adalah adil

?"2}=*!@

dan

?"2+}=*!@

Dengan satu-satunya perbedaan adalah +menimpa 2pada program kedua.

JavaScript (ES6),  24  22 byte

Meskipun formatnya tidak biasa, ini adalah definisi fungsi anonim, yang dapat dipanggil secara langsung atau ditugaskan ke variabel.

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

Cobalah online!

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

Coba online dua kali lipat!

Bagaimana?

Menerapkan unary +ke suatu fungsi ditafsirkan sebagai upaya untuk memaksanya ke nomor dan menghasilkan NaN . Oleh karena itu, yang terdepan +(g=x=>x*x)salah di kedua versi.

Di sisi lain, menerapkan biner +antara 2 fungsi menghasilkan sebuah string. Oleh karena itu, (x=>x*2)+(g=x=>x*x)kebenaran dalam versi berlipat ganda.

Perl 6 , 8 byte (ukuran chunk 1)

* *<1 2>

Cobalah online! Coba dua kali lipat!

Apapun / Hyper Apa pun lambda yang mengambil nomor dan mengembalikan nomor untuk program pertama dan daftar tunggal untuk program kedua. Pada dasarnya ini menyimpan logika yang sama persis, kecuali bahwa operator perkalian ( *) digantikan oleh yang eksponensial ( **).

**  **<<11  22>>

Apa pun literal (membingungkan juga diwakili oleh a *) digandakan hingga HyperWhthing ( **) yang pada dasarnya sama kecuali memetakan daftar. Ruang diperlukan untuk memisahkan apa pun yang literal dari perkalian dan diabaikan ketika digandakan. Alih-alih hanya 2(yang akan digandakan ke 22) kami menggunakan daftar yang berisi dua elemen, yang mengevaluasi ke 2 dalam konteks numerik). The <>dapat dua kali lipat untuk daftar dengan interpolasi, dan dua elemen dalam yang dua kali lipat, tapi tak satu pun dari perubahan yang panjang daftar.

Pesona Runic , 9 byte (ukuran chunk 3)

i3?:*@:+@

Cobalah online!
Coba dua kali lipat!

The 3?melompat 3 petunjuk berikutnya, mengakibatkan (dieksekusi) i3?...:+@. Ketika dua kali lipat hasil dalam dieksekusi i3?...:*@mana .mewakili 3 petunjuk NOP'd. @adalah "cetak seluruh tumpukan dan akhiri."

C # (Visual C # Interactive Compiler) / Javascript, 22 byte, ukuran chunk 11

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

Cobalah online!

Brain-Flak , 48 30 byte (ukuran chunk 10)

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

Cobalah online! Coba dua kali lipat!

Ini pada dasarnya mengambil tiga langkah, kemudian ketika digandakan mengeksekusi langkah-langkah itu dua kali masing-masing. Program awal adalah:

1. Gandakan TOS, alihkan tumpukan, dan mulailah mendorong suatu nilai
2. Dapatkan nomor segitiga TOS n * (n-1) / 2
3. Pop TOS, beralih stack dan pop dua kali, lalu dorong hasilnya.

Untuk input nke program yang tidak digandakan, ini menghasilkan:

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:

Untuk program yang digandakan:

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 byte, potongan 76 byte

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

Cobalah online!

Gandakan (dengan baris baru untuk kejelasan)

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

Cobalah online!

Berikut adalah versi yang menggunakan prosedur penggandaan yang lebih kompleks. Itu 5 potongan ukuran 15. Kode di sini adalah 46 byte namun karena padding yang diperlukan secara substansial lebih lama.

105 90 byte, potongan 15 byte

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

Cobalah online!

Gandakan (dengan baris baru untuk kejelasan)

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

Cobalah online!

Cubix , 18 14 byte (panjang potong 9 7)

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

Perhatikan ruang trailing. Cobalah online!

Dua kali lipat:

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

Sekali lagi, ada satu ruang trailing. Cobalah online!

Penjelasan

Gagasan utamanya adalah menggandakan kode menyebabkan kubus menjadi lebih besar, sehingga penunjuk instruksi dimulai pada simbol yang berbeda. Karena program penambahan tidak dapat diletakkan pada kubus dengan panjang sisi 1, panjang sisi akan menjadi 2. Selain itu, kode yang digandakan harus berada pada kubus dengan panjang sisi 3, sehingga kode yang digandakan harus setidaknya 25 byte . Ini berarti kode harus sepanjang minimal 13 byte. Dengan demikian, paling banyak 1 byte lagi dapat disimpan.

Sekarang ke kode aktual. Pengamatan pertama adalah bahwa wajah atas (yaitu, 4 karakter pertama) tidak digunakan oleh program penambahan. Selanjutnya, jika kita membuat karakter ke-5 mencerminkan IP di sekitar kubus, kita dapat membebaskan 2 karakter lebih banyak. Kami akan menggunakan karakter ini untuk meletakkan program kuadrat.

Mornington Crescent , 656 Bytes (Ukuran bongkahan 328)

Hanya untuk menambah bobot pada teori bahwa ini dapat diselesaikan di hampir semua bahasa ...

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

(Baris baru yang tertinggal penting)

Coba versi tunggal! ... atau ... Coba versi yang berlipat ganda!

Teorinya di sini sederhana: Dalam versi tunggal, 'Batas Hijau' diisi dengan string acak, tetapi dalam versi dua kali akan diisi dengan input kuadrat. Setelah potongan berakhir, kedua versi menggandakan 'input', tetapi dalam versi kode yang dua kali lipat, input telah diganti dengan 0.

Hasil ini dikembalikan ke Batas Hijau, yang melakukan operasi maks () dua kali, sebelum membawa hasilnya ke output. Dalam versi tunggal ini membuat penggandaan tidak diubah (int dan string hanya beralih bolak-balik), tetapi dalam versi digandakan ini menggantikan 0 dengan hasil kuadrat yang sudah disimpan dalam Bounds Green.

JavaScript (Node.js) , 15 12 byte (ukuran chunk: 6)

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

Cobalah online!

Kasus tunggal:

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

Kasus ganda:

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

Tampaknya juga berfungsi di C #, dan Java jika berubah =>menjadi ->?

R , 42 35 28 byte (ukuran chunk 4)

Sekarang dengan bongkahan yang lebih kecil dan tidak ada kesalahan. Saya juga punya solusi yang lebih panjang dengan ukuran chunk 3; Lihat di bawah.

Saya rasa tidak mungkin untuk menulis jawaban R dengan ukuran chunk 1 atau 2; Saya akan dengan senang hati memberikan hadiah kepada siapa pun yang membuktikan saya salah.

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

Cobalah online!

The #adalah untuk komentar di R. 3 baris hanya spasi, membuat sepotong newline + 2 ruang + baris baru, sehingga potongan sebelumnya dan berikutnya dapat memiliki baris baru.

Menggandakan, menjadi:

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

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

Cobalah online!

Versi tunggal menghitung $\frac n2\times4=2n$; versi ganda menghitung$\frac n2\times \frac n2\times4=n^2$.

Berikut ini solusi yang sedikit lebih lama, tetapi dengan ukuran chunk 3:

R , 39 byte (ukuran chunk 3)

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

Cobalah online!

Dua kali lipat:

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

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

Cobalah online!

Perhatikan bahwa Giuseppe memiliki jawaban R lain , dengan satu potongan 30 byte.

R , 59 30 byte (ukuran chunk 59 30)

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

Cobalah online!

Penghargaan untuk Robin Ryder karena menginspirasi ini; bertambah Fsetiap kali, dan fungsi fmemilih output yang sesuai.

Ini tidak terlalu menarik, tetapi pasti sesuatu yang pintar memanipulasi ukuran chunk akan diimpikan. Seperti yang diharapkan, Robin Ryder datang dengan ini yang lebih pendek dan memiliki beberapa manipulasi potongan rapi.

PowerShell , 22 byte (ukuran chunk 11)

param($p)
#   /
2 * $p

Cobalah online .

Dua kali lipat:

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

Solusi ini didasarkan pada solusi @ ShieruAsakoto .

Solusi @Grimy yang telah dikonversi ke PowerShell, 26 byte (ukuran chunk 13)

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

Cobalah online .

Dua kali lipat:

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

Perl 5 ( -p), 22 15 byte

-7 byte terima kasih kepada Grimy

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

TIO

Arang , 13 byte

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

Cobalah online! Penjelasan: Daftar kosong yang telah ditentukan adalah falsey sehingga inputnya dikalikan dengan 2. Ketika digandakan pass kedua melihat string kosong telah didorong ke daftar sehingga ia mengalikan input dengan sendirinya. Cobalah online! Dalam sintaksis verbose ini sesuai dengan Multiprint(Cast(Times(Cast(q), Ternary(u, Cast(q), 2)))); Push(u, w);.

Python 3, 56 53 byte

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

Keterampilan python saya agak payah, jadi pasti bisa bermain golf .. Berdasarkan jawaban Python di tantangan " Saya gandakan sumbernya, Anda gandakan hasilnya! " .

Panjang chunk 53.

Coba online atau coba online dua kali lipat .

Java 8, 62 byte

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

Panjang potongan 62.

Coba online atau coba online dua kali lipat .

Penjelasan:

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

Di Jawa, komentar yang tersedia adalah // commentdan /* comment */. Yang digabungkan di sini untuk menimpa bagian-bagian tertentu. Lihat cara kerja komentar ini berkat penyorotan 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;}/**///

Program ganda menciptakan Bytekelas khusus dan nilainya SIZE=9, yang menimpa java.lang.Bytekelas default dan nilainya SIZE=8.

Japt , 7 5 byte

*N²jJ

Cobalah | Dua kali lipat

²mendorong 2 ke array input Nkemudian jmenghapus & mengembalikan elemen pada indeksJ=-1 (yaitu, yang baru saja dimasukkan 2) dan mengalikan input dengan itu.

Ketika digandakan hasilnya Jdikalikan dengan 2, jadi elemen pada indeks -2(yaitu, input) dikembalikan oleh jdan digunakan sebagai pengali.

Jelly , 8 6 byte (panjang chunk 3)

Ḥ;²3ị 

Cobalah online!

Dua kali lipat

Solusi yang bagus: Lua , 66 byte (ukuran chunk 66 byte)

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

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

Oh ya, cukup yakin bahwa ada solusi yang lebih pendek untuk ini, tapi itu yang terbaik yang bisa saya lakukan dengan cara ini. Ambil masukan sebagai argumen pertama.

Penjelasan singkat: seluruh bisnis dengan acukup jelas untuk semua orang, sedangkan bagian kedua dengan xlebih menarik. Pada dasarnya, saya membuat tabel (atau memperbarui yang sudah ada pada pass kedua) dengan finalizer (__gc metamethod) which gets called when program exits.

Solusi lumpuh: Lua , 60 byte (ukuran chunk 30 byte)

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

Cobalah online! atau Coba dua kali lipat!

Lebih kecil dan dengan chunking yang lebih baik, tetapi pada akhirnya membosankan dan lumpuh tanpa trik pintar. Saya cukup yakin tidak ada komentar yang diperlukan untuk ini.

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 byte

Ukuran chunk 6.
Bukan solusi yang bagus, tetapi berhasil. Ini adalah tantangan yang unik, itu benar-benar membuat Anda berpikir dari sudut pandang yang berbeda.

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

Cobalah online!

Dua kali lipat:

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

Cobalah online!

Cascade , 13 byte (ukuran chunk 13)

]
&/2
#
*
 2&

Cobalah online!

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

Coba dua kali lipat!

Ini cukup sulit. Inti dasar dari ini adalah untuk mencetak input yang dikalikan dengan 2untuk program pertama, dan menggantikannya 2dengan salinan input untuk yang kedua.

Penjelasan:

Bagian yang dieksekusi dari program pertama terlihat seperti

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

Program yang digandakan pada dasarnya menambahkan yang pertama ]ke akhir baris terakhir, sehingga program membungkus untuk itu daripada &. Ini mengubahnya menjadi

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

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

Cobalah online! Coba dua kali lipat!

Menyalahgunakan fakta bahwa $vardalam $[$var]diperluas terlebih dahulu, kemudian dievaluasi dalam konteks aritmatika.

             # 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

Jika ada yang ingin celah dalam menurunkan ini, inilah 24/8solusi terdekat yang saya dapatkan (keluaran x^2+2ketika digandakan)