Đã có một vài thách thức liên quan đến việc nhân đôi mã nguồn: tại đây và đây . Nhiệm vụ chúng ta có ở đây khó hơn một chút, nhưng nên được thực hiện trong hầu hết mọi ngôn ngữ.

Trong thử thách này, bạn sẽ nhận một số nguyên dương tùy ý. Chương trình của bạn phải xuất số nguyên đó lên gấp đôi . Khi mã nguồn của bạn được nhân đôi, nó sẽ lấy một số nguyên dương và xuất ra bình phương .

Làm thế nào là mã nguồn của bạn tăng gấp đôi? Vâng, bạn có thể có nó theo cách của bạn . Điều đó có nghĩa là, bạn có thể chia mã nguồn của mình thành các chuỗi byte hoặc ký tự (hoặc mã thông báo trong các lang được mã hóa) với bất kỳ độ dài bằng nhau nào bạn muốn và lặp lại mỗi đoạn hai lần liên tiếp.

Đối với chương trình ban đầu ABCDEFGHIJKL, (độ dài 12) ở đây là tất cả các chương trình nhân đôi có thể:

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

Lưu ý rằng điều này có nghĩa là các chương trình có độ dài chính chỉ có thể được nhân đôi theo hai cách: mỗi ký tự được nhân đôi hoặc toàn bộ chương trình được lặp lại hai lần.

Quy tắc:

• Mã phải là một chương trình hoặc chức năng đầy đủ.
• Sơ hở tiêu chuẩn bị cấm.
• Phương pháp I / O tiêu chuẩn được cho phép.
• Tất cả các ký tự / byte, bao gồm cả khoảng trắng và dòng mới, được tính theo độ dài của mã và đóng góp vào các đoạn.
• Bạn có thể giả sử rằng đầu vào và hình vuông của nó có thể được biểu thị bằng kiểu int / số nguyên của ngôn ngữ của bạn.
• Bạn không thể giả sử một dòng mới hoặc nhân vật khác.
• Cung cấp kích thước khối của bạn trong tiêu đề sau khi đếm byte.
• Đây là mã golf , vì vậy các chương trình ngắn hơn là tốt hơn! Nếu hai chương trình có cùng độ dài, chương trình nào sử dụng độ dài khối nhỏ hơn sẽ thắng. (Nếu bạn có một chương trình dài hơn sử dụng độ dài đoạn nhỏ hơn, thì cũng đáng để đăng!)
• Nếu chương trình của bạn yêu cầu đầu vào / dòng thứ hai, bạn có thể không đưa ra giả định nào về giá trị của nó. Cụ thể, chương trình của bạn sẽ hoạt động nếu đầu vào thứ hai trống, giống như đầu tiên hoặc một số nguyên khác. Nếu chương trình của bạn không yêu cầu đầu vào / dòng thứ hai, bạn có thể bỏ qua hạn chế này.

Liên kết hộp cát

Perl 5 , 8 byte (kích thước chunk 4)

$_*=~~+2

Dùng thử trực tuyến hoặc thử phiên bản nhân đôi .

Unary ~là phủ định bitwise, vì vậy áp dụng nó hai lần là không có. Do đó, chương trình cơ sở chỉ đơn giản là nhân $_(biến đầu vào-đầu ra ngầm định) với 2.

Nhị phân ~~là smartmatch, trả về boolean. ~~+2~~+2phân tích như (~~+2) ~~ (+2). Vì 2 bằng 2, điều này mang lại kết quả đúng (1). Do đó, chương trình nhân đôi trước tiên nhân với $_1, sau đó nhân với $_chính nó.

05AB1E , 4 byte (kích thước khối 2 hoặc 4)

·Inr

Hãy thử trực tuyến hoặc nhân đôi dưới dạng một đoạn 4 byte đơn hoặc nhân đôi thành hai đoạn 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 (kích thước chunk 13)

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

Hãy thử trực tuyến!

Nhân đôi:

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

Giải pháp này được cung cấp bởi @Grimy.

Python 3 , 32 30 28 byte (kích thước khối 16 15 14)

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

Hãy thử trực tuyến!

-4 byte nhờ @negativeSeven

Nhân đôi:

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

Hãy thử trực tuyến!

Hàm này tận dụng quy tắc chunk độc đáo của thử thách này.

Befunge-98 (FBBI) , 8 byte (đoạn dài 2)

;&:#* +q

Hãy thử trực tuyến!

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

Hãy thử trực tuyến! (nhân đôi)

Không bao gồm luồng điều khiển, chương trình đầu tiên thực thi &:+q(đầu vào, trùng lặp đỉnh của ngăn xếp, thêm, thoát với mã trả về) và thực thi thứ hai &:*+q(đầu vào, đầu trùng lặp của ngăn xếp, nhân, thêm (tổng với 0 ẩn), thoát với trả về mã)

Hexagony , 14 byte (kích thước chunk 14)

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

Mở rộng:

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

Hãy thử trực tuyến!

Nhân đôi

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

Mở rộng:

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

Hãy thử gấp đôi trực tuyến!

Hexagony có một vị trí kỳ lạ trong thử thách này, trong đó thực sự đạt được nhiệm vụ không khó hơn nhiều so với việc đơn giản là có thể viết hai chương trình riêng lẻ. Tuy nhiên, chơi golf giải pháp tỏ ra khá khó khăn.

Giải pháp này là ý tưởng tầm thường ở dạng ngắn nhất mà tôi có thể phù hợp, nhưng tôi nghi ngờ có những câu trả lời ngắn hơn, thông minh hơn. Phiên bản này rất ngây thơ đặt hai giá trị cho đầu vào và tính tổng hoặc nhân chúng, tùy thuộc vào việc nguồn có được nhân đôi hay không. Việc sử dụng lại mã duy nhất là"+ làm cho mã sao chép cho chương trình nhân đôi đủ ngắn để phù hợp với không gian chưa sử dụng từ chương trình gốc.

Tôi nghi ngờ sử dụng các hướng dẫn thay đổi IP []sẽ giúp cách ly các bộ phận dễ dàng hơn, nhưng một giải pháp thực sự lý tưởng sẽ sử dụng lại rất nhiều mã giữa hai phần. Tôi đã thực hiện một chương trình trợ giúp để nhân đôi mã nguồn lục giác. Lưu ý rằng nó sẽ loại bỏ các no-op theo dõi vì vậy nếu bạn muốn có no-op giữ chỗ ở cuối, chỉ cần điền vào một số ký tự khác và thay đổi lại sau đó. Nó có thể xử lý các kích thước khối khác nhau, mặc dù tôi chưa viết mã để xuất từng chương trình có thể (Hexagony dường như cho vay để sử dụng kích thước khối đầy đủ).

Hexagony , 12 byte (kích thước chunk 4)

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

Hãy thử trực tuyến!

Định dạng:

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

Và nhân đôi , sau đó định dạng:

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

Về cơ bản, điều này đặt cạnh đầu tiên cho đầu vào, sau đó cạnh thứ hai thành một 2hoặc một bản sao của đầu vào, sau đó nhân hai cạnh đó thành cạnh thứ ba, in ra và chấm dứt. Danh sách các hướng dẫn thực hiện chỉ là

?"2}=*!@

và

?"2+}=*!@

Với sự khác biệt duy nhất là ghi +đè 2lên chương trình thứ hai.

JavaScript (ES6),  24  22 byte

Mặc dù định dạng bất thường của nó, đây là định nghĩa của một hàm ẩn danh, có thể được gọi trực tiếp hoặc gán cho một biến.

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

Hãy thử trực tuyến!

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

Hãy thử trực tuyến gấp đôi!

Làm sao?

Áp dụng unary +cho một chức năng được hiểu là một nỗ lực để ép buộc nó vào một số và dẫn đến NaN . Do đó, hàng đầu +(g=x=>x*x)là giả trong cả hai phiên bản.

Mặt khác, áp dụng nhị phân +giữa 2 hàm dẫn đến một chuỗi. Do đó, (x=>x*2)+(g=x=>x*x)là sự thật trong phiên bản nhân đôi.

Perl 6 , 8 byte (kích thước khối 1)

* *<1 2>

Hãy thử trực tuyến! Hãy thử gấp đôi!

Bất cứ điều gì / HyperWhthing lambda lấy một số và trả về một số cho chương trình đầu tiên và một danh sách đơn cho chương trình thứ hai. Về cơ bản, điều này giữ logic chính xác như nhau, ngoại trừ toán tử nhân ( *) được thay thế bằng toán tử mũ ( **).

**  **<<11  22>>

Bất cứ nghĩa đen nào (khó hiểu cũng được đại diện bởi a *) được nhân đôi lên thành HyperWhthing ( **) về cơ bản là giống nhau ngoại trừ nó ánh xạ qua các danh sách. Không gian là cần thiết để phân tách bất cứ nghĩa đen nào từ phép nhân và bị bỏ qua khi nhân đôi. Thay vì chỉ 2(sẽ được nhân đôi thành 22), chúng tôi sử dụng một danh sách chứa hai phần tử, ước tính thành 2 trong ngữ cảnh số). Có <>thể nhân đôi thành một danh sách với phép nội suy và hai phần tử bên trong được nhân đôi, nhưng cả hai phần tử này đều không thay đổi độ dài của danh sách.

Runic Enchantments , 9 byte (kích thước chunk 3)

i3?:*@:+@

Hãy thử trực tuyến!
Hãy thử gấp đôi!

Việc 3?bỏ qua 3 hướng dẫn tiếp theo, dẫn đến một (được thực thi) i3?...:+@. Khi nhân đôi, kết quả là được thực thi i3?...:*@trong đó .thể hiện 3 lệnh NOP'd. @là "in toàn bộ ngăn xếp và chấm dứt."

C # (Trình biên dịch tương tác Visual C #) / Javascript, 22 byte, kích thước khối 11

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

Hãy thử trực tuyến!

Brain-Flak , 48 30 byte (kích thước chunk 10)

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

Hãy thử trực tuyến! Hãy thử gấp đôi!

Điều này về cơ bản mất ba bước, sau đó khi nhân đôi thực hiện các bước đó hai lần mỗi bước. Chương trình ban đầu là:

1. Sao chép ĐKDV, chuyển đổi ngăn xếp và bắt đầu đẩy một giá trị
2. Lấy số tam giác của Tosh n * (n-1) / 2
3. Pop Tosh, chuyển stack và pop hai lần, sau đó đẩy kết quả.

Đối với đầu nvào vào một chương trình không bị xáo trộn, điều này dẫn đế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:

Đối với chương trình nhân đôi:

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, khối 76 byte

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

Hãy thử trực tuyến!

Nhân đôi (với dòng mới cho rõ ràng)

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

Hãy thử trực tuyến!

Đây là một phiên bản sử dụng thủ tục nhân đôi phức tạp hơn. Nó có 5 khối kích thước 15. Mã ở đây là 46 byte tuy nhiên do phần đệm được yêu cầu nên nó dài hơn đáng kể.

105 90 byte, khối 15 byte

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

Hãy thử trực tuyến!

Nhân đôi (với dòng mới cho rõ ràng)

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

Hãy thử trực tuyến!

Cubix , 18 14 byte (đoạn dài 9 7)

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

Lưu ý không gian dấu. Hãy thử trực tuyến!

Nhân đôi:

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

Một lần nữa, có một không gian dấu. Hãy thử trực tuyến!

Giải trình

Ý tưởng chính là việc nhân đôi mã làm cho khối lập phương trở nên lớn hơn, do đó, con trỏ lệnh bắt đầu ở một biểu tượng khác. Vì chương trình bổ sung không thể được đặt trên một khối có độ dài cạnh 1, nên độ dài của cạnh sẽ là 2. Ngoài ra, mã nhân đôi cần phải nằm trên một khối có độ dài cạnh 3, do đó, mã nhân đôi phải có ít nhất 25 byte . Điều này có nghĩa là mã phải dài ít nhất 13 byte. Như vậy, nhiều nhất 1 byte có thể được lưu.

Bây giờ đến mã thực tế. Quan sát đầu tiên là mặt trên (nghĩa là 4 ký tự đầu tiên) không được chương trình bổ sung sử dụng. Hơn nữa, nếu chúng ta tạo ký tự thứ 5 phản ánh IP xung quanh khối, chúng ta có thể giải phóng thêm 2 ký tự. Chúng tôi sẽ sử dụng các nhân vật này để đưa chương trình bình phương.

Mornington Crescent , 656 Byte (kích thước Chunk 328)

Chỉ cần thêm trọng lượng vào lý thuyết rằng điều này có thể được giải quyết bằng hầu hết mọi ngôn ngữ ...

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

(Dòng mới là rất quan trọng)

Hãy thử phiên bản duy nhất! ... Hoặc ... Hãy thử phiên bản nhân đôi!

Lý thuyết ở đây rất đơn giản: Trong phiên bản đơn, 'Bound Green' chứa đầy một chuỗi ngẫu nhiên, nhưng trong phiên bản nhân đôi, nó được lấp đầy với đầu vào bình phương. Sau khi đoạn kết thúc, cả hai phiên bản đều nhân đôi 'đầu vào', nhưng trong phiên bản nhân đôi của mã, đầu vào đã được thay thế bằng 0.

This result is taken back to Bounds Green, which performs a max() operation twice, before taking the result to the output. In the single version this leaves the doubling unaltered (the int and string are just switched back and forth), but in the doubled version this replaces the 0 with the squared result already stored in Bounds Green.

JavaScript (Node.js), 15 12 bytes (chunk size: 6)

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

Try it online!

Single case:

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

Double case:

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

Seems to also work in C#, and Java if changing => to ->?

R, 42 35 28 bytes (chunk size 4)

Now with a smaller chunk and no error. I also have a longer solution with chunk size 3; see below.

I don't think it is possible to write an R answer with chunk size 1 or 2; I'll happily give a bounty to anyone who proves me wrong.

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

Try it online!

The # is for comments in R. The 3rd line is only spaces, making a chunk of newline + 2 spaces + newline, so that the previous and next chunk can have no newline.

Doubled, it becomes:

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

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

Try it online!

The single version computes $\frac n2\times4=2n$; the double version computes $\frac n2\times \frac n2\times4=n^2$.

Here is a slightly longer solution, but with chunk size 3:

R, 39 bytes (chunk size 3)

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

Try it online!

Doubled:

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

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

Try it online!

Note that Giuseppe has another R answer, with one chunk of 30 bytes.

R, 59 30 bytes (chunk size 59 30)

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

Try it online!

Credit to Robin Ryder for inspiring this; increments F each time, and the function f selects the appropriate output.

This isn't particularly interesting, but doubtless something clever manipulating the chunk size will be dreamed up. As expected, Robin Ryder came up with this which is both shorter and has some neat chunk manipulation.

PowerShell, 22 bytes (chunk size 11)

param($p)
#   /
2 * $p

Try it online.

Doubled:

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

This solution is based on @ShieruAsakoto's solution.

@Grimy solution that has been converted to PowerShell, 26 bytes (chunk size 13)

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

Try it online.

Doubled:

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

Perl 5 (-p), 22 15 bytes

-7 bytes thanks to Grimy

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

TIO

Charcoal, 13 bytes

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

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)