มีการคู่ของความท้าทายที่เกี่ยวข้องกับรหัสที่มาเสแสร้ง A: ที่นี่และที่นี่ งานที่เรามีที่นี่ยากขึ้นนิดหน่อย แต่น่าจะทำได้ในเกือบทุกภาษา

ในการท้าทายนี้คุณจะต้องใช้จำนวนเต็มบวกโดยพลการ โปรแกรมของคุณจะต้องแสดงผลเป็นจำนวนเต็มสองเท่าสองเท่าเมื่อรหัสต้นฉบับของคุณเป็นสองเท่าก็จะใช้เวลาในการเป็นจำนวนเต็มบวกและการส่งออกมันยกกำลังสอง

ซอร์สโค้ดของคุณเป็นสองเท่าได้อย่างไร ดีคุณสามารถมีได้ในแบบของคุณ นั่นคือจะบอกว่าคุณสามารถแยกรหัสที่มาของคุณขึ้นเป็นสตริงของไบต์หรืออักขระ (หรือราชสกุลใน Langs tokenized) ของใด ๆที่เท่าเทียมกันระยะเวลาที่คุณต้องการและทำซ้ำแต่ละก้อนสองครั้ง

สำหรับโปรแกรมเริ่มต้นของABCDEFGHIJKL(ความยาว 12) ที่นี่เป็นโปรแกรมสองเท่าที่เป็นไปได้ทั้งหมด :

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

โปรดทราบว่านี่หมายถึงโปรแกรมที่มีความยาวสูงสุดสองเท่าสามารถทำได้สองวิธีเท่านั้น: ทุกตัวละครเพิ่มเป็นสองเท่าหรือโปรแกรมเต็มจะทำซ้ำสองครั้ง

กฎ:

• รหัสจะต้องเป็นโปรแกรมหรือฟังก์ชั่นเต็มรูปแบบ
• ช่องโหว่มาตรฐานเป็นสิ่งต้องห้าม
• อนุญาตให้ใช้วิธีมาตรฐาน I / O
• อักขระ / ไบต์ทั้งหมดรวมถึงช่องว่างและบรรทัดใหม่ถูกนับในความยาวของรหัสและนำไปสู่ชิ้นส่วน
• คุณอาจสมมติว่าอินพุตและสี่เหลี่ยมจัตุรัสสามารถแสดงโดยชนิด int / จำนวนเต็มของภาษาของคุณ
• คุณไม่สามารถใช้อักขระขึ้นบรรทัดใหม่หรืออักขระอื่น ๆ
• ระบุขนาดก้อนของคุณในส่วนหัวหลังจากนับไบต์
• นี่คือรหัสกอล์ฟโปรแกรมที่สั้นกว่าดีกว่า! หากสองโปรแกรมมีความยาวเท่ากันโปรแกรมที่ใช้ความยาวอันน้อยจะเป็นผู้ชนะ (ถ้าคุณมีโปรแกรมที่ยาวขึ้นซึ่งใช้ความยาวอันน้อยลงนั่นก็คุ้มที่จะโพสต์ด้วย!)
• หากโปรแกรมของคุณต้องการอินพุต / บรรทัดที่สองคุณอาจไม่มีข้อสมมติฐานเกี่ยวกับค่าของมัน โดยเฉพาะอย่างยิ่งโปรแกรมของคุณควรทำงานหากอินพุตที่สองว่างเปล่าเช่นเดียวกับค่าแรกหรือจำนวนเต็มอื่น หากโปรแกรมของคุณไม่ต้องการอินพุต / บรรทัดที่สองคุณอาจเพิกเฉยต่อข้อ จำกัด นี้ได้

ลิงก์ Sandbox

Perl 5 , 8 ไบต์ (ขนาดก้อน 4)

$_*=~~+2

ลองมันออนไลน์หรือลองรุ่นสองเท่า

เอกภาพ~เป็นลบล้าง bitwise ดังนั้นการใช้มันสองครั้งเป็น noop ดังนั้นโปรแกรมพื้นฐานจะเพิ่มทวีคูณ$_ (ตัวแปรอินพุต - เอาต์พุตโดยปริยาย) ด้วย 2

Binary ~~คือ 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), รหัส)

Hexagony , 14 ไบต์ (ขนาดก้อน 14)

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

ขยาย:

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

ลองออนไลน์!

สองเท่า

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

ขยาย:

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

ลองออนไลน์เป็นสองเท่า!

Hexagony อยู่ในตำแหน่งที่แปลกประหลาดในการท้าทายนี้ซึ่งในความเป็นจริงการบรรลุภารกิจนั้นไม่ยากกว่าการเขียนโปรแกรมสองรายการ อย่างไรก็ตามการเล่นกอล์ฟแก้ปัญหาค่อนข้างยาก

วิธีแก้ปัญหานี้เป็นแนวคิดเล็กน้อยในรูปแบบที่สั้นที่สุดที่ฉันสามารถใส่ได้ แต่ฉันคิดว่ามีคำตอบที่สั้นกว่าและฉลาดกว่า เวอร์ชันนี้ไร้เดียงสาตั้งค่าสองค่าเป็นอินพุทและผลรวมหรือคูณพวกเขาขึ้นอยู่กับว่าแหล่งที่มาเป็นสองเท่า การใช้รหัสซ้ำเพียงอย่างเดียวคือการ"+สร้างรหัสการคัดลอกสำหรับโปรแกรมสองเท่าที่สั้นพอที่จะพอดีกับพื้นที่ที่ไม่ได้ใช้จากโปรแกรมต้นฉบับ

ฉันสงสัยว่าการใช้คำแนะนำการเปลี่ยน IP []จะทำให้การแยกชิ้นส่วนง่ายขึ้น แต่ทางออกที่ดีที่สุดอย่างแท้จริงจะนำโค้ดจำนวนมากมาใช้ใหม่ระหว่างทั้งสอง ฉันสร้างโปรแกรมตัวช่วยเพื่อให้ได้ซอร์สโค้ดหกเหลี่ยม โปรดทราบว่ามันจะลบ no-ops ที่ต่อท้ายดังนั้นหากคุณต้องการให้ไม่มีตัวยึดตำแหน่งในตอนท้ายเพียงแค่กรอกอักขระอื่นแล้วเปลี่ยนกลับ มันสามารถรองรับขนาดก้อนที่แตกต่างกันได้ แต่ฉันยังไม่ได้เขียนโค้ดเพื่อส่งออกแต่ละโปรแกรมที่เป็นไปได้ (Hexagony ดูเหมือนว่าจะให้ยืมตัวเองโดยใช้ขนาดเต็มก้อน)

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)

ลองออนไลน์ได้สองเท่า!

อย่างไร?

ใช้เอก+ให้กับฟังก์ชันถูกตีความว่าเป็นความพยายามที่จะบังคับให้มันไปเป็นจำนวนและผลในน่าน ดังนั้นผู้นำ+(g=x=>x*x)จึงเป็นเท็จในทั้งสองรุ่น

ในทางกลับกันการใช้ไบนารี+ระหว่าง 2 ฟังก์ชั่นส่งผลให้สตริง ดังนั้นจึง(x=>x*2)+(g=x=>x*x)เป็นความจริงในรุ่นสองเท่า

Perl 6 , 8 ไบต์ (ขนาดก้อนที่ 1)

* *<1 2>

ลองออนไลน์! ลองสองเท่า!

สิ่งใด / HyperWhething แลมบ์ดาที่ใช้ตัวเลขและส่งกลับตัวเลขสำหรับโปรแกรมแรกและรายการซิงเกิลสำหรับโปรแกรมที่สอง โดยพื้นฐานแล้วสิ่งนี้จะช่วยให้ตรรกะเดียวกันแน่นอนยกเว้นว่าตัวดำเนินการคูณ ( *) จะถูกแทนที่ด้วยเลขชี้กำลังหนึ่ง ( **)

**  **<<11  22>>

สิ่งใดตามตัวอักษร (สับสนยังเป็นตัวแทนจาก*) จะเพิ่มขึ้นเป็นสองเท่าถึง HyperWhething ( **) ซึ่งโดยทั่วไปจะเหมือนกันยกเว้นมันแมปมากกว่ารายการ จำเป็นต้องใช้พื้นที่เพื่อแยกสิ่งที่แท้จริงออกจากการคูณและจะถูกละเว้นเมื่อเพิ่มเป็นสองเท่า แทนที่จะเป็นเพียงแค่2(ซึ่งจะเพิ่มเป็นสองเท่า22) เราใช้รายการที่มีสององค์ประกอบซึ่งประเมินเป็น 2 ในบริบทที่เป็นตัวเลข) <>สามารถเท่าที่จะรายการที่มีการแก้ไขและสององค์ประกอบภายในเป็นสองเท่า แต่ไม่การเปลี่ยนแปลงเหล่านั้นมีความยาวของรายการ

Runic Enchantments 9 ไบต์ (ขนาดก้อน 3)

i3?:*@:+@

ลองออนไลน์!
ลองสองเท่า!

3?ข้ามต่อไป 3 คำแนะนำที่ส่งผลให้ i3?...:+@(ดำเนินการ) เมื่อเพิ่มเป็นสองเท่าผลลัพธ์จะถูกดำเนินการi3?...:*@โดยที่.แสดงถึงคำแนะนำ 3 NOP @คือ "พิมพ์สแต็กทั้งหมดและสิ้นสุด"

C # (Visual C # Interactive คอมไพเลอร์) / Javascript, 22 ไบต์, ขนาดก้อน 11

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

ลองออนไลน์!

Brain-Flak , 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: 

Brain-Flak , 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 ตัวแรก) ไม่ได้ถูกใช้โดยโปรแกรมเพิ่มเติม นอกจากนี้หากเราทำให้ตัวละครตัวที่ 5 สะท้อน IP รอบลูกบาศก์เราสามารถเพิ่มตัวละครได้อีก 2 ตัว เราจะใช้ตัวละครเหล่านี้เพื่อวางโปรแกรมกำลังสอง

Mornington Crescentขนาด 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

(ขึ้นบรรทัดใหม่ต่อท้ายเป็นสิ่งสำคัญ)

ลองรุ่นเดียว! ... หรือ ... ลองรุ่นสองเท่า!

ทฤษฎีที่นี่ง่าย: ในรุ่นเดียว 'ขอบเขตสีเขียว' จะเต็มไปด้วยสตริงแบบสุ่ม แต่ในรุ่นสองเท่าจะได้รับเต็มไปด้วยการป้อนข้อมูลกำลังสอง หลังจากที่สิ้นสุดชิ้นทั้งสองรุ่นที่สอง 'การป้อนข้อมูล' แต่ในรุ่นสองเท่าของรหัสการป้อนข้อมูลถูกแทนที่ด้วย 0

ผลลัพธ์นี้จะถูกนำกลับไปที่ขอบเขตสีเขียวซึ่งดำเนินการ max () การดำเนินการสองครั้งก่อนนำผลลัพธ์ไปยังเอาต์พุต ในเวอร์ชั่นเดียวสิ่งนี้จะทำให้ไม่มีการเปลี่ยนแปลงเป็นสองเท่า (int และสตริงเพิ่งจะสลับไปมา) แต่ในรุ่นสองเท่านี้จะแทนที่ 0 ด้วยผลลัพธ์ squared ที่เก็บไว้ในขอบเขตสีเขียวแล้ว

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#  

ลองออนไลน์!

The #สำหรับความคิดเห็นใน R บรรทัดที่ 3 เป็นช่องว่างเท่านั้นทำให้มีการขึ้นบรรทัดใหม่ + 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#

ลองออนไลน์!

โปรดทราบว่า Giuseppe มีคำตอบ R อีกคำตอบหนึ่งอัน 30 ไบต์

R , 59 30 ไบต์ (ขนาดก้อน59 30)

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

ลองออนไลน์!

ขอมอบเครดิตให้แก่Robin Ryderสำหรับการสร้างแรงบันดาลใจนี้ เพิ่มขึ้น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 ไบต์ขอบคุณ Grimy

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

TIO

ถ่าน 13 ไบต์

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

ลองออนไลน์! คำอธิบาย: รายการว่างที่กำหนดไว้ล่วงหน้าเป็นเท็จดังนั้นการป้อนข้อมูลจะถูกคูณด้วย 2 เมื่อสองเท่าที่สองผ่านเห็นสตริงที่ว่างเปล่าได้ถูกผลักไปยังรายการเพื่อที่จะคูณการป้อนข้อมูลด้วยตัวเองแทน ลองออนไลน์! ใน verbose 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:])) #

ทักษะหลามของฉันนะดูดดังนั้นแน่นอนสามารถแข็งแรงเล่นกอล์ฟ .. ขึ้นอยู่กับคำตอบที่งูใหญ่ใน " ฉันเป็นสองเท่าของแหล่งที่มาของคุณสองเอาท์พุท! " ความท้าทาย

ความยาวก้อน 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.ByteSIZE=8

Japt , 7 5 ไบต์

*N²jJ

ลองมัน | สองเท่า

²กด 2 ไปที่อาร์เรย์ของอินพุตNจากนั้นjลบ & ส่งคืนองค์ประกอบที่ดัชนีJ=-1(เช่นแทรกใหม่2 ) และคูณอินพุตโดย

เมื่อเพิ่มเป็นสองเท่าผลลัพธ์Jจะถูกคูณด้วย2ดังนั้นองค์ประกอบที่ดัชนี-2(เช่นอินพุต) จะถูกส่งคืนโดยjและใช้เป็นตัวคูณ

เยลลี่ , 8 6 ไบต์ (ความยาวก้อน 3)

Ḥ;²3ị 

ลองออนไลน์!

สองเท่า

วิธีแก้ปัญหาที่ดี: Lua , 66 ไบต์ (ก้อนขนาด 66 ไบต์)

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

ลองออนไลน์!(เพิ่มเป็นสองเท่าของตัวคุณเองมันไม่ยากมาก)

โอ้ใช่แล้วค่อนข้างแน่ใจว่ามีวิธีแก้ปัญหาที่สั้นกว่านี้ แต่สิ่งที่ดีที่สุดที่ฉันสามารถทำได้คือวิธีนี้ รับอินพุตเป็นอาร์กิวเมนต์แรก

คำอธิบายสั้น ๆ : ธุรกิจทั้งหมดที่มีaค่อนข้างชัดเจนสำหรับทุกคนในขณะที่ส่วนที่สองมีxความน่าสนใจ โดยพื้นฐานแล้วฉันสร้างตาราง (หรืออัปเดตที่มีอยู่ในการส่งครั้งที่สอง) ด้วย finalizer (__gc metamethod) ซึ่งได้รับการเรียกเมื่อออกจากโปรแกรม

วิธีแก้ปัญหา Lame: Lua 60 ไบต์ (ขนาดก้อน 30 ไบต์)

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

ลองออนไลน์! หรือลองเป็นสองเท่า!

เล็กกว่าและมี chunking ที่ดีกว่า แต่ในที่สุดก็น่าเบื่อและง่อยโดยไม่มีลูกเล่นที่ฉลาด ฉันค่อนข้างมั่นใจว่าไม่จำเป็นต้องมีความคิดเห็นใด ๆ

J , ^{15 10} 9 ไบต์

+: :(*-:)

ลองออนไลน์!

รุ่นสองเท่า: ลองออนไลน์!

f : gสร้างคำกริยาที่เรียกใช้งานfเมื่อถูกเรียกด้วยอาร์กิวเมนต์หนึ่งตัวและgเมื่อถูกเรียกด้วย 2 อาร์กิวเมนต์ ดังนั้นของเราดำเนินการสองครั้ง+:กับแหล่งที่มาเดิมและ*-:เมื่อแหล่งที่มาเป็นสองเท่า

สิ่งนี้ทำงานได้เพราะรถไฟของคำกริยาสองตัวใน J กลายเป็นตะขอและf fดำเนินการเช่นเดียวกับy f (f y)ที่ y คืออินพุตต้นฉบับ ยิ่งไปกว่า*-:นั้นมันคือ "เบ็ด dyadic" ซึ่งทำงานโดยการคูณ*ARG ด้านซ้ายโดย ARG ครึ่ง-:ทางขวา ARG ด้านซ้ายจะเป็นอินพุตต้นฉบับและ ARG ด้านขวาจะเป็นอินพุตสองเท่าดังนั้นสิ่งนี้จะสร้างกำลังสองของอินพุตดั้งเดิม

คำตอบเดิม

J , 15 ไบต์

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

ลองออนไลน์!

รุ่นสองเท่า: ลองออนไลน์!

ในเวอร์ชั่นเดียวเรามีกริยาเดียวที่ใช้ Agenda @.ในการทำ if ... จากนั้นตรรกะ: ถ้าอาร์กิวเมนต์มีค่าเท่ากับตัวของมันเอง=~ให้เอาอาร์กิวเมนต์นั้นมาเพิ่มเป็นสองเท่า(+:@[)แล้วใช้อาร์กิวเมนต์และสองครั้ง

อย่างไรก็ตามเมื่อเราเพิ่มรหัสเป็นสองเท่าเราจะได้ตะขอ J โทรกริยาและใส่f yจากนั้นตะขอf fจะดำเนินการดังนี้:

y f (f y)

ซึ่งหมายความว่าตอนนี้อินพุตเดิมคือ arg ซ้ายและ arg ขวาคืออินพุตสองเท่า เนื่องจากสิ่งเหล่านี้จะไม่เท่ากัน=~จะคืนค่าเป็นเท็จในเวลานี้และตอนนี้เราจะดำเนินการแยกส่วนของวาระกล่าวคือ*:@]ซึ่งหมายถึง "ตาราง ARG ที่ถูกต้อง" และเนื่องจาก~ผันกลับอินพุตของคำกริยา dyadic, arg ที่เหมาะสมจะเป็นอินพุตดั้งเดิม

Python 3 , 60 ไบต์

Chunk size 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เมื่อเพิ่มเป็นสองเท่า)