ท้าทาย:

งานของคุณคือการเขียนโปรแกรม / ฟังก์ชั่น / ตัวอย่างให้มากที่สุดเท่าที่จะทำได้โดยแต่ละเอาต์พุต / พิมพ์ / ส่งคืนจำนวนเต็ม โปรแกรมแรกจะต้องส่งออกจำนวนเต็มที่1สอง2และอื่น ๆ

คุณไม่สามารถใช้อักขระซ้ำได้ระหว่างโปรแกรม ดังนั้นหากโปรแกรมแรกคือ: x==xคุณไม่สามารถใช้อักขระxและ=อีกครั้งในโปรแกรมอื่น ๆ หมายเหตุ: อนุญาตให้ใช้ตัวอักษรเดียวกันหลาย ๆ ครั้งในโปรแกรมเดียว

เกณฑ์การให้คะแนน:

ผู้ชนะจะได้รับการส่งที่นับได้สูงสุด ในกรณีที่มีการเสมอกันผู้ชนะจะเป็นผู้ส่งซึ่งใช้จำนวนไบต์น้อยที่สุด

กฎ:

• คุณสามารถใช้ภาษาเดียวสำหรับจำนวนเต็มทั้งหมดเท่านั้น
• อนุญาตให้มีตัวอย่าง
• เพื่อให้มันยุติธรรมตัวละครทุกตัวจะต้องได้รับการเข้ารหัสโดยใช้ไบต์เดียวในภาษาที่คุณเลือก
• ผลลัพธ์จะต้องเป็นทศนิยม คุณไม่สามารถส่งออกด้วยสัญกรณ์ทางวิทยาศาสตร์หรือรูปแบบอื่น ๆ การแสดงผลลอยตกลงตราบใดที่ตัวเลขทั้งหมดที่แสดง0ไว้ข้างหลังจุดทศนิยมเป็น ดังนั้นจึง4.000เป็นที่ยอมรับ ยอมรับความไม่ถูกต้องเนื่องจาก FPA ตราบเท่าที่ไม่ได้แสดงในเอาต์พุต
• ans =อนุญาตให้นำหน้าและต่อท้ายช่องว่างและขึ้นบรรทัดใหม่ได้
• คุณอาจไม่สนใจ STDERR ตราบใดที่เอาต์พุตที่ถูกต้องถูกส่งกลับไปยัง STDOUT
• คุณอาจเลือกที่จะส่งออกจำนวนเต็มไปยัง STDERR แต่เฉพาะในกรณีที่ STDOUT ว่างเปล่า
• สัญลักษณ์ภาษาอิสระ (เช่นLenguage ) ไม่ได้รับอนุญาต
• ตัวอักษรเป็นกรณีa != Aๆ ไป
• โปรแกรมจะต้องเป็นอิสระ
• ช่องว่างไม่สามารถนำกลับมาใช้ใหม่ได้
• คุณต้องใช้ตัวเลข ASCII ในผลลัพธ์

คำอธิบายได้รับการสนับสนุน!

JavaScript (ES7) คะแนน 17, 176 ไบต์

พวกเขาบอกว่ามันไม่สามารถทำได้ดังนั้นฉันจึงทำ: D (ขอบคุณความช่วยเหลือจาก @FullDecent มาก)

""**""
~(~/~//~/~/)/~/~/
3
4
!NaN- -!NaN- -!NaN- -!NaN- -!NaN
6
7
8
9
++[[]][+[]]+[+[]]
11
'lengthlength'.length
222>>2>>2
`${``^``}xE`^``
0XF
C=CSS==CSS;C<<C<<C<<C<<C
555555555555555555555%55

ตัวละครที่ไม่ได้ใช้:

#&,:?@ABDGHIJKLMOPQRTUVWYZ\_bcdfijkmopqrsuvwyz|

ฉันไม่คิดว่าเป็นไปได้ 18 แต่ฉันพูดเหมือนกันประมาณ 17 ...

คำอธิบาย

JavaScript เป็นภาษาที่พิมพ์อย่างอ่อนมาก หากคุณพยายามดำเนินการทางคณิตศาสตร์กับค่าที่ไม่ใช่ตัวเลข JS จะพยายามอย่างหนักที่สุดในการแปลงเป็นตัวเลขก่อน สิ่งนี้ช่วยให้ได้คำตอบที่น่าสนใจมากมาย ฉันพยายามหลีกเลี่ยงการใช้ตัวเลขให้มากที่สุดเพื่อใช้ในภายหลัง

1. **เป็นผู้ดำเนินการยกกำลังใน ES7 สตริงว่างเมื่อถูกบังคับให้มีจำนวนกลายเป็น0ดังนั้นการคำนวณ0 ** 0ซึ่งเป็น1ไปตามจาวาสคริปต์
2. ไร้สาระเล็กน้อย แต่มันได้ผล /~/เป็น regex ที่แท้จริงและ~/~/ผลตอบแทน-1ดังนั้นนี่คือ~(-1 / -1) / -1= ~(1) / -1= =-2 / -1 2(ให้เครดิตกับ@ GOTO0สำหรับแนวคิด)
3. 3ง่ายดาย
4. 4ตอนนี้เพียงแค่
5. NaNเป็น falsy เพื่อให้!NaNมีที่ซึ่งเทียบเท่ากับtrue 1การแสดงออกจึงกลายเป็น1 - -1 - -1 - -1 - -1= =1 + 1 + 1 + 1 + 15
6. 6ง่ายดาย
7. 7ง่ายดาย
8. 8ง่ายดาย
9. 9ง่ายดาย
10. สิ่งนี้ใช้เวทมนต์JSF ***เล็กน้อย +[]คือ0เพื่อ[[]][+[]]ส่งกลับองค์ประกอบแรกของ[[]](นั่นคือ[]) และการเพิ่มขึ้นนี้++ 1จากนั้น+[+[]]เพิ่มอาร์เรย์[0]ซึ่งจะบังคับให้เป็นสตริง"10"และทำให้
11. 11ง่ายดาย ฉันเคยใช้เป็น11&1111เวลา 3 และ33/311 จนกระทั่งฉันรู้อีกครั้งว่าฉันเป็นใบ้ ...
12. กลยุทธ์นี้จะทำงานอยู่กับจำนวนใด ๆ : สร้างสตริงของความยาวและการใช้งาน12.length
13. ฉันแค่ยุ่งกับ2s และ>s ในขณะที่ได้รับหนึ่งนี้ ผมโชคดีอีกครั้ง: 222 >> 2เป็น55และเป็น55 >> 213
14. อันนี้ค่อนข้างยุ่งยาก แนวคิดพื้นฐานคือการสร้าง14ใน hex ( 0xE) แต่เราต้องการตัวเลข0อื่น ๆ ดังนั้นแทนที่จะเราย่อหน้าผลของ``^``สตริงxE; สตริงที่ว่างเปล่าข่มขู่ไปยังหมายเลขที่เป็น0เช่นนี้จะส่งกลับ=0 ^ 0 0แล้วผลลัพธ์คือ XORed ด้วยสตริงว่างซึ่งแปลงทั้งสองค่าเป็นตัวเลข เป็น"0xE" ^ ""14
15. นี้เป็นเรื่องง่ายสวย: เป็นเลขฐานสิบหกตัวอักษรที่มีค่าของ0XF15
16. ที่ยากที่สุดของทั้งหมด? ก่อนอื่นเราตั้งค่าตัวแปรCเป็นCSS == CSS(นั่นคือtrue) จากนั้นเราจะใช้ผลและดำเนินการ<< Cครั้งที่สี่ซึ่งโดยทั่วไปคูณโดย12 ** 4
17. JavaScript เริ่มที่จะสูญเสียความแม่นยำจำนวนเต็มที่ 2 ⁵³ซึ่งจะช่วยให้555...555%55เพื่อกลับตัวเลขที่ไม่ได้เป็นหรือ0 5ฉันโชคดีมากที่ได้เล่นที่นี่

กลยุทธ์ที่สามารถใช้ได้กับหลายหมายเลข:

• -!NaNจะทำงานกับหมายเลขใด ๆ (ปัจจุบัน5) แม้ว่ามันจะมีขนาดใหญ่มากอย่างรวดเร็ว
• ~/~/จะทำงานกับหมายเลขใด ๆ (ปัจจุบัน2) แม้ว่ามันจะมีขนาดใหญ่มากเร็วมาก
• +[]จะทำงานกับจำนวนใด ๆ (ปัจจุบัน10) แม้ว่ามันจะไกลโดยที่ง่ายที่สุดในหรือ1011
• .length จะทำงานกับจำนวนใด ๆ
• `${-``}xE`-`` จะทำงานกับหมายเลขใด ๆ สวยมากถ้าคุณทำถูกต้อง
• C<<Cจะทำงานในอำนาจใด ๆ ของทั้งสอง (ปัจจุบัน16) หรือ int ใด ๆ |เลยถ้าคุณรวม

เยลลี่ , จำนวนเต็ม 47 ตัว, 519 ไบต์

e
BI$⁼#
⁾⁾⁾Ụ^/
ı***ıḞḞ
5
6
7
.::::
9
EȮ<
⁻GṘ
=`p`VV×`DQV
~A~A~A~A~A~A~A~A~A~A~A~A~A
⁷ṾṾṾw
⁴ḟ€⁴Ṁ
mmmmċ
ṭṭṭṭṭṭṭṭḍḄḄḄḄḄḄḄḄḄ
+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ
CNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNC
ĖḌĖḌ
ṫṣȦJṫȦ⁸ȦJ
22
“@ṃ»
!ḤḤ!
³HH
ØaM
;;;;;;;;;;;;;;;;;;;;;;;;;;;¬¬ḅ¬
irið8c
⁶ḲĠṂ°İṂĊ
œṡ¹ẆẆTUṖṖṖṖP
ȷ½RṪ
LµdddddµFL
33
WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWŒḊ
ẇɓæ«æ«æ«æ«æ«|æ«|
⁹ṚḢ²
‘‘‘0‘‘‘‘‘‘‘
’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’ạ
-____---__________
”(O
⁵ḶxḶ⁵ị⁵ḶxḶḣṢ
⁽{ʂ%⁽{}
ẊẠżv©żvżvżvọ®®Ạżvżvżvọ®
44
111111l11&K1111111Kl11&
,SS¶ỊỊ,ÇS¶ÇÑÇÇÇÑ
ÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆn

ทุกบรรทัดเป็นโปรแกรมที่แยกต่างหากและสมบูรณ์

ลองออนไลน์! (รวมถึงชุดทดสอบและตัวตรวจแยก)

มันทำงานอย่างไร

ทุกโปรแกรมแบบเต็มโดยไม่มีข้อโต้แย้งบรรทัดคำสั่งรันลิงค์หลัก (กำหนดในบรรทัดสุดท้าย) niladically คือไม่มีอินพุต หากลิงก์แรกในเชนคือ nilad ลิงก์นั้นจะถูกใช้เรียกใช้และทั้งอาร์กิวเมนต์หลักและค่าส่งคืนจะถูกตั้งค่าเป็นผลลัพธ์ หากลิงก์แรกในเชนคือ monad หรือ dyad จะไม่ถูกใช้และใช้อาร์กิวเมนต์และค่าส่งคืน0โดยนัยแทน ในทั้งสองกรณีส่วนที่เหลือของห่วงโซ่จะดำเนินการ monadically

วุ้นมีผลในหลายกรณี ยวดอาร์เรย์แบบซิงเกิลถูกพิมพ์โดยไม่มีเครื่องหมายวงเล็บล้อมรอบดังนั้น42และ[42]และแยกไม่ออกหลังการพิมพ์ เราจะใช้มันหลายครั้ง

1 - 10

e

อยู่ทดสอบอะตอมถ้าค่าตอบแทน0เป็นอาร์กิวเมนต์0 มันไม่ดังนั้นeผลตอบแทนที่1

BI$⁼#

BI$เป็น quicklink โดยเฉพาะโซ่แบบ monadic ที่เกิดขึ้นจากการ$จัดกลุ่มอะตอมไบนารีBและกลุ่มอะตอมที่เพิ่มขึ้นIอย่างรวดเร็ว รวมพวกมันจะแปลงจำนวนเต็มเป็นอาร์เรย์ของตัวเลขในฐาน 2 จากนั้นคำนวณความแตกต่างไปข้างหน้าของตัวเลขที่ได้ หากอาร์เรย์มีองค์ประกอบเดียวเท่านั้นจะไม่มีความแตกต่างไปข้างหน้าและIส่งกลับอาร์เรย์ว่าง (เท็จ); หากมีอย่างน้อยสองหลักIส่งกลับอาร์เรย์ที่ไม่ว่างเปล่า (ความจริง)

quick #ใช้ quicklink ก่อนหน้านี้และนำไปใช้กับ0 , 1, 2, …จนกระทั่งพบว่ามีการจับคู่ที่เพียงพอและคืนค่าอาร์เรย์ของการจับคู่ จำนวนเงินที่ต้องคำนวณโดย⁼ซึ่งเปรียบเทียบค่าตอบแทน / อาร์กิวเมนต์0ตัวเองยอม1 ดังนั้นโปรแกรมทั้งหมดจึงคืนค่า[2]ซึ่งเป็นจำนวนเต็มไม่เป็นลบตัวแรกที่มีตัวเลขสองหลักในฐาน 2

⁾⁾⁾Ụ^/

⁾⁾⁾เป็นสตริงตัวอักษรเฉพาะสตริง⁾⁾ เกรดขึ้นอะตอมỤเรียงลำดับดัชนีของตนโดยค่าที่สอดคล้องกันของพวกเขา; ตั้งแต่ตัวละครทั้งสองมีค่าเท่ากันนี้ผลตอบแทนถัวเฉลี่ย[1, 2] อาร์เรย์ส่งผลให้มีการลดลงด้วยบิต XOR ^/ดังนั้นโปรแกรมทั้งหมดส่งกลับ3

ı***ıḞḞ

ıเริ่มต้นการโต้แย้งและผลตอบแทนคุ้มค่าให้กับหน่วยจินตภาพฉัน *เป็นรูปแบบเลขชี้กำลังซึ่งมีค่าอาร์กิวเมนต์เริ่มต้นที่ถูกต้องสำหรับอาร์กิวเมนต์ของลิงก์หลัก ดังนั้น***ıคำนวณ((i ^ฉัน ) ^ฉัน ) ^ฉัน ≈ 4.81 + 0iที่Ḟอะตอม ( ชั้นสำหรับอาร์กิวเมนต์จริงส่วนจริงสำหรับคนที่ซับซ้อน) คำนวณส่วนจริง ( 4.81 ) จากนั้นḞชั้นยอม4

5
6
7

โปรแกรมทั้งสามนี้ประกอบด้วยตัวอักษรเดียวและทำสิ่งที่คุณคาดหวัง

.::::

ตัวอักษร.เป็นชวเลขสำหรับ0.5และเริ่มต้นการโต้แย้งและค่าตอบแทน แบ่งจำนวนเต็มคู่ของ ( :) ค่าเริ่มต้นของการโต้แย้งสิทธิในการโต้แย้งการเชื่อมโยงหลักเพื่อ::::คำนวณ0.5 / 0.5 / 0.5 / 0.5 / 0.5ผลผลิต8

9

ตัวอักษรอื่น

EȮ<

ทั้งหมดเท่ากับอะตอมEผลตอบแทนที่1ถ้าองค์ประกอบทั้งหมดในการโต้เถียงที่มีความเท่าเทียมกันและ0หากไม่ได้ อาร์กิวเมนต์จำนวนเต็มZจะเลื่อนตำแหน่งให้เป็น[Z]ดังนั้นEจะให้ผลตอบแทน1สำหรับอาร์กิวเมนต์นัย0

ตอนนี้เอาต์พุตอะตอมจะȮพิมพ์1ถึง STDOUT จากนั้นเราจะเปรียบเทียบ1กับข้อโต้แย้งโดยปริยาย0ใช้น้อยกว่า<อะตอม ผลลัพธ์คือ(1 <0) = 0และถูกพิมพ์โดยปริยายเมื่อโปรแกรมเสร็จสิ้น

11 - 20

⁻GṘ

ตารางอะตอมGพยายามที่จะทำให้ตารางสายตาที่ชื่นชอบจากอาร์กิวเมนต์ สำหรับอาร์กิวเมนต์จำนวนเต็มธรรมดา (ที่นี่: 0 ) มันจะล้อมในอาเรย์ แบนไม่เท่ากับอะตอม⁻เปรียบเทียบอาร์กิวเมนต์นัย0กับผลที่ได้ไปทางขวา ( [0] ) ผลผลิต1ตั้งแต่อาร์กิวเมนต์จะไม่เท่ากัน ตัวแทนอะตอมṘพิมพ์1เพื่อ STDOUT และผลตอบแทนของ ในตอนท้ายของโปรแกรมค่าตอบแทนขั้นสุดท้ายจะถูกพิมพ์โดยปริยายดังนั้นเราจึงจบลงด้วยการส่งออกของ11

=`p`VV×`DQV

ความรวดเร็วในตัวเอง`เปลี่ยนสีย้อมให้กลายเป็น monad โดยเรียกมันว่ามีอาร์กิวเมนต์ซ้ายและขวาเหมือนกัน ครั้งแรก=`เปรียบเทียบอาร์กิวเมนต์นัย0กับตัวเองยอม1

ผลิตภัณฑ์ Cartesianอะตอมpคาดว่ารายการเป็นข้อโต้แย้งของมันจึงส่งเสริมเลขที่1ในช่วง[1, ... , 1] = [1] p`ใช้ผลิตภัณฑ์ Cartesian ของ[1]และตัวเองยอม[[1, 1]]

EVALอะตอมVเปลี่ยนอาร์เรย์ทั้งหมดแบน (ที่มีเฉพาะตัวเลขและตัวอักษร) เป็นสตริงแล้วประเมินสตริงส่งผลให้โปรแกรม Jelly niladic [[1, 1]]มีการเปิดครั้งแรกใน[“11”]แล้วVevals สตริงยอม[11] อีกครั้งVจะเปิดอาร์เรย์นี้ลงใน"11"แล้ว evals มันจะให้ผลผลิต11

ตอนนี้×`คูณ11กับตัวเองให้ผลผลิต121 ทศนิยมอะตอมหัน121เข้า[1, 2, 1]ที่ไม่ซ้ำกันอะตอมQทิ้งที่สอง1และVอีกครั้งจะเปลี่ยนรายชื่อของตัวเลขลงในจำนวนเต็มที่เกิดจากการเชื่อมโยงพวกเขากลับมา12

~A~A~A~A~A~A~A~A~A~A~A~A~A

~คือbitwise NOT atom ด้วยสองของเลขคณิตสมบูรณ์ก็แผนที่อาร์กิวเมนต์Zเพื่อ~ Z = - (Z + 1) Aเป็นค่าสัมบูรณ์อะตอมจึงแผนที่- (Z + 1) = Z + 1 ด้วยค่าตอบแทนเริ่มต้น0 , สิบสำเนาของ~Aผลตอบแทน13

⁷ṾṾṾw

ค่าคงที่⁷เก็บอักขระบรรทัดใหม่'\ n'และเริ่มต้นอาร์กิวเมนต์และค่าส่งคืน

unevalอะตอมṾพยายามที่จะสร้างการแสดงสตริงของอาร์กิวเมนต์Zดังกล่าวว่าโปรแกรม Jelly ประกอบด้วยรหัสนี้จะกลับZ

การเรียกครั้งแรกตามหน้าที่ส่งคืนสตริง"" \ n "ซึ่งเป็นตัวอักษรที่แท้จริง การโทรครั้งต่อไปจะส่งคืน""”,” \ n " - ตัวอักษรคู่หนึ่ง การโทรครั้งที่สามและครั้งสุดท้ายจะส่งกลับ"", ",", ",,", "\ n" - กลุ่มของตัวอักษรห้าตัว

สุดท้ายดัชนีหน้าต่างอะตอมwส่งเสริมการโต้แย้งสิทธิของ'\ n'สตริง"\ n"และหาดัชนีแรกของสตริงย่อยที่เริ่มต้นด้วย"\ n" นี้จะส่งกลับ14

⁴ḟ€⁴Ṁ

⁴เป็นค่าคงที่ 16 ตัวกรอง quicklink กรองแต่ละตัว ( ḟ€) ส่งเสริมการโต้แย้งซ้าย16ถึงช่วง[1, …, 16]จากนั้นวนซ้ำองค์ประกอบต่างๆ

สำหรับแต่ละองค์ประกอบZ , ḟ⁴จะถูกดำเนินการครั้งแรกในการส่งเสริมZเพื่อ[Z]แล้วลบทั้งหมด (ถ้ามี) การเกิดขึ้นของ16 นี้อัตราผลตอบแทนอาร์เรย์[[1], [2], ... , [14] [15], []]ที่อาร์เรย์สุดท้ายคือว่างเปล่าเพราะมันมี16

สุดท้ายสูงสุดอะตอมṀเลือก[15]

mmmmċ

modularอะตอมm- เรียกว่ามีข้อโต้แย้งx (อาร์เรย์) และY (จำนวนเต็ม) มักจะใช้เวลาทุก| Y | ^THองค์ประกอบของxที่เริ่มต้นด้วยก่อนถ้าY> 0กับที่ผ่านมาหากY <0 อย่างไรก็ตามเมื่อy = 0มันจะคืนค่าx ที่ตัดกับการย้อนกลับ

อาร์กิวเมนต์จำนวนเต็มซ้าย0คือการส่งเสริมให้คนแรกที่จะ[0] สำเนาแรกของmconcatenates [0]กับตัวเองยอม[0, 0] สำเนาที่เหลือจะเปลี่ยนผลลัพธ์เป็น[0, 0, 0, 0]จากนั้น[0, 0, 0, 0, 0, 0, 0, 0]และในที่สุด[0, 0, 0, 0, 0, 0, 0 , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

ที่ผ่านมานับอะตอมċนับจำนวนครั้งที่ส่ออาร์กิวเมนต์0ปรากฏในอาร์เรย์ที่เกิดขึ้นกลับ16

ṭṭṭṭṭṭṭṭḍḄḄḄḄḄḄḄḄḄ

ṭเป็นตะปูอะตอมและผนวกอาร์กิวเมนต์ซ้ายไปขวาหนึ่งของมัน ตั้งแต่ṭและต่อไปนี้ḍเป็น dyadic ทั้งหมดเรียกร้องให้ṭผ่านอาร์กิวเมนต์นัย0ṭเป็นอาร์กิวเมนต์สิทธิที่จะ การโทรครั้งแรกจะส่งกลับ[0, 0] , ครั้งที่สอง[0, [0, 0]และครั้งที่แปดและครั้งสุดท้าย[0, [0, [0, [0, [0, [0, [0, [0] 0]]]]]]]]

ḍเป็นอะตอมที่แบ่งแยกได้ สำหรับอาร์กิวเมนต์xและyมันจะส่งกลับ1คือxคือหารด้วยy , 0ถ้าไม่ใช่ Ḅเป็น no-op สำหรับจำนวนเต็มดังนั้นḍḄทดสอบ0สำหรับการหารด้วยจำนวนเต็มแต่ละตัวในอาร์เรย์ที่สร้างขึ้น 0คือหารด้วยตัวเองเพื่อให้เราได้รับ[1, [1, [1, [1, [1, [1, [1, [1, 1]]]]]]]]

ตอนนี้อะตอมแบบไบนารี่Ḅทำงานบนอาเรย์แบน สำหรับคู่[a, b]มันก็ส่งกลับ2a + B ดังที่ได้กล่าวไว้ก่อนหน้านี้Ḅคือไม่มี-op สำหรับจำนวนเต็ม: อาร์กิวเมนต์จำนวนเต็มคจะเลื่อนตำแหน่งให้เป็น[C]และ[C]ในใด ๆฐานเป็นเพียงค

สายแรกที่จะḄช่วยลด[1, 1]ไป3จึงยอม[1, [1, [1, [1, [1, [1, [1, 3]]]]]]] สายต่อไปจะช่วยลด[1, 3]ไป5อย่างใดอย่างหนึ่งต่อไป[1, 5]ไป7และอื่น ๆ จนเก้าḄผลตอบแทน17

+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ

Ṇเป็นแบนตรรกะไม่อะตอมและแผนที่อาร์กิวเมนต์นัย0ที่จะ1 +เป็นอะตอมการบวกดังนั้นแต่ละสิบแปดสำเนาของการ+Ṇเพิ่มค่าส่งคืนก่อนหน้า ( 0เริ่มต้น) โปรแกรมทั้งหมดจึงส่งกลับ18

CNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNC

Cเป็นส่วนประกอบอะตอมและแผนที่อาร์กิวเมนต์Zไป1-z Nเป็นลบล้างอะตอมและแผนที่อาร์กิวเมนต์Zเพื่อ-z ร่วมกันCNแผนที่Zไป- (1-z) = Z-1ดังนั้นแปดสำเนาเปิดอาร์กิวเมนต์นัย0เข้า-18 แอพลิเคชันสุดท้ายของอัตราผลตอบแทนC1 - (-18) = 19

ĖḌĖḌ

การระบุอะตอมĖระบุรายการในอาร์เรย์สร้างคู่ดัชนีค่า อาร์กิวเมนต์นัย0จะเลื่อนตำแหน่งให้เป็น[0]แล้วĖอัตราผลตอบแทน[[1, 0]] undecimalอะตอมแปลงอาร์เรย์แบนจากฐาน 10 ถึงจำนวนเต็มยอม[10]ในกรณีนี้โดยเฉพาะอย่างยิ่ง

สายที่สองที่จะĖแปลง[10]เข้า[[1, 10]]ซึ่งสองḌในที่สุดก็เปลี่ยนไป[20]

21 - 30

ṫṣȦJṫȦ⁸ȦJ

หางอะตอมṫ(เป็นคู่) เลือก postfix ของการโต้แย้งทางด้านซ้ายของตนที่เริ่มต้นที่ดัชนี (1-based และแบบแยกส่วน) ที่ระบุไว้ในข้อโต้แย้งสิทธิของการส่งเสริมการโต้แย้งจำนวนเต็มซ้ายxไป[x] เรียกว่าเมื่อมีข้อโต้แย้งทั้งการตั้งค่าเป็น0 , ṫส่งกลับ[0]

ใด ๆ และทั้งหมดอะตอมȦผลตอบแทนที่1ถ้าอาร์กิวเมนต์เป็น truthy และไม่มีเลขที่ระดับความลึกใด ๆ0มิฉะนั้น ที่นี่เราก็ใช้มันเป็นฟังก์ชั่นตัวตนที่จะกลับอาร์กิวเมนต์นัย0 การแบ่งที่อะตอมṣพาร์ติชั่นอาร์กิวเมนต์ซ้าย[0]ที่การเกิดขึ้นของอาร์กิวเมนต์ที่ถูกต้อง0ดังนั้นมันจึงส่งกลับ[[], []]ที่นี่

ดัชนีอะตอมJทิ้งองค์ประกอบของค่าตอบแทนและแทนที่ด้วยดัชนีของพวกเขายอมช่วง[1, 2]ในกรณีนี้โดยเฉพาะ Ȧและṫการทำงานทั้งเป็นก่อนเพื่อให้พวกเขาลด[1, 2]เพื่อ postfix ที่เริ่มต้นที่ดัชนีสุดท้ายยอม[2]

ในการเชื่อมโยง niladic, คง⁸ถือ[] นี่คือ nilad ที่เข้าใจไม่ได้นั่นคือมันไม่เข้ากับห่วงโซ่ แต่อย่างใด เป็นผลให้ค่าส่งคืนก่อนหน้า ( [2] ) ถูกพิมพ์ไปที่ STDOUT จากนั้นแทนที่ด้วยค่าของ nilad ( [] )

ตั้งแต่[]คือ falsy, Ȧแปลงมันเป็น0 Jอะตอมส่งเสริม0ไป[0]แล้วส่งกลับรายการของดัชนีของตน ( [1] ) ซึ่งจะมีการพิมพ์โดยปริยายเมื่อเสร็จสิ้นโปรแกรม

22

ตัวอักษรอื่น Repdigits ดูเหมือนจะเป็นสถานที่ที่ดีที่สุดในการใช้พวกเขา

“@ṃ»

สิ่งนี้ใช้การบีบอัดสตริง inbuilt ของ Jelly ดัชนีของ@และMในหน้ารหัส Jelly คือ64และ220และตัวอักษรของสตริงสามารถมี 250 ตัวอักษรแตกต่างกันดังนั้นนี่เป็นครั้งแรกคำนวณจำนวนเต็ม250 × 65 + 220 = 16,470

16470หารด้วย 3 ดังนั้นผลหาร16470/3 = 5490เข้ารหัสอักขระ ASCII ที่พิมพ์ได้หรือตัวป้อนบรรทัด มี 96 เหล่านี้และ5490 = 96 × 57 + 18ซึ่งหมายความว่าเราได้ถอดรหัสอักขระ ASCII พิมพ์ที่ 0-based ดัชนี18ซึ่งเป็น'2'

เราจะเหลือ57ซึ่งยังเป็นที่หารด้วย3ดังนั้นเชาวน์57/3 = 19 = 96 × 0 + 19เข้ารหัสอักขระ ASCII พิมพ์ที่ 0-based ดัชนี18ซึ่งเป็น'3'

ใบนี้0 ; กระบวนการถอดรหัสหยุดลง อักขระที่สร้างถูกต่อกันเป็นรูปแบบ"23"

!ḤḤ!

ปัจจัยอะตอม!เปลี่ยนอาร์กิวเมนต์นัย0เข้า1 สองสวดของunhalveอะตอมḤเปิด1เข้า2แล้ว2เข้า4 ในที่สุด!คำนวณ4! = 24

³HH

ในกรณีที่ไม่มีข้อโต้แย้งบรรทัดคำสั่งคง³ถือ100 สองสวดของHผลัด100เข้า50แล้ว50เข้า25

ØaM

ค่าคงที่Øaถืออักษรตัวพิมพ์เล็ก สูงสุดอะตอมMอัตราผลตอบแทนดัชนีทุกรายการสูงสุดและตั้งแต่Zเป็นตัวอักษรตัวพิมพ์เล็กใหญ่ที่สุดผลที่ได้คือ[26]

;;;;;;;;;;;;;;;;;;;;;;;;;;;¬¬ḅ¬

อะตอมของconcatenate ยี่สิบหกสำเนาต่อ;ค่าส่งคืนเริ่มต้น0และยี่สิบหกอินสแตนซ์ของอาร์กิวเมนต์เริ่มต้น0ซึ่งสร้างอาร์เรย์จำนวน 27 ศูนย์

¬เป็นอะตอมของNOT แบบโลจิคัลดังนั้น;¬ผนวก1กับอาร์เรย์ของศูนย์ รายการถัดไปจะเป็นการ¬ปฏิเสธองค์ประกอบทั้งหมดในอาร์เรย์ทำให้เรามีอาร์เรย์ 27 รายการและ 1 ศูนย์

ḅเป็นอะตอมunbaseและแปลงอาร์เรย์หลักจากอาร์กิวเมนต์ซ้ายจากฐานที่ระบุในอาร์กิวเมนต์ขวาเป็นจำนวนเต็ม ḅ¬แปลงจาก unary เป็นจำนวนเต็มดังนั้นมันจึงทำการรวม สำหรับอาร์เรย์ของ 27 คนที่ส่งกลับ27

irið8c

ดัชนีของอะตอมiส่งเสริมอาร์กิวเมนต์ซ้าย0ไป[0]แล้วหาดัชนีของการโต้แย้งสิทธิของตน0ในอาร์เรย์ที่ยอม1

ช่วงอะตอมrสร้างน้อยไปมากหรือมากไปน้อยช่วงจากมันเหลืออาร์กิวเมนต์หนึ่งที่เหมาะสมของมัน อาร์กิวเมนต์ที่เหมาะสมเป็นอาร์กิวเมนต์นัย0ดังนั้นอัตราผลตอบแทนนี้[1, 0] ภาวนาที่สองของการiพบว่าดัชนีของ0ใน[1, 0]ยอม2

ðเริ่มห่วงโซ่ dyadic ใหม่ เนื่องจาก chain ก่อนหน้านี้เป็น niladic ทั้งอาร์กิวเมนต์ซ้ายและขวาของ chain นี้จะเท่ากับค่าส่งคืนของ chain แรก ( 2 ) cในอะตอมชุดค่าผสม ด้วยอาร์กิวเมนต์ซ้าย8และการโต้แย้งสิทธิ2จะนับทุกที่ไม่ซ้ำกันเรียงลำดับ 2 การรวมกันของชุดของ8องค์ประกอบกลับ8C2 = 8! / (6! 2!) = 28

⁶ḲĠṂ°İṂĊ

คง⁶ถืออักขระช่องว่างและตั้งข้อโต้แย้งและผลตอบแทนคุ้มค่าให้กับ'' คำอะตอมḲส่งเสริมตัวละคร''เป็นสตริงเดี่ยว""และแยกมันในพื้นที่น่วม[[] []]

กลุ่มอะตอมĠกลุ่มดัชนีทุกองค์ประกอบที่เท่าเทียมกัน เนื่องจากองค์ประกอบทั้งสองของค่าส่งคืนล่าสุดมีค่าเท่ากันจึงส่งคืน[[1, 2]]ที่นี่ ขั้นต่ำอะตอมสารสกัดจากน้อยที่สุด (เท่านั้น) องค์ประกอบของอาร์เรย์นี้ยอม[1, 2]

ระดับอะตอม°แปลงจำนวนเต็มทั้งจากองศา sexagesimal เรเดียนยอม1 °×2π / 360 ° = π / 180และ2 °×2π / 360 ° = π ผกผันอะตอมเตะแปรผกผันการคูณผลผลิต180 / π≈ 57.3และ90 / π≈ 28.6

จากนั้นṂอีกครั้งใช้เวลาอย่างน้อยยอม28.6 สุดท้ายceilอะตอมĊแปลง28.6ลงในวันที่ 29

œṡ¹ẆẆTUṖṖṖṖP

ตัวตนของอะตอม¹ส่งกลับ0สำหรับอาร์กิวเมนต์นัย0 แยกรอบอะตอมœṡส่งเสริมทั้งสองของอาร์กิวเมนต์ (ทั้ง0 ) ไป[0]แล้วแยก[0]รอบ subarrays ติดกันเท่ากับ[0] อัตราผลตอบแทนนี้[[] []]

เลื่อนหน้าต่างอะตอมẆสร้าง subarrays ต่อเนื่องกันทั้งหมดของอาร์กิวเมนต์ ตัวอย่างแรกเปลี่ยน[[], []]เป็น[[]], [[]], [[], []]] , ตัวอย่างที่สองเปลี่ยน[[[]], [[]], , []]]เป็น
[[[[]]], [[]], [[]], [] []], [[[]], [[]] [] []]] [[[]], [[]], [[] []]]]

จริงอะตอมTแสดงรายการดัชนีทุกองค์ประกอบ truthy ไม่มีของอาร์เรย์ในระดับแรกว่างเปล่าดังนั้นจึงอัตราผลตอบแทนนี้[1, 2, 3, 4, 5, 6] คว่ำอะตอมUกลับอาร์เรย์นี้ยอม[6, 5, 4, 3, 2, 1]

สี่สำเนาของป๊อปอะตอมṖลบช่วงสี่องค์ประกอบที่ออกจากเราด้วย[6, 5] ในที่สุดผลิตภัณฑ์อะตอมPแปลงอาร์เรย์นี้ในวันที่ 30

31 - 40

ȷ½RṪ

ȷเป็นชวเลข1 × 10 ³ = 1000 รากอะตอม½อัตราผลตอบแทน31.6ซึ่งช่วงอะตอมRเปลี่ยนเป็น[1, ... , 31] ในที่สุดหางอะตอมṪสารสกัดจากองค์ประกอบสุดท้ายกลับมาวันที่ 31

LµdddddµFL

ยาวอะตอมLส่งเสริมการโต้แย้งโดยปริยาย0ไป[0] , แล้วจะใช้เวลาความยาวที่จะให้ผลผลิต1 µเริ่มห่วงโซ่ monadic ใหม่และผลลัพธ์1กลายเป็นอาร์กิวเมนต์

สำหรับอาร์กิวเมนต์xและy ที่ที่divmodอะตอมdอัตราผลตอบแทน[x / y, x% Y] การโทรแต่ละครั้งจะมีy = 1ดังนั้นผลที่ได้จะเป็น[x, 0]

สายแรกจะเริ่มต้นด้วยx = 1น่วม[1, 0] dดำเนินการกับจำนวนเต็มเท่านั้นดังนั้นจึง vectorizes ในการโทรตามมา การโทรครั้งที่สอง[[1, 0], [0, 0]] , ครั้งที่สาม[[1, 0], [0, 0]], [0, 0], [0, 0]] , และอันที่ห้าและสุดท้ายคืออาร์เรย์ของความลึก 5 ที่มีหนึ่งและ 31 ศูนย์

µอีกครั้งจะเริ่มต้นโซ่ monadic ใหม่และอาร์เรย์จากก่อนจะกลายเป็นอาร์กิวเมนต์ แบนอะตอมFunnests อาร์เรย์นี้ยอมอาร์เรย์แบนของหนึ่งเดียวและ 31 เลขศูนย์ สุดท้ายLต้องใช้ความยาวของผลกลับ32

33

repdigit อีกตัวอักษรอื่น

WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWŒḊ

ตัวอย่างของแต่ละห่ออะตอมแปลงอาร์กิวเมนต์Zเข้า[Z] ด้วยค่าส่งคืนเริ่มต้นที่0ทั้ง 34 อินสแตนซ์ให้ผลตอบแทนร่วมกัน[[[[[[[[[[[[[[]] [] [] [] [] [] [] [] [การควบคุมอย่างต่อเนื่อง [อย่างสำคัญอย่างหนึ่ง] ]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]] ในที่สุดความลึกอะตอมŒḊคำนวณความลึกสูงสุดของอาร์เรย์ที่เกิดขึ้นกลับ34

ẇɓæ«æ«æ«æ«æ«|æ«|

หน้าต่างอยู่อะตอมẇส่งเสริมทั้งสองของอาร์กิวเมนต์ (ทั้งค่าเริ่มต้น0 ) ไป[0]แล้วการทดสอบถ้า ** [0] ** เกิดขึ้นเป็น subarray ต่อเนื่องกันของ[0] มันไม่ดังนั้นẇผลตอบแทนที่1

ɓเริ่มห่วงโซ่ dyadic ใหม่ เนื่องจาก chain ก่อนหน้านี้เป็น niladic อาร์กิวเมนต์ทั้งซ้ายและขวาของ chain นี้จะเท่ากับค่าส่งคืนของ chain แรก ( 1 ) โซ่ใช้ประโยชน์จากอะตอมที่แตกต่างกันสองแบบคือบิตฮาร์ตซ้าย ( æ«) และบิตหรือ OR ( |)

โซ่ dyadic ที่เริ่มต้นด้วยสามหรือมากกว่านั้นเริ่มแรกเรียกว่า dyad แรกกับข้อโต้แย้งของโซ่ นี่นี้จะช่วยให้1 << 1 = 2 หกกลุ่มที่ตามมาจะถูกจัดกลุ่มเป็นคู่ (เรียกว่าส้อม ) ซึ่งกลุ่มที่อยู่ด้านขวาสุดจะถูกเรียกก่อนด้วยอาร์กิวเมนต์ของโซ่จากนั้นกลุ่มที่อยู่ทางซ้ายสุดจะถูกเรียกด้วยค่าส่งคืนก่อนหน้าทั้งสองด้าน

สำหรับการæ«æ«ที่เราได้รับ2 << (1 << 1) = 2 << 2 = 8 จากนั้นæ«æ«คำนวณ8 << (1 << 1) = 8 << 2 = 32 ตอนนี้|æ«รับเรา32 | (1 << 1) = 32 | 2 = 34

ในที่สุด trailing |จะทำหน้าที่คล้ายhookและถูกเรียกด้วยค่าส่งคืนก่อนหน้าเป็นอาร์กิวเมนต์ด้านซ้ายและอาร์กิวเมนต์ด้านขวาของ chain เป็นค่าที่ถูกต้อง สิ่งนี้ส่งคืน34 | 1 = 35

⁹ṚḢ²

ในกรณีที่ไม่มีการโต้แย้งที่สองคง⁹ถือ256 กลับอะตอมส่งเสริม256อาร์เรย์[2, 5, 6]และฝืนมันจะให้ผลผลิต[6, 5, 2] จากนั้นหัวอะตอมḢสารสกัดจากองค์ประกอบแรกและตารางอะตอม²ผลตอบแทน ** 6² = 36 *

‘‘‘0‘‘‘‘‘‘‘

เพิ่มอะตอม‘เพิ่มอาร์กิวเมนต์โดย1เพื่อ‘‘‘เปิดค่าตอบแทนเริ่มต้น0เข้า3 0ต่อไปนี้เป็น nilad ที่หาตัวจับยากเช่นมันไม่เข้ากับห่วงโซ่ แต่อย่างใด เป็นผลให้ค่าส่งคืนก่อนหน้า ( 3 ) ถูกพิมพ์เป็น STDOUT จากนั้นแทนที่ด้วยค่าของ nilad ( 0 )

ต่อไปนี้7สำเนาของ‘เทิร์นนี้0ลงใน7ซึ่งจะมีการพิมพ์โดยปริยายเมื่อเสร็จสิ้นโครงการ

’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’ạ

พร่องอะตอม’decrements โต้แย้งโดย1ดังนั้นสามสิบแปดสำเนาเปิดค่าตอบแทนเริ่มต้น0เข้า-38 ความแตกต่างแน่นอนอะตอมạคำนวณความแตกต่างไม่ได้ลงนามระหว่าง-38และอาร์กิวเมนต์นัย0กลับ38

-____---__________

-เป็นชวเลข-1และตั้งข้อโต้แย้งและผลตอบแทนคุ้มค่าการเชื่อมโยงที่จะ-1 แต่ละ_ตัวอย่างของอะตอมการลบ dyadic ซึ่งอาร์กิวเมนต์ที่ถูกต้องจะมีค่าเริ่มต้นเป็น-1หากไม่มี

ครั้งแรก-____-คำนวณ(-1) - (-1) - (-1) - (-1) - (-1) = 3 -1ต่อไปนี้เป็น nilad ที่ไม่สามารถเข้าใจได้ดังนั้นค่าส่งคืนก่อนหน้า ( 3 ) จะถูกพิมพ์ไปยัง STDOUT แล้วแทนที่ด้วยค่าของ nilad ( -1 )

ถัดไป-_คำนวณ(-1) - (-1) = 0โดยที่ตัวอักษร-ตั้งค่าอาร์กิวเมนต์ซ้ายของ_และใช้ค่าส่งคืนเป็นค่าที่ถูกต้อง เก้าสำเนาต่อไปนี้ของการ_ลบอาร์กิวเมนต์เริ่มต้น-1จากค่าส่งคืนผลผลิต9ซึ่งจะถูกพิมพ์โดยปริยายเมื่อโปรแกรมเสร็จสิ้น

”(O

”(เป็นตัวละครที่ตัวอักษรและลำดับอะตอมOเงยหน้าขึ้นมองจุดรหัส Unicode ของผลผลิต40

41 - 47

⁵ḶxḶ⁵ị⁵ḶxḶḣṢ

ในกรณีที่ไม่มีอาร์กิวเมนต์บรรทัดคำสั่งที่สามคง⁵ถือ10 unlengthอะตอมḶสร้างช่วง 0-based โดยเฉพาะ[0, ... , 9]สำหรับอาร์กิวเมนต์10เพื่อให้ทั้งสองด้านของการทำซ้ำในสถานที่xอะตอม การจับคู่หลังองค์ประกอบของอาร์กิวเมนต์ซ้ายกับการทำซ้ำของขวาหนึ่งและทำซ้ำองค์ประกอบแต่ละครั้งจำนวนที่สอดคล้องกัน ด้วย[0, …, 9]เป็นทั้งอาร์กิวเมนต์ซ้ายและขวาเราจึงได้ศูนย์ศูนย์หนึ่งหนึ่งสองสอง ฯลฯ

ดัชนีลงในอะตอมịเรียกองค์ประกอบของการโต้แย้งสิทธิของตนที่ดัชนีที่ระบุไว้ในหนึ่งซ้าย ด้วยอาร์กิวเมนต์ซ้าย10 ( ⁵ด้านซ้าย) และการโต้แย้งสิทธิ[1, 2, 2, 3, 3, 3, 4, 4, 4, 4, ... , 9] (ผลก่อนหน้า) นี้จะช่วยให้4

chain จนถึงจุดนี้ตามด้วย nilad ที่ไม่สามารถเข้าใจ⁵ได้ดังนั้นค่าส่งคืนก่อนหน้า ( 4 ) ในพิมพ์ไปยัง STDOUT ค่าส่งคืนถูกตั้งค่าเป็น10และส่วนที่เหลือของ chain จะแยกวิเคราะห์ตามปกติ

ก่อนที่⁵ḶxḶจะให้ผลผลิตอาร์เรย์[1, 2, 2, 3, 3, 3, 4, 4, 4, 4, ... , 9] เวลานี้เราเรียกว่าเรียงอะตอมṢในอาร์กิวเมนต์10ซึ่งส่งเสริม10ไป[1, 0]แล้วเรียงมันให้ผลผลิต[0, 1] หัว dyadicอะตอมตอนนี้เรียกคำนำหน้าของความยาว0และ1จากผลการไปทางซ้ายออกจากเราด้วย[[] [1]] เมื่อพิมพ์จะไม่มีสิ่งใดนอกจาก1จะยังคงปรากฏให้เห็น

⁽{ʂ%⁽{}

⁽และตัวละครสองตัวต่อไปนี้เป็นตัวอักษรตัวเลข ถ้าเจและkเป็นจุดรหัสของพวกเขาในหน้ารหัสวุ้นและ(ญ, k) <(124, 250)ที่เราได้รับจำนวนเต็ม1,001 + 250J + K จุดโค้ดของ'{' , '}'และ'ʂ'คือ123 , 125และ167ดังนั้นตัวอักษรด้านซ้ายจะประเมินเป็น1001 + 250 × 123 + 167 (= 31918)ในขณะที่ด้านขวาจะประเมินเป็น1001 + 250 × 123 + 125 (= 31876)

ตั้งแต่จำนวนเต็มซ้ายน้อยกว่าสองเท่าขวาหนึ่งผลที่ได้คือ( ... + 167%) ( ... + 125) = ( ... + 167) - ( ... + 125) = 167- 125 = 42

ẊẠżv©żvżvżvọ®®Ạżvżvżvọ®

สับเปลี่ยนอะตอมẊrandomizes ลำดับขององค์ประกอบอาร์กิวเมนต์ของ; อาร์กิวเมนต์ตัวเลขzถูกเลื่อนระดับเป็นช่วง[1, …, z]ล่วงหน้า สำหรับอาร์กิวเมนต์นัย0ช่วงนี้ว่างเปล่าและẊอัตราผลตอบแทน[] ทุกอะตอมẠผลตอบแทนที่1ถ้าทุกองค์ประกอบอาร์กิวเมนต์เป็น truthy, 0หากไม่ได้ เนื่องจากอาร์เรย์ที่ว่างเปล่าไม่มีองค์ประกอบที่เป็นเท็จẠส่งคืน1ที่นี่

ซิปกับอะตอมż(เป็นคู่) ใช้อาร์กิวเมนต์xและy ที่และ transposes คู่[x, y] สำหรับจำนวนเต็มxและy ที่นี้ก็มีอัตราผลตอบแทน[[x, y]]เพื่อการนี้โดยเฉพาะżที่เรียกว่ามีข้อโต้แย้ง1และ0 (อาร์กิวเมนต์นัย) ผลตอบแทน[[1, 0]] EVAL dyadicอะตอมvเปลี่ยนอาร์เรย์แบนทั้งหมด (ที่มีเฉพาะตัวเลขและตัวอักษร) ผมอาร์กิวเมนต์ซ้ายเป็นสตริงแล้วสตริงประเมินผลโปรแกรม Jelly เอกที่มีการโต้แย้งสิทธิของเป็นข้อโต้แย้งโปรแกรม ตั้งแต่["10"]ประกอบด้วย แต่เพียงผู้เดียวของตัวอักษรนี้ละเว้นอาร์กิวเมนต์ขวาของvและก็จะส่งผลใน[10]

การคัดลอกด่วน©จะแนบไปกับvและคัดลอกผลลัพธ์ไปยังการลงทะเบียน อะตอมเรียกคืน® (nilad) ที่เกิดขึ้นในภายหลังจะดึงข้อมูล[10]จากการลงทะเบียน

สามสำเนาของżvการทำงานเป็นก่อนที่จะทำแผนที่[10]เพื่อ[[10 0]เพื่อ[100]เพื่อ ... เพื่อ[10000] เพื่ออะตอมọทดสอบกี่ครั้งอาร์กิวเมนต์ซ้ายคือหารด้วยขวาหนึ่งของดังนั้นนี่มันคำนวณคำสั่งของ10 (ความจริงด้วย®) ใน10000 = 10 ⁴น่วม[4]

ต่อไปนี้®เป็น nilad ที่ไม่สามารถเข้าใจได้ดังนั้นค่าส่งคืนก่อนหน้า ( [4] ) จะถูกพิมพ์เป็น STDOUT จากนั้นแทนที่ด้วยค่าของ nilad ( 10 ) เราใช้Ạต่อไปยอม1 (นี่เป็นสิ่งจำเป็นในฐานะ nilad ตามด้วย dyad จะต้องแยกวิเคราะห์ในจุดนี้)

เมื่อก่อนżvżvżvผนวกสาม zeroes กับค่าตอบแทนในปัจจุบันหัน1เข้า[1000] สุดท้ายọ®คำนวณลำดับที่10ใน1000 = 10 ³และ3จะถูกพิมพ์ไปที่ STDOUT เมื่อโปรแกรมเสร็จสิ้น

44

อีกอันหนึ่งกลับกลายเป็นอีกความหมายที่แท้จริง

111111l11&K1111111Kl11&

แรกและสำคัญที่สุดตัวหนังสือ111111ชุดอาร์กิวเมนต์และค่าตอบแทนเริ่มต้น111111 การวิ่งอื่น ๆ ของ1ยังเป็นตัวอักษร

lคืออะตอมลอการิทึมซึ่งคำนวณลอการิทึมของอาร์กิวเมนต์ซ้ายไปยังฐานที่ระบุในหนึ่งค่า เมื่อเรียก111111มีการโต้แย้งสิทธิ11เราได้รับเข้าสู่ระบบ₁₁ 111111 ≈ 4.85

คำอะตอมKร่วมอาร์กิวเมนต์รายการที่ช่องว่างหลังจากการส่งเสริมตัวเลข / ตัวอักษรZเพื่อ[Z] ที่นี่เราก็ใช้มันเพื่อเปิดการโต้แย้งการเชื่อมโยงของ111111เข้า[111111] (เราไม่ต้องการอาเรย์ที่นี่ แต่เราหมดอะตอมตัวตน) ค่าบิตและอะตอม&ใช้ค่าส่งคืนทั้งสองด้านแล้วแปลงค่าเป็นจำนวนเต็มถ้าจำเป็นและคำนวณค่าบิตและ เฉพาะในกรณีนี้ก็จะส่งกลับ[4.85 และ 111111] = [4 & 111111] = [4]

ต่อไปนี้1111111เป็น nilad ที่ไม่สามารถเข้าใจได้ดังนั้นค่าส่งคืนก่อนหน้า ( [4] ) จะถูกพิมพ์ไปยัง STDOUT แล้วแทนที่ด้วยค่าของ nilad ( 1111111 ) Kจากนั้นก็หันจำนวนเต็มนี้ลงใน[1111111] (นี่ไม่จำเป็นอีกครั้งจริง ๆ แต่ nilad ตามด้วย dyad จะสามารถแยกวิเคราะห์ได้ในจุดนี้)

เมื่อก่อนl11คำนวณเข้าสู่ระบบ₁₁ 1111111 ≈ 5.81แล้ว&ส่งกลับ[5.81 และ 111111] = [5 และ 111111] = [5]

,SS
ỊỊ,ÇS
ÇÑÇÇÇÑ

นี่เป็นโปรแกรมเดียวที่ประกอบด้วยลิงค์ที่ผู้ใช้กำหนดหลายลิงค์ ลิงค์สุดท้ายคือลิงค์หลักและเรียกใช้งานเมื่อโปรแกรมเริ่มทำงานส่วนที่เหลือเป็นลิงค์ช่วยเหลือ Quick Çหมายถึงลิงก์ที่อยู่เหนือลิงก์ปัจจุบันและดำเนินการแบบ monadically ในทำนองเดียวกันตัวย่อÑจะอ้างถึงลิงค์ด้านล่างหนึ่งตัวปัจจุบัน (ล้อมรอบ) และเรียกใช้งานแบบ monadically

ลิงค์ด้านบนประกอบด้วยอะตอมคู่, - สีย้อมที่เปลี่ยนอาร์กิวเมนต์xและyเป็น[x, y] - และผลรวมอะตอมS- monad ที่ส่งเสริมอาร์กิวเมนต์จำนวนเต็มzเป็น[z]และลดอาร์กิวเมนต์อาเรย์ด้วยการเพิ่ม เมื่อการเชื่อมโยง,SSเรียกว่ามีข้อโต้แย้งจำนวนเต็มnก็คำนวณΣ [n, Σn] = Σ [N, N] = 2n

ลิงค์กลางประกอบด้วยอะตอมข้างต้นความรวดเร็วดังกล่าวÇและอะตอมที่ไม่มีนัยสำคัญỊ - monad ที่ให้ค่า1สำหรับการโต้แย้งเชิงตัวเลขzกับ-1 ≤ z ≤ 1แต่สำหรับ0ทั้งหมด การใช้Ịสองครั้งกับอาร์กิวเมนต์จำนวนเต็มnจะแทนที่ด้วย1เป็นหลักเนื่องจากเอาต์พุตของอันแรกỊ( อินพุตของอันที่สอง) ไม่มีนัยสำคัญเสมอ ผลที่ได้นี้จะถูกจับคู่แล้วกับค่าตอบแทนของÇ(เรียกว่ามีอาร์กิวเมนต์n ) Sและส่งผลให้ทั้งคู่จะลดลง โดยรวมเราคำนวณΣ [(| n | ≤ 1) ≤ 1 2n] = Σ [1, 2n] = 2n + 1

ด้วยการเชื่อมโยงตัวช่วยสองตัวเหล่านี้แทนที่ลิงก์หลักสามารถสร้างจำนวนเต็มที่ไม่เป็นลบได้โดยดูที่เลขฐานสอง ด้วยค่าส่งคืนเริ่มต้นที่0ลูกโซ่ÇÑÇÇÇÑคำนวณผลลัพธ์สุดท้าย(((((0 × 2 + 1) × 2) × 2 + 1) × 2 + 1) × 2 + 1) × 2 = ((5 × 2 + 1) x 2 + 1) × 2 = 46

ÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆn

ที่สำคัญต่อไปอะตอมพบว่าจำนวนที่เล็กที่สุดในเชิงบวกที่สำคัญที่เป็นอย่างเคร่งครัดมากกว่าอาร์กิวเมนต์ ด้วยค่าเริ่มต้นผลตอบแทน0สวดสิบห้าของการÆnคำนวณตัวเลขที่สำคัญที่สิบห้าซึ่งเป็น47

brainfuck , คะแนน 2, 255 144 10 ไบต์

... ใช่ไม่ใช่ความคิดที่ดีที่สุดเพราะฉันมีแค่ 8 ตัวอักษร (tarpits gonna tarpit) ที่จะทำงานด้วย แต่ขอดูว่ามันเป็นไปได้มากแค่ไหน ฉันคิดว่าทั้งหมดนี้เป็นไปได้ : Pคำตอบนี้แสดงให้เห็นถึงหกในแปดตัวละครที่ใช้สมอง brainfuck อีกสองคน,ซึ่งก็คือการป้อนข้อมูลและ.ซึ่งเป็นเอาท์พุท

+
>--[<->-]

เห็นภาพออนไลน์!

คำอธิบาย

ทุกหมายเลขจะถูกสร้างและเก็บไว้ในเซลล์เริ่มต้นบนเทป อย่างยิ่งต้องอาศัยเซลล์ห่อหุ้มซึ่งไม่ได้นำไปใช้กับล่ามสองสามตัว

1 :

[ 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 ]
  ^

+  increment the current cell

[ 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 ]
  ^

2 :

[ 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 ]
  ^

>  move to the next cell
-- decrement the current cell twice

[ 0 |254| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 ]
      ^

[  while the current cell is not 0
<  move to the previous cell
-  decrement the current cell

[255|254| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 ]
  ^

>  move to the next cell
-  decrement the current cell

[255|253| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 ]
      ^

]  repeat while the current cell is not 0

...

[ 3 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 ]
      ^

[ 2 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 ]
  ^

[ 2 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 ]
      ^

Neimคะแนน 38, 327 ไบต์

1: 𝔼
2: 2
3: 3
4: 4
5: 5
6: 6
7: 7
8: 8
9: 9
10: β
11: γ
12: δ
13: ε
14: ζ
15: η
16: θ
17: ι
18: κ
19: λ
20: μ
21: ν
22: ξ
23: π
24: ρ
25: σ
26: ς
27: τ
28: υ
29: φ
30: χ
31: ψ
32: ω
33: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
34: <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<𝐀
35: 𝐓0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻
36: ℂ𝐋𝐠𝐋𝐠𝐋𝐠𝐋𝐝𝐬𝕏𝐬
37: α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊
38: 𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝐥

คำอธิบาย:

• สำหรับ 1 เราใช้โทเค็น 'ตรวจสอบความเท่าเทียมกัน' ที่นี่การใช้ประโยชน์จากเมื่อ Neim พยายามที่จะปรากฏในการป้อนข้อมูลที่ว่างเปล่ามันจะได้รับ 0 เป็น 0 และ 0 เทียบเท่าเทียบเท่าผลัก 1 นี้ซึ่งพิมพ์โดยปริยาย
• ตั้งแต่ 2 ถึง 9 เราแค่ใช้ตัวอักษรตัวเลข
• จาก 10 ถึง 32 Neim มีค่าคงที่หนึ่งไบต์สำหรับพวกเขาทั้งหมด (ใช่มันบ้า)
• สำหรับ 33 เราใช้คำสั่งที่เพิ่มขึ้นเท่านั้น ในไบต์แรก Neim พยายามป๊อปอัพบางอย่างเพื่อให้สามารถเพิ่มได้ แต่เนื่องจากอินพุตว่างเปล่าจึงมีค่าเริ่มต้นที่จะ0เปิด
• สำหรับ 34 เราใช้วิธีการเดียวกัน แต่ลดค่าและรับค่าสัมบูรณ์
• สำหรับ 35 เราใช้ประโยชน์จากความจริงที่ว่าศูนย์แฟคทอเรียลเป็นหนึ่งและเราใช้มันโดยการทำซ้ำและเพิ่มเข้าไปซ้ำ ๆ
• สำหรับ 36 เราใช้ℂในการตรวจสอบ 0 และ 0 สำหรับ co-primality ซึ่งเป็น นี่เป็นการผลัก 1 จากนั้นเราจะได้การใช้งานครั้งแรก𝐋ซึ่งส่งผลให้รายการเดี่ยวที่มีเพียง 2 จากนั้นเราจะได้รับองค์ประกอบที่ยิ่งใหญ่ที่สุด ( 𝐠) ซึ่งผลัก 2 เป็นจำนวน [2 3 5 7 11]แล้วเราทำซ้ำขั้นตอนนี้จนกว่าเราจะได้รับรายชื่อ หลังจากนั้นเราจะใช้ในการคำนวณสันดอนส่งผลให้ในรายการ𝐝 [1 2 2 4]ต่อไปเราจะใช้𝐬เพื่อให้ได้ผลรวม - ซึ่งเป็น 9 - แล้วเราจะคำนวณช่วงพิเศษ 0-9 [0 1 2 3 4 5 6 7 8]ส่งผลให้ใน ในที่สุด𝐬ก็ใช้อีกครั้งเพื่อให้ได้ 37
• สำหรับ 37 αคือค่าคงที่ที่แสดงถึงค่าลบและเรากดและลบซ้ำแล้วซ้ำอีก (ใช้ประโยชน์จากความจริงที่ว่าเมื่อเราพยายาม popping ที่อินพุตว่าง 0 จะถูกผลัก)
• สำหรับ 38 อีกครั้งโดยใช้ค่าเริ่มต้น 0 สำหรับการป้อนข้อมูลว่างเรายังคงผนวก 0 กับตัวเองสร้างรายการที่มีความยาวจากนั้นคำนวณความยาว

ลองได้ที่นี่

Python 2, 15

นี่คือจุดเริ่มต้นมองหามากขึ้น

ขอบคุณลีโอซึ่งทิปช่วยให้ฉันไปถึง 15

[[[]]>[]][[]>[]]>>[[]>[]][[]>[]]

2

import math
print'%i'%math.pi

((()<())<())<<((()<())<())<<((()<())<())

5

6

7

8

9

11^1 

33/3

4--4--4

__debug__+__debug__+__debug__+__debug__+__debug__+__debug__+__debug__+__debug__+__debug__+__debug__+__debug__+__debug__+__debug__

q=""=="";qq=q=="";qqq=~q*~q*~q;~qqq*~q*~qq

0xF

Japtet , 448 ไบต์, คะแนน 42

การทำงานร่วมกันมากระหว่างปุย , ETHproductionsและโอลิเวอร์

v
y
Íà
Qiiii)iiii)âQ
ÂHq
LÁL
´Vn´VnVnVn
8
9
A
B
C
D
E
F
G
J-----J---J---J---J
[¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾]x
;Iìw
~~½e½e½e½e~½e½
++T+++T+++T+++T+++T+++T
22
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
4á
5²
°UU°°°U°°U°°U°°U°°U
»³³
7/¼
$'_____________________________b'$bb
ZµÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉ
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"aa
Sc
33
Mg011
##
6p
Rí í í í í è.
`¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥`l
¨N|N¹òò¹m···m|¹mò¹m···m|¹mò¹m···m|¹o
º¤¤*º¤*º¤
(Å<<(Å<<(Å<<(Å<<(Å<<(Å^(Å<<(Å<<(Å<<(Å^(Å
Y±Y¶YY±YY±Y±Y¶YY±YY±Y±Y¶YY±Y

ตัวอักษร (มีประโยชน์) เหล่านี้เหลืออยู่:

!%&,:=>?@OPWX\dfhjkrstuz{}¡¢£¦§©ª«¬®¯¸ÀÃÆÇÈÐßãäåæçéêëîïñóôõö×øÿ

คำอธิบาย

สองสิ่งที่ควรรู้เกี่ยวกับ Japtr ก่อนที่เราจะเริ่มต้นซึ่งฉันใช้บ่อยๆ ประการแรก Japt มี 6 U-Zตัวแปรสงวนไว้สำหรับการป้อนข้อมูลเหล่านั้นเป็นตัวพิมพ์ใหญ่ 0ถ้าไม่มีการป้อนข้อมูลจะถูกส่งผ่านตัวแปรเหล่านั้นพวกเขาทั้งหมดจะเริ่มต้น สิ่งที่สองกล่าวถึงในเคล็ดลับนี้

คลิกที่ตัวอย่างข้อมูลใด ๆ ที่จะลองในล่ามออนไลน์

v

เมื่อนำไปใช้กับตัวเลขvวิธีการใช้จำนวนเต็มnเป็นอาร์กิวเมนต์และส่งกลับ1ถ้าจำนวนหารด้วยn , 0ถ้าไม่ได้ ถ้าnไม่ได้จัดมาแล้วมันเริ่มต้นที่2 0 (ค่าเริ่มต้นสำหรับU) คือหารด้วย2ดังนั้นนี้จะช่วยให้เราของเรา1

y

คล้ายกันมากกับอันแรก เมื่อนำไปใช้กับตัวเลขyวิธีการใช้จำนวนเต็มnเป็นอาร์กิวเมนต์และส่งกลับ GCD ของตัวเลขทั้งสอง ถ้าnไม่ได้จัดมาแล้วมันเริ่มต้นที่2 ตั้งแต่0คือหารด้วย2 , GCD (0, 2)ทำให้เรามีของเรา2

Íà

àส่งคืนจำนวนชุดค่าผสมของ[1...this]ซึ่งส่งคืน3

Qiiii)iiii)âQ

Qเริ่มต้นที่เครื่องหมายคำพูดเดียว iบนสตริงที่แทรกสตริงอื่นที่จุดเริ่มต้น; ตามที่อธิบายไว้ใน# 3แต่ละรายการiiii)เทียบเท่ากับ.i("i".i("i"))ใน JS ดังนั้นการแทรกสองชุดiไว้ที่จุดเริ่มต้นของสตริง iiii"ทำเช่นนี้เป็นครั้งที่สองและคุณมีสตริง âQแล้วจำลอง.search(Q)ให้ดัชนีของครั้งแรก"ในสตริงซึ่งเป็น4

ÂHq

LÁL

´Vn´VnVnVn

ตามที่ระบุไว้ก่อนที่จะVเริ่มต้นที่0 ´เป็นทางลัดสำหรับ--โอเปอเรเตอร์ดังนั้นรหัสจึงเทียบเท่ากับ JS ต่อไปนี้:

(--V).n((--V).n(V.n(V.n())))

X.n(Y)เทียบเท่ากับY - Xหรือ-X + Y ; คนแรกที่--Vผลตอบแทน-1และสอง-2ดังนั้นนี้เป็นเรื่องเกี่ยวกับเทียบเท่ากับ- (- 1) + (- (- 2) + (- (- 2) + - (- 2))) ลดความซับซ้อนของเราได้รับ1 + 2 + 2 + 2 = 7

8
9

แท้จริง8และ9

A
B
C
D
E
F
G

นี่คือค่าคงที่สำหรับ10 - 16รวม

J-----J---J---J---J

Jมีการตั้งค่าให้-1 ล่าม Japt จะทำการแยกวิเคราะห์อย่างถูกต้องตาม(J--) - (--J) - (--J) - (--J) - (--J)นี้ เมื่อทำการคำนวณทางคณิตศาสตร์มากกว่านี้เราพบว่านี่เท่ากับ(-1) - (-3) - (-4) - (-5) - (-6)หรือ-1 + 3 + 4 + 5 + 6 = 17 .

[¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾]x

¾.75เป็นคุณอาจคาดเดาทางลัดสำหรับ เราใส่ 24 สำเนาของ0.75ในอาร์เรย์แล้วรวมกับxให้0.75 * 24 = 18

;Iìw

ฉันคิดว่านี่เป็นสิ่งที่ฉันโปรดปราน ;ที่จุดเริ่มต้นของโปรแกรมการเปลี่ยนแปลงค่าของค่าคงที่บางส่วนของ Japt; โดยไม่ได้Iเป็น64แต่กับมันIคือ91 ìwแปลงไปยังรายการของตัวเลขและวิ่งwในรายการย้อนกลับอาร์เรย์แล้วแปลงกลับไปยังหมายเลขที่จะได้รับเรา19

~~½e½e½e½e~½e½

           ½e½     1.5811  (.5 * sqrt(10))
          ~       -2
        ½e         0.005  (.5 * (10 ** -2))
      ½e           0.5058
    ½e             1.6024
  ½e              20.0138

และสุดท้าย~~ทำหน้าที่ในชั้นนี้เป็นจำนวนเต็มผลผลิตผลของเรา20

++T+++T+++T+++T+++T+++T

(++T) + (++T) + (++T) + (++T) + (++T) + (++T)

ผลที่ได้คือ1 + 2 + 3 + 4 + 5 + 6ซึ่งสรุปไป21

22

ตัวอักษร22

ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ

Äเป็นทางลัดสำหรับ+1ดังนั้นผลรวมนี้คือ23 1วินาที

4á

พบจำนวนพีชคณิตของ[1, 2, 3, 4]ซึ่งก็คือ4! = 24

5²

²เป็นทางลัดสำหรับp2ซึ่งจะเพิ่มจำนวนเป็นกำลังสอง 5 ** 2คือ25

°UU°°°U°°U°°U°°U°°U

°เป็นทางลัดสำหรับผู้ประกอบการหรือถ้ามันไม่สามารถแยกวิเคราะห์เป็นเช่นนี้++ + +ตามที่ระบุไว้ก่อนเมื่อมีการป้อนข้อมูลที่ไม่มีUค่าเริ่มต้น0 ดังนั้นรหัสเทียบเท่ากับ(++U), (U++) + + (++U) + + (++U) + + (++U) + + (++U) + + (++U)ซึ่งจะคล้ายกับ# 17 : Uจะเพิ่มขึ้นครั้งแรกที่1แล้วเพิ่มขึ้นซ้ำแล้วซ้ำอีกและเพิ่มดังกล่าวว่าผลสุดท้ายคือ1 + 3 + 4 + 5 + 6 + 7 = 26

»³³

³เป็นทางลัดสำหรับpวิธีการที่มีการโต้แย้งของ3 อย่างไรก็ตามถ้าอักษรตัวพิมพ์เล็กปรากฏขึ้นโดยตรงหลังจากวงเล็บซ้าย ( »เป็นทางลัดสำหรับ(() มันจะกลายเป็นสตริง สิ่งนี้ทำให้มันถูกส่งผ่านไปยังเมธอดและเรียกว่าเป็นฟังก์ชัน (เช่นm³การแม็พ.p(3)) ในกรณีนี้ แต่("p",3)ผลตอบแทนที่ได้ของเรา3แล้วเรายกมันขึ้นสู่อำนาจของ3( pเป็นวิธีการพลังงานเมื่อนำไปใช้กับตัวเลข) ซึ่งจะช่วยให้เราของเรา27

7/¼

¼ในขณะที่คุณอาจจะรู้ว่าตอนนี้เป็นทางลัดสำหรับ.25ดังนั้นนี้คำนวณ7 / 0.25 = 28

$'_____________________________b'$bb

สิ่งใดที่อยู่ในห่อ$สัญลักษณ์จะถือว่าเป็น JavaScript บริสุทธิ์ดังนั้นเราจึงได้มีสตริงของ 29 bขีดตามด้วย (โดยไม่ต้อง$, 'จะเป็นสตริงตัวเดียว.) The bวิธีเมื่อนำไปใช้สตริงผลตอบแทนดัชนีแรกของการโต้แย้งภายในสตริงที่ ตามที่อธิบายไว้ใน# 3คนสุดท้ายbจะถูกแปลงเป็นสตริงดังนั้นเราโลภดัชนีแรกของbในสตริงของเราซึ่งเป็นวันที่ 29

ZµÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉ

µเป็นทางลัดสำหรับ-=และสำหรับÉ -1ผลที่ได้คือการลบ 30 สำเนาของ-1จาก0ซึ่งจะช่วยให้30

"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"aa

เป็นอย่างมากเช่น # 29 aวิธีเมื่อนำไปใช้กับสตริงผลตอบแทนดัชนีสุดท้ายของการโต้แย้งในสตริงที่ ใช้ 0 การจัดทำดัชนีดัชนีล่าสุดaในสายของ 32 aคือ31

Sc

Sกำหนดไว้ล่วงหน้าไปยังพื้นที่เดียวและcที่เดียวถ่านสตริงผลตอบแทนถ่านรหัสให้32

33

ตัวอักษร33

Mg011

MgNส่งคืนหมายเลข Nth Fibonacci 011คือ9ในฐานแปด จำนวนฟีโบนักชี 9 เป็น34

##

#ส่งคืนอักขระรหัสถัดไปของอักขระ รหัสถ่านของ#ตัวเองเกิดขึ้นเป็น35ทำให้งานของเราที่นี่เป็นเรื่องง่ายโดยเฉพาะ

6p

pคือการยกกำลังและไม่มีอาร์กิวเมนต์ที่สองเป็นค่าเริ่มต้น2 ; จึงพิมพ์นี้6 ** 2 = 36

Rí í í í í è.

อันนี้ค่อนข้างยุ่งยาก Rค่าเริ่มต้นเป็นอักขระขึ้นบรรทัดใหม่เดียว (ซึ่งขึ้นบรรทัดใหม่นั้นมีความสำคัญในภายหลัง) íในสตริงโดยไม่มีข้อโต้แย้งใด ๆ พาตัวละครแต่ละตัวและผนวกดัชนีของมัน: การแปลงค่อนข้างไร้ประโยชน์ แต่ผลลัพธ์ผ่านการทำซ้ำ 5 ครั้งคือ: (ใช้Rแทนการขึ้นบรรทัดใหม่ตามตัวอักษร)

R
R0
R001
R0010213
R001021304251637
R0010213042516370849210511112613314715

น่าสนใจว่าแต่ละรายการเป็นเพียงคำนำหน้าของถัดไป ... แต่อย่างไรก็ตามส่วนสุดท้ายè.นับจำนวนการแข่งขัน/./gที่พบในผลลัพธ์ ในสตริงมี 38 ตัวอักษร แต่เนื่องจาก/./gเพียงตรงกับตัวอักษรที่ไม่ขึ้นบรรทัดใหม่ผลที่ได้คือ37

¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥l

backticks ทำเครื่องหมายสตริงบีบอัดและคลายไป¥ ในสตริงให้ength ดังนั้นหลังจากการบีบอัดนี้จะช่วยให้38llll

¨N|N¹òò¹m···m|¹mò¹m···m|¹mò¹m···m|¹o

Oooh เด็กชายคนนี้เป็นคนบ้ามาก ครั้งแรกที่เราสร้างtrueด้วย¨N( ¨ย่อมา>=และNไม่มีปัจจัยการผลิตคืออาร์เรย์ว่างเปล่า) แล้วแปลงที่มี1 |Nจากตรงนั้นมันบ้าไปแล้ว:

ò    Inclusive range [0..1],            [0, 1]
 ò   making each an inclusive range.    [[0], [0, 1]]
m·   Join each on newlines.             ["0", "0\n1"]
·    Join on newlines.                  "0\n0\n1"
·    Split on newlines.                 ["0", "0", "1"]
m    Map each item X and index Y to     
 |     X | Y.                           ["0" | 0, "0" | 1, "1" | 2] -> [0, 1, 3]
m    Map each by 
 ò     inclusive range.                 [[0], [0, 1], [0, 1, 2, 3]]
m··· Same as before.                    ["0", "0", "1", "0", "1", "2", "3"]
m|   Bitwise OR thing again.            [0, 1, 3, 3, 5, 7, 7]
mò   Map each by inclusive range.       [[0], [0, 1], ..., [0, 1, 2, 3, 4, 5, 6, 7]]
m··· Same as before.                    ["0", "0", ..., "5", "6", "7"]
m|   Bitwise OR again.                  ["0"|0, "0"|1, ..., "5"|30, "6"|31, "7"|32]
                                        -> [0, 1, ..., 31, 31, 39]

(ใน¹s เป็นเพียงทดแทนสำหรับภาพระยะใกล้ parens และได้รับการละเว้น.) สุดท้ายoแล้วปรากฏและส่งกลับรายการสุดท้ายในอาร์เรย์ให้39

º¤¤*º¤

ส่วนใหญ่เคล็ดลับเช่นเดียวกับกับ# 3 ¤เป็นทางลัดสำหรับsวิธีการที่มีการโต้แย้งของ2 อย่างไรก็ตามในกรณีนี้รหัส transpiled คือ(("s", 2).s(2) * (("s", 2) * (("s", 2))))หรือทำให้ง่าย(2).s(2) * (2 * 2)ขึ้น .s(2)ส่งกลับจำนวนเป็นสตริงฐาน-2 ซึ่งจะช่วยให้"10"; * (2 * 2)โดยปริยายแปลงนี้ให้จำนวนและคูณ4ให้40

(Å<<(Å<<(Å<<(Å<<(Å<<(Å^(Å<<(Å<<(Å<<(Å^(Å

คล้ายกับรุ่นก่อนหน้า Åเป็นทางลัดสำหรับsวิธีการที่มีการโต้แย้งของ1 ในกรณีนี้ แต่แต่ละ(Åtranspiles เพื่อ("s", 1)ที่เพิ่งส่งกลับ1 1<<1<<1<<1<<1<<1คือ32และ1<<1<<1<<1เป็น8 ; เหล่านี้จะ XORed ร่วมกับ1ที่จะได้รับ41

Y±Y¶YY±YY±Y±Y¶YY±YY±Y±Y¶YY±Y

±เป็นทางลัดสำหรับ+=และสำหรับ¶ ===ซึ่งหมายความว่ารหัสเป็นจริง

Y+=Y===Y,Y+=Y,Y+=Y+=Y===Y,Y+=Y,Y+=Y+=Y===Y,Y+=Y

Y===Y เป็นจริงเสมอดังนั้นเราสามารถทำให้บางสิ่งนี้ง่ายขึ้น:

Y+=1,Y+=Y,Y+=Y+=1,Y+=Y,Y+=Y+=1,Y+=Y

0 + 1 = 1 ; 1 + 1 = 2 ; 2 + (2 + 1) = 5 ; 5 + 5 = 10 ; 10 + (10 + 1) = 21 ; 21 + 21 = 42

PHP, คะแนน 17, 130 Bytes

ตัวอักษรที่ใช้ ADEFGIKLMOPRSTVXYZ=_![]()<>'"#$,;/-+*|^&0123456789afhnprstwx

Z==Z
FTP_MOREDATA
';'&w
![]<<![]<<![]
5
6
"#"|"$"|"1"
8
SIGKILL
333333>>3>>3>>3>>3>>3
99/9
22-2-2-2-2-2
strspn(XXXXXXXXXXXXXX,X)
7+7
0xf
4*4
ha^YV

1 ค่าคงที่บูลีน Z (ไม่ได้ตั้งค่า) เท่ากับค่าคงที่ Z

2 FTP_MOREDATA เป็นค่าคงที่ใน PHP ด้วยค่า 2

3 บิตและตัวอักษร; และ

4 bitwise Shift ซ้ายและตรรกะไม่ได้โยนอาร์เรย์ว่างเปล่าเป็นบูลีนจริงด้วยจะถูกแปลงเป็นจำนวนเต็ม 1 ผ่านตัวดำเนินการ Shift ซ้าย

7 bitwise or chars # และ $ and 1

9 SIGKILL เป็นค่าคงที่ใน PHP ด้วยค่า 9

10 Shiftwise Shift ขวาทุกขั้นตอนคือการหารจำนวนเต็มด้วย 8 ดังนั้นเราจึงมีขั้นตอน 333333, 41666, 5208, 651, 81, 10

13 นับถ่าน X ในสตริง X ... จากจุดเริ่มต้น

15 ค่าเลขฐานสิบหก f = 15

17 bitwise Xor พร้อมสายฮ่าและ YV

ตัวอย่างทั้งหมดเป็นรายการในอาร์เรย์

ลองออนไลน์!

PHP, คะแนน 16, 94 Bytes

ตัวอักษรที่ใช้ AEIMPRTUZeflnrstvwx^_&|()[]=!.*+/-<>$":0123456789

Z==Z
":"&"w"    
M_PI|[]
TRUE<<TRUE<<TRUE
5
6
A^v    
8
9
!$s.strlen($s)    
77/7
3+3+3+3
111>>1>>1>>1    
22-2-2-2-2
0xf
4*4

1 ค่าคงที่บูลีน Z (ไม่ได้ตั้งค่า) เท่ากับค่าคงที่ Z

2 บิตและตัวอักษร: และ w

3 Pi casted เป็นค่าจำนวนเต็มผ่านอาร์เรย์ว่างเปล่าที่นำไปใช้เป็นศูนย์

7 bitor xor chars A และ v

10 ตัวแปร $ s ไม่ได้ตั้งค่า! $ s = หนึ่งข้อตกลงที่มีความยาวสตริงของตัวแปร $ s

13 111/2 = 55/2 = 27/2 = 13 จำนวนเต็มหาร bitwise

15 ค่าเลขฐานสิบหก f = 15

ตัวอย่างทั้งหมดเป็นรายการในอาร์เรย์

ลองออนไลน์!

PHP, คะแนน 14, 84 ไบต์

ตัวอักษรที่ใช้ $!_^[]()%/+~-=AEILMNPRUZ0123456789delnrstx

Z==Z
2
M_PI^[]
4
5
6
ERA%11
8
9
!$s.strlen($s)
77/7
3+3+3+3
0xd    
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-NULL

1 ค่าคงที่บูลีน Z (ไม่ได้ตั้งค่า) เท่ากับค่าคงที่ Z

3 Pi casted เป็นค่าจำนวนเต็มผ่านอาร์เรย์ว่างเปล่าที่นำไปใช้เป็นศูนย์

7 ERA เป็นค่าคงที่ที่มีค่า 131116 mod 11 = 7

10 ตัวแปร $ s ไม่ได้ตั้งค่า! $ s = หนึ่งข้อตกลงที่มีความยาวสตริงของตัวแปร $ s คือศูนย์

13 ค่าเลขฐานสิบหก d = 13 14 bitwise not และเครื่องหมายลบเพิ่ม NULL เป็น 14

ตัวอย่างทั้งหมดเป็นรายการในอาร์เรย์

ลองออนไลน์!

R, คะแนน13 14

F^F                       # F==0 in R
q=""=="";q--q             # ""=="" is TRUE, TRUE == 1 (Thanks WheatWizard)
3
4
5
6
7
8
9
1e1                       # scientific notation for 10
22/2
T+T+T+T+T+T+T+T+T+T+T+T   # T == 1
0xD                       
sum(mtcars$vs)            # mtcars is a built-in dataset, summing the $vs column gives 14

มีอีกหนึ่งอย่างขอบคุณ user2390246

ตัวละครที่ใช้:

0123456789acemqrstuvxDFT^=";-/+()$

MATLคะแนน21 22 23 ตัวเลข (273 ไบต์)

ขอบคุณJ Doe ที่ต่อเลขจาก 22 เป็น 23!

0~
'bd'd
{P}gk
HH^
5
6
7
8
9
3 3.333333333333333*
11
IEE
[B]Yq
llllllllllllllNwxwxwxwxwxwxwxwxwxwxwxwxwxwx
KUKUa-
4W
FFFFFFFFFFFFFFFFFn
TTTTTTTTTTTTTTTTTTs
rrrrrrrrrrrrrrrrrrrhhhhhhhhhhhhhhhhhhz
OOOOOOOOOOOOOOOOOOOOvZyX>
JJJJJJJJJJJJJJJJJJJJJ++++++++++++++++++++J/
22
`@QQQQQQQQQQQQQQQQQQQQQQ@@<

ลองออนไลน์! แต่ละส่วนย่อยในลิงก์สิ้นสุดลงด้วยD(แสดง) หรือ]D(ปิดวงวนอย่างชัดเจนและแสดง) เพื่อล้างสแต็กและแยกออกจากตัวอย่างถัดไป

คำอธิบาย

0~

0ดัน ลบล้าง ให้ซึ่งจะแสดงเป็นtrue1

'bd'd

'bd'สตริงกด ความแตกต่างติดต่อกันระหว่างจุดรหัสของอักขระ

{P}gk

piอาร์เรย์เซลล์ผลักดันที่มีจำนวน แปลงเป็นอาร์เรย์ตัวเลข (เช่นเป็นตัวเลขเดียว) ปัดเศษลง

HH^

กด2สองครั้ง อำนาจ

5

ตัวอักษรตัวเลข

6

ตัวอักษรตัวเลข

7

ตัวอักษรตัวเลข

8

ตัวอักษรตัวเลข

9

ตัวอักษรตัวเลข

3 3.333333333333333*

3ดัน 3.333333333333333ดัน คูณ. 10เนื่องจากความถูกต้องลอยจุดนี้จะช่วยให้

11

ตัวอักษรตัวเลข

IEE

3ดัน ทวีคูณ2สองเท่า

[B]Yq

กด[6](ซึ่งเหมือนกับ6) คำนวณn- th prime

llllllllllllllNwxwxwxwxwxwxwxwxwxwxwxwxwxwx

กด114 ครั้ง จำนวนขององค์ประกอบในกอง ล้างส่วนที่เหลือของสแต็ก

KUKUa-

4ดัน สี่เหลี่ยม ทำเหมือนเดิม. ใด ๆ 1ให้ ลบออก

4W

4ดัน 2ยกขึ้นเพื่อที่

FFFFFFFFFFFFFFFFFn

Push array [false false ... false](17 ครั้ง) จำนวนขององค์ประกอบในอาร์เรย์

TTTTTTTTTTTTTTTTTTs

กดอาร์เรย์[true true ... true](18 ครั้ง) ผลรวมของอาร์เรย์

rrrrrrrrrrrrrrrrrrrhhhhhhhhhhhhhhhhhhz

กด 19 ตัวเลขสุ่มจากช่วงเวลา (0,1) ต่อกันแนวนอน 18 ครั้ง จำนวนขององค์ประกอบที่ไม่ใช่ศูนย์ในอาร์เรย์

OOOOOOOOOOOOOOOOOOOOvZyX>

กด020 ครั้ง เชื่อมต่อเนื้อหาสแต็กในแนวตั้ง (ให้เวกเตอร์คอลัมน์) ขนาด: [20 1]ให้อาร์เรย์ อาร์เรย์สูงสุด

JJJJJJJJJJJJJJJJJJJJJ++++++++++++++++++++J/

กด1j(หน่วยจินตภาพ) 21 ครั้ง เพิ่ม 20 ครั้ง 1jหารด้วย

22

ตัวอักษรตัวเลข

`@QQQQQQQQQQQQQQQQQQQQQQ@@<

ทำ ... ในขณะที่ลูป ( `) ด้วยสิ้นสุดโดยนัย ในการย้ำแรกมันดันดัชนีซ้ำ ( @) และเพิ่มขึ้นมัน ( Q) ครั้งที่ 22 23ซึ่งอัตราผลตอบแทน เงื่อนไขลูป ( @@<) เป็นเท็จดังนั้นจึงออกจากลูป

แนวคิดบางประการสำหรับการปรับปรุงเพิ่มเติม

• (ช่องว่าง) ในตัวอย่าง 10 อาจถูกแทนที่ด้วย |
• X>ในตัวอย่าง 20 จะถูกแทนที่ด้วยคำนำหน้าจึงพ้นpX
• ไม่ได้ใช้งานและมีประโยชน์ในปัจจุบัน: :,A

Vim 8 บน Windows, คะแนน 13, 104 bytes

1
2
3
4
5
6
7
^R=&ts^@
9
8^O^A^O^A
0^[^X^X^X^X^X^X^X^X^X^X^X0x
:h<CR>wwwwwwwwwwwy$:q<CR>p
grgKjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjYZZvPWWWllld|llD

^{keystroke}หมายถึง<C-{keystroke}>เพื่อให้^Xมีที่<C-x>ยกเว้นซึ่งเป็น^@ <C-j>ฉันยังคงพยายามเพิ่มจำนวนมากขึ้นในรายการนี้และ<CR>แสดงถึงตัวดึงข้อมูลบรรทัด

หมายเหตุ: -u NONE -U NONEการเรียกใช้คำสั่งเหล่านี้เริ่มต้นเป็นกลุ่มโดยใช้ นี่คือเพื่อให้แน่ใจว่าการกำหนดค่าของคุณจะไม่ยุ่งเกี่ยวกับรหัส

ตัวอย่างที่ 1 ถึง 10 เริ่มต้นในโหมดแทรก ในขณะที่ตัวอย่างข้อมูล 12 และ 13 เริ่มทำงานในโหมดปกติ

คำอธิบาย

Snippet :^R=&ts^@8 ผมต้องขอขอบคุณ @ L3viathan มากับนี้และ @ nmjcman101 สำหรับการแนะนำ^@แทนเลื่อนบรรทัดและ @ ØrjanJohansenสำหรับการตัดทอนไป&tabstop จากนั้นประเมินขนาดของแท็บซึ่งเป็นค่าเริ่มต้นที่ 8 และค่านี้จะถูกแทรกลงในตัวแก้ไข&ts&ts

Snippet 8^O^A^O^A10 เราใส่ 8 แล้วเพิ่มสองครั้งเพื่อรับ 10

Snippet 0^[^X^X^X^X^X^X^X^X^X^X^X0x11 เราเขียน 0 ลงมาและลดมัน 11 ครั้งเพื่อให้ได้ -11 จากนั้นเราลบเครื่องหมายลบเพื่อรับ 11

Snippet :h<CR>wwwwwwwwwwwy$:q<CR>p12 นี่จะเปิดเมนูช่วยเหลือของ Vim 8 ซึ่งมีข้อมูลต่อไปนี้:

*help.txt*  For Vim version 8.0.  Last change: 2016 Sep 12

และลำดับของการwย้ายไปที่ 12 ซึ่งเป็นจุดที่y$คัดลอกตัวเลข pจากนั้นก็จะถูกวางลงในโปรแกรมแก้ไขโดยใช้

ตัวอย่างข้อมูล 13 grgKjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjYZZvPWWWllld|llDต้องขอบคุณ @DJMcMayhem ที่มาพร้อมกับมัน ใช้ได้กับ Windows เท่านั้น gข้อมูลการค้นหาเมนูความช่วยเหลือสำหรับคำสั่งที่เริ่มต้นด้วย จากนั้นจะเลื่อนลงโดยใช้jเพื่อไปที่บรรทัดนี้:

|g?|        g?      2  Rot13 encoding operator

หลังจากนั้นจะคัดลอกและวางในบัฟเฟอร์ หลังจากนั้นทุกอย่างยกเว้น 13 จะถูกลบออกจากบัฟเฟอร์

Mathematica คะแนน 13

x~D~x
⌊E⌋
3
⌈Pi⌉
5
6
LucasL@4
8
9
0!+0!+0!+0!+0!+0!+0!+0!+0!+0!
77/7
Tr[{11,1}]
-I*I-I*I-I*I-I*I-I*I-I*I-I*I-I*I-I*I-I*I-I*I-I*I-I*I

05AB1E , คะแนน 18, 67 ไบต์

X     Variable is initialized to 1
Y     Variable is initialized to 2
2>     2 + 1
4
5
6
7
8
9
T     Constant 10
3b     3 in binary
•C     Ascii code of 'C'
11Ì     11 in hex
A'ok     Index of 'o' in the alphabet
žz¨¤x+     Middle character of '256' times 2, plus itself
¾<<<<n     Variable initialized to 0, 4 times -1, squared
‘c‘‘c‘QDJH     'c' equals itself (true = 1), duplicated, converted from hex to dec
тD÷·±D*·     Constant 100, divided by itself, * 2, bitwise not, times itself, * 2
"d"aÐÐÐÐÐÐÐÐÐ)O     "d" is_alpha (true = 1), triplicated 9 times, total sum

ลองออนไลน์!

PingPongคะแนน 127

ใน PingPong ตัวละครทุกตัวมีค่าตัวเลขที่แตกต่างกันทำให้นับได้ถึง 127 งานที่ไม่สำคัญ ภาษาทำงานได้โดยการอ่านค่าของตัวละครทุกตัวและผลักไปที่ด้านบนสุดของสแต็กซึ่งดำเนินการทั้งหมด ในทางทฤษฎี PingPong สามารถผ่าน 127 ได้ แต่มันต้องผ่านบล็อกของตัวละครที่ปรากฏเป็นช่องว่างในเท็กซ์เอดิเตอร์ดังนั้นฉันจึงทิ้งมันไว้ในทางออก

1: 1
2: 2
3: 3
4: 4
5: 5
6: 6
7: 7
8: 8
9: 9
10: A
11: B
12: C
13: D
14: E
15: F
16: G
17: H
18: I
19: J
20: K
21: L
22: M
23: N
24: O
25: P
26: Q
27: R
28: S
29: T
30: U
31: V
32: W
33: X
34: Y
35: Z
36: a
37: b
38: c
39: d
40: e
41: f
42: g
43: h
44: i
45: j
46: k
47: l
48: m
49: n
50: o
51: p
52: q
53: r
54: s
55: t
56: u
57: v
58: w
59: x
60: y
61: z
62: ©
63: ®
64: À
65: Á
66: Â
67: Ã
68: Ä
69: Å
70: Æ
71: Ç
72: È
73: É
74: Ê
75: Ë
76: Ì
77: Í
78: Î
79: Ï
80: Ð
81: Ñ
82: Ò
83: Ó
84: Ô
85: Õ
86: Ö
87: ×
88: Ø
89: Ù
90: Ú
91: Û
92: Ü
93: Ý
94: Þ
95: ß
96: à
97: á
98: â
99: ã
100: ä
101: å
102: æ
103: ç
104: è
105: é
106: ê
107: ë
108: ì
109: í
110: î
111: ï
112: ð
113: ñ
114: ò
115: ó
116: ô
117: õ
118: ö
119: ÷
120: ø
121: ù
122: ú
123: û
124: ü
125: ý
126: þ
127: ÿ

อ็อกเทฟคะแนน 14, 74 ไบต์

ค่อนข้างแน่ใจว่าฉันใกล้ถึงขีด จำกัด แล้ว

1:  ~0                        % Not 0 == 1
2:  "H"/"$"                   % "H" = 72, "$" = 36. H/$ = 2
3:  3                         % Literal
4:  4                         % Literal
5:  5                         % Literal
6:  6                         % Literal
7:  7                         % Literal
8:  8                         % Literal
9:  9                         % Literal
10: ceil(pi*pi)               % pi*pi = 9.87. ceil(9.87) = 10
11: 11                        % Literal
12: 2+2+2+2+2+2               % Well, not much to say
13: ['','RT'-'!']             % 'RT' = [82,84]. Subtract '!' (33) to get ['',49,51]=13
14: nnz...                    % Number of non-zero elements in the string...
    nnnnnnnnnnnnnn            % on this line. (This is an awesome trick by the way!)

มีการลบstrchrตั้งแต่ผมมีอยู่แล้วcจำนวน 10 ฉันยังคงมีj, ^, =,!พื้นที่และแท็บแนวนอน (ASCII-9) ซ้ายดังนั้นจึงอาจเป็นไปได้ที่จะบีบอีกหนึ่งใน

แท็บแนวนอนสามารถใช้เป็นช่องว่างได้ดังนั้นเคล็ดลับที่ใช้กับstrchrและnnzสามารถใช้งานได้อีกครั้ง เหลือตัวอักษรตัวพิมพ์abdfgjkmoquvwxyเล็กเท่านั้น มีฟังก์ชั่นไม่มากนักที่สามารถสร้างจากสิ่งเหล่านี้modสามารถใช้งานได้ แต่ไม่สามารถรับสายเข้าได้

มันง่ายที่จะใช้ตัวละครที่เหลืออยู่เพื่อรับ1แต่ฉันไม่รู้ว่าฉันจะหาอะไรได้อีก

การทดสอบทั้งหมด

อาจเป็นไปได้ที่มีประโยชน์: fun aเป็นเช่นเดียวกับfun('a'), fun a bเป็นเช่นเดียวกับfun('a','b')และอื่น ๆ สามารถใช้หลาย ๆ ที่ได้:

gt t g    % Equivalent to 't'>'g'. Returns 1. Uses space (available)
or o r    % Equivalent to 'o' | 'r'. Returns 1. 

การใช้สิ่งนี้จะทำให้0มี แต่ฉันไม่เห็นว่าจะมีประโยชน์อย่างไร

e (2.71828...)และjยังไม่ได้ใช้ ต้องลบceilเพื่อใช้eแม้ว่า

ทางเลือก (แรงบันดาลใจ):

1:  ~0             % Not 0 = 1
2:  2              % Numeral
3:  3              % Numeral
4:  fix(i^i^i^i)   % Numeral
5:  5              % Numeral
6:  6              % Numeral
7:  7              % Numeral
8:  8              % Numeral
9:  9              % Numeral 
10: 1+1+1+1+1+1+1+1+1+1   % Well, not much to explain
11: ['','RR'-'!']  % RR are [82,82] in ASCII, subtract 33 (!) to get
                   % [49,49], and concatenate with the empty string to convert [49,49] to 11 
12: nnz nnnnnnnnnnnn   % Number of non-zero elements in the string containing 12 n
13: "4"/4          % "4" = 52. Divide it by 4 to get 13.

JavaScript (ES7), 16 จำนวนเต็ม, 137 130 128 ไบต์

ฉันตอบ @ETHproductions 'และวิ่งไปหามันซักพัก มันเปลี่ยนไปมากจนฉันโพสต์แยกต่างหาก ยินดีต้อนรับไอเดีย :)

""**""
-~-~{}
3
C=CSS==CSS;C<<C<<C
5
6
7
8
9
++[[]][+[]]+[+[]]
11
4444444444444444444%44
222>>2>>2
`..............i`.indexOf`i`
0XF
atob('MTY')

ที่เหลือ:
$_@#!^&|/?:, ABDEGHIJKLNPQRUVWZcghjklmpqrsuvwyz

หรือหากข้อมูลโค้ดสำหรับ 1 ถูกแทนที่ด้วย!!/!//!!/!/:
$_@#^&|*?:", ABDEGHIJKLNPQRUVWZcghjklmpqrsuvwyz

JavaScript (ES7), 16 จำนวนเต็ม, 127 ไบต์

สั้นลงหนึ่งไบต์ : P

""**""
-~-~{}
3
4
5
6
7
C=CSS==CSS;C<<C<<C<<C
9
++[[]][+[]]+[+[]]
11
`............i`.indexOf`i`
222>>2>>2
0XE
atob('MTU')
88888888888888888%88

ที่เหลือ: $_@#!/^&|?:,ABDFGHIJKLNPQRVWYZcghjklmpqrsuvwyz

Dyalog APL คะแนน 15, 89 ไบต์

≡''
≢###
3
4
⍴⍬⍬⍬⍬⍬
6
⌈○2
8
9
1E1
⎕D⍳⊂⎕D











l:l
7--7-×7
(~0 0 0 0 0 0 0 0 0 0 0 0 0 0)⊥~0
5+5+5

_{ขึ้นบรรทัดใหม่ก่อนl:lเป็นส่วนหนึ่งของ 12}

_{ช่องว่างใน 14 หมายถึงแท็บ}

> <>คะแนน 20, 93 90 74 65 ไบต์

(3 ไบต์บันทึกโดย Teal Pelican จำนวนไบต์ที่บันทึกโดย Jo King!)

iii((
2
3
ll{lll{[
5
6
7
8
!   00=0g
a
b
c
d
e
f
44*
'RA'%
999-9--
"&F#",,
1::+:++:+:+

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

คำอธิบาย:

• ในiii((แต่ละครั้งiพยายามรับอินพุต แต่เนื่องจากไม่มีสิ่งใดเลยจึงส่ง EOF = -1แทน จากนั้น(เป็นคำสั่งที่น้อยกว่าและเนื่องจาก-1ไม่น้อยกว่า-1มันผลักดันความผิดพลาด0; แต่(คำถามที่สองถามว่า-1น้อยกว่า0ซึ่งเป็นจริงหรือไม่ดังนั้นมันจึงผลักความจริง1ออกมา
• 2และ3ชัดเจน
• สำหรับll{lll{[ครั้งแรกที่lผลักดันให้ความยาวของสแต็คซึ่งเป็นแล้วสองผลักดันความยาวใหม่นำสแต็คที่จะ0 หมุนสแต็คซ้าย, แลกเปลี่ยนและ อีกสามs นำสแต็คที่จะ จากนั้นหมุนไปด้านหน้าและอดออมปิดแรกสิ่งในกองซึ่งเป็น0, 1{10l1, 0, 2, 3, 4{1[14
• 5, 6, 7และ8ที่เห็นได้ชัดเกินไป
• ใน!\t00=0g(ซึ่ง\tหมายถึงแท็บ) !ข้ามแท็บจากนั้น00=กดสองศูนย์และตรวจสอบว่าพวกเขาเท่ากันหรือไม่ - พวกเขาอยู่แล้วดังนั้นเราจึงได้รับความ1จริง หลังจากที่ผลักดันอื่น0ที่gได้รับตัวอักษรที่อยู่ในตำแหน่งของรหัสซึ่งเป็นแท็บที่มีรหัสตัวอักษร1,09
• aผ่านไปfแต่ละผลักดัน10ไป15ตามลำดับ (น่าจะทำให้มีความสุขเลขฐานสิบหก)
• 44*ผลักดันให้ทั้งสองและคูณพวกเขาร่วมกันสำหรับ416
• 'RA'ผลักดันให้รหัสอักขระของRและA(82 และ 65 ตามลำดับ) ไปยังกองแล้วคำนวณ%82 mod 65 = 17
• 999-9--9 - ((9 - 9) - 9) = 18ประเมิน
• "&F#"ผลักดันให้มีการใช้รหัสตัวละคร&, Fและ#ซึ่งเป็น38, 70และ35ตามลำดับ จากนั้นก็เป็นส่วนหนึ่งเพื่อให้เราได้รับ,38 / (70 / 35) = 19
• สุดท้าย1::ดัน1และซ้ำมันสองครั้ง+เพิ่มสองคนร่วมกันที่จะได้รับ2; :+ทำซ้ำ2และเพิ่มเข้าไปในตัวเองเพื่อรับ4; +เพิ่มของเหลือที่1จะได้รับ5; จากนั้นทำซ้ำและเพิ่มเป็นครั้งที่สองที่เกิดขึ้นใน:+:+20

นี่คือคะแนนสูงสุดที่เป็นไปได้ด้วย> <> ตัวอย่างข้อมูลใด ๆ ที่จะต้องมีคำสั่งบางที่จะเปลี่ยนสแต็คที่ว่างเปล่าลงไปในกองไม่ว่างเปล่าและมีเพียง 18> <> คำสั่งที่สามารถทำเช่นนั้น (คือi, lและตัวเลข0–9และa–f) บวกโหมดสตริง (คำแนะนำอื่น ๆ ไม่ว่าจะทำอะไรกับสแต็กเปล่า><v^/\|_#x!{}rหรือพยายามที่จะป๊อปบางสิ่งและข้อผิดพลาด?.+-*,%=():~$@[]on&gp) การเข้าสู่โหมดสตริงใช้อย่างใดอย่างหนึ่ง"หรือ'ดังนั้นจึงมี18 + 2 = 20ตัวอย่างที่เป็นไปได้

หากคุณสะดวกสบายมากขึ้นกับ unprintables กว่าฉันนี้เป็นไปได้ใน 53 ไบต์ขอบคุณโจคิง: 00=, iii((i-, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f, 2222***, !Xll$g, 11+::+:+:++, 'Y', "Z"ที่X, YและZจะถูกแทนที่ด้วยตัวอักษรที่มีรหัส17, 19และ20ตามลำดับ

MathGolf , 48 51 53 จำนวนเต็ม, 324 ไบต์

î
ª∞~
c±b±+
φⁿ_¥-
5
6
7
○¢i♀/
d²
♂
A
B
C
D
E
☻
F
G
H
I
J
K
L
M
N
O
P
Q
R
S
T
♥
U
V
W
X
Y
Z
♫¼¼¼¼
88888]Σ
41
╔½½½½½½½½½½½
π░3§3
22#22#
τ╥└
♦⌡⌡⌡⌡⌡⌡⌡⌡⌡
!⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠
'0$
ÿ@@@@£9
))))))))))))))))))))))))))))))))))))))))))))))))))
►◄╠•╠
"hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh"h 
♣(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((

2 คะแนน (และไบต์ที่แตกต่าง -2 ใช้สำหรับการ40) ขอบคุณที่@maxb

แต่ละบรรทัดเป็นโปรแกรมที่แยกจากกัน

ไบต์ที่ใช้ (92 ไบต์ที่ต่างกัน): îª∞~c±b+φⁿ_¥-567○¢i♀/d²♂ABCDE☻FGHIJKLMNOPQRST♥UVWXYZ♫¼8]Σ41╔½π░3§2#τ╥└♦⌡!⌠'0$ÿ@£9)►◄╠•╠"h ♣(

คำอธิบายและลิงก์ TIO:

MathGolf เป็นภาษาการเล่นกอล์ฟแบบใหม่ที่มีความเชี่ยวชาญในการแข่งขันกอล์ฟทางคณิตศาสตร์ มันมีตัวต่อแบบไบท์ไบต์จำนวนมากทำให้นี่เป็นความท้าทายที่สมบูรณ์แบบสำหรับมัน

1) î: กดค่า 1-indexed ของ loop ซึ่งเป็น 1 โดยค่าเริ่มต้น: ลองออนไลน์
2) ª∞~: กด [1]; เพิ่มเป็นสองเท่า ([2]); รายการป๊อปและผลักดันเนื้อหาลงในกอง: ลองออนไลน์
3) c±b±+: กด -2; จากนั้นป๊อปและกดค่าสัมบูรณ์ของมัน กด -1; จากนั้นป๊อปและกดค่าสัมบูรณ์ของมัน และเพิ่มเข้าด้วยกันลองออนไลน์
4) φⁿ_¥-: กดอัตราส่วนทองคำ (1.618033988749895); ก้อนมัน (4.23606797749979); ทำซ้ำด้านบนของสแต็ก ใช้โมดูโล่ 2 (0.23606797749979); ลบออกจากกัน: ลองออนไลน์
5,6,7) ตัวเลขตัวเอง: ลองออนไลน์
8) ลองใช้ออนไลน์ 9) : กด -3; กำลังสอง: ลองออนไลน์○¢i♀/ : กด 2048; แปลงเป็นสตริงเลขฐานสิบหก (800); ทอดสู่จำนวนเต็ม; กด 100 หาร:
d² 10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,24,25,25,26,27,27,28,27,28,27,28,29,30,31,32,33 34,35,36,37,38) กดตัวเลขในตัว ( ♂ABCDE☻FGHIJKLMNOPQRST♥UVWXYZ): ลองออนไลน์
39) ♫¼¼¼¼: กด 10000; จำนวนเต็มหารด้วย 4 สี่ครั้ง: ลองออนไลน์
40) 88888]Σ: กด 8 ห้าครั้ง ห่อไว้ในรายการ รวมรายการนั้น: ลองออนไลน์
41) หมายเลข: ลองออนไลน์
42) ╔½½½½½½½½½½½: กด 86400; จำนวนเต็มหารด้วย 2 สิบเอ็ดครั้ง: ลองออนไลน์
43) π░3§3: กด PI ( 3.141592653589793); โยนเพื่อสตริง; ป๊อปและดันอักขระ 0 ดัชนีที่สาม (4); กด 3; เอาต์พุตสแต็กทั้งหมดรวมเข้าด้วยกันโดยปริยาย:ลองออนไลน์ 48)
44)22#22#: กด 2 สองครั้ง; ใช้พลังของทั้งสอง (4); ทำมันอีกครั้ง; ส่งออกสแต็กทั้งหมดเข้าด้วยกันโดยปริยาย: ลองออนไลน์
45) τ╥└: กด 2 * PI (6.283185307179586); ป๊อปและผลักดันพลังของ 2 ด้านล่างมันใกล้เคียงที่สุด (4); ดันด้านบนของสแต็ค + 1 โดยไม่ต้องโผล่ (5); ส่งออกสแต็กทั้งหมดเข้าด้วยกันโดยปริยาย: ลองออนไลน์
46) ♦⌡⌡⌡⌡⌡⌡⌡⌡⌡: กด 64; ลดลง 2 เก้าครั้ง: ลองออนไลน์
47) !⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠: กดแกมม่า (n + 1) (1 โดยค่าเริ่มต้น); เพิ่มขึ้น 2 ยี่สิบสามครั้ง: ลองออนไลน์ : กดค่าลำดับของอักขระ '0': ลองออนไลน์ 49) : กดสตริง
'0$
ÿ@@@@£9"@@@@"; ป๊อปและกดความยาว (4); กด 9; ส่งออกสแต็กทั้งหมดเข้าด้วยกันโดยปริยาย: ลองออนไลน์
50) )))))))))))))))))))))))))))))))))))))))))))))))))): เพิ่มขึ้น 1 50 ครั้ง: ลองออนไลน์
51) ►◄╠•╠: กด 1,000,000; ผลักดัน 10,000,000; ป๊อปอัพทั้งสองและจำนวนเต็มหารพวกเขาด้วยกัน (10); กด 512; pop ทั้งสองและจำนวนเต็มหารพวกเขาด้วยกัน: ลองออนไลน์
52) "hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh"h : กดสตริง"hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh"; ดันความยาวของมัน (โดยไม่ต้อง popping สตริง); ลบทุกอย่างออกจากสแต็กยกเว้นรายการสุดท้าย: ลองออนไลน์
53) ♣(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((: กด 128; ลดน้อยลง 1 ครั้งเจ็ดสิบห้า: ลองออนไลน์

จะลองเพิ่มในภายหลัง ฉันยังคงมีบางสิ่งที่มีประโยชน์ที่เหลือรวมทั้งโมดูโลและคูณ%*

Java 8, 11 12 13, 39 ไบต์

Java มีเพียง 10 สัญลักษณ์สำหรับตัวเลข (0-9) และการเรียกใช้เมธอดและค่าคงที่ทั้งหมดต้องใช้ระยะเวลาดังนั้นฉันไม่แน่ใจว่าฉันจะได้รับมากกว่า 11 เอาต์พุต

ตัวละครจะถูกแปลงเป็นจำนวนเต็มโดยค่าเริ่มต้นเมื่อมีการใช้งาน

+1 ด้วยความช่วยเหลือของ @ OlivierGrégoire

i->-~i
2
3
4
5
6
7
8
9
'P'^'Z'
11
"::::::::::::"::length
0xD

คำอธิบาย:

i->-~i

lambda จำนวนเต็มซึ่งไม่รับอินพุตและส่งคืน 1 เมื่อพารามิเตอร์ไม่รับอินพุตค่าดีฟอลต์จะถูกใช้ตามเมตาโพสต์ด้านบนซึ่งสำหรับจำนวนเต็มคือ 0

2
3
4
5
6
7
8
9

จำนวนเต็มตามตัวอักษร

'P'^'Z'

XOR ของอักขระสองตัวเพื่อส่งคืน 10

11

จำนวนเต็มตามตัวอักษร

":::::::::::"::length

การแสดงออกแลมบ์ดาซึ่งจะส่งกลับความยาวของสตริง 12 ตัวอักษร

0xD

เลขฐานสิบหก 13

เชื่อมโยง TIOหากคุณต้องการตรวจสอบ

Gaiaคะแนน 25, 203 ไบต์

§‼
..⌉+⌉
₵P~~
4
5
6
∂Ql
8
9
¶c
11
'¡ċ⌋u⌋
--⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻
7:,Σ
Ø!))))))))))))))
øøw<øøw<«øøw<«øøw<«øøw<«
⟩‘
₸ḣ₸K$₸ḣ₸/S₸₸/=$
]]]]]]]]]]]]]]]]]]]n
⇑’e
0(((((((((((((((((((((_
22
“B”“↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺B”B
3₈×
ℍḥḥ

ฉันคิดว่านี่เป็นคะแนนที่สมบูรณ์แบบเพราะไม่มีข้อ จำกัด ใด ๆ สำหรับตัวละคร

คำอธิบาย

1 §‼

§เป็นอักขระเว้นวรรคเชื่อม‼โยงกับบูลีนดังนั้นผลลัพธ์คือ 1

2 ..⌉+⌉

.เป็นทางลัดสำหรับดังนั้นนี่คือ0.5ceil(0.5+ceil(0.5))

3 ₵P~~

₵P คือปี่ ~คือลบล้างค่าบิต การปฏิเสธ bitwise สองเท่าเป็นการตัดทอน

4 4

5 5

6 6

7 ∂Ql

∂Q เป็นรายการที่มีชื่อของวันในสัปดาห์ lคือความยาว

8 8

9 9

10 ¶c

จุดรหัสcของ linefeed¶ของเลื่อนบรรทัด

11 11

12 '¡ċ⌋u⌋

'¡  The string "¡"
ċ   Turn it into a list of code points: [161]
⌋   Minimum: 161
u⌋  Floored square root: 12

13 --⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻

-เป็นชวเลข-1, ⁻เป็นลบ ดังนั้นนี่คือ-1 - -1 - -1...เวลาเพียงพอที่จะทำให้ 13

14 7:,Σ

กด7, ทำสำเนา:, จับคู่,7 Σวินาทีสองรายการเข้ากับรายการและรวม

15 Ø!))))))))))))))

Øเป็นสตริงว่างดังนั้นØ!คือ 1 เพิ่ม)1 14 ครั้ง

16 øøw<øøw<«øøw<«øøw<«øøw<«

øø    Push two empty lists
w     Wrap one of them
<     [] < [[]]? (it is, so push 1)
øøw<  Do the same thing again to push another 1
«     Bitshift 1 left by 1
      Do that same thing again 3 more times to get 16

17 ⟩‘

การปิดสตริงด้วย‘ทำให้มันเป็นตัวอักษรฐาน -250 ⟩อยู่ที่ค่าไบต์ 17 ในหน้ารหัสของ Gaia

18 ₸ḣ₸K$₸ḣ₸/S₸₸/=$

₸     10
ḣ     doubled
₸     10
K     20 choose 10 (184756)
$     Digit list
₸ḣ₸/  20/10 (2)
S     Split the digit list at index 2 ([[1 8][4 7 5 6]])
₸₸/   10/10 (1)
=     Get the first element of that split ([1 8])
$     Join together and print 18

19 ]]]]]]]]]]]]]]]]]]]n

แต่ละรายการ]ล้อมรอบสแต็กในรายการ ทำเช่นนี้ 19 ครั้งและรับความลึกnของรายการ

20 ⇑’e

การปิดสตริงด้วย’ทำให้มันเป็นรายการของรหัสรหัสเพจeดัมพ์รายการบนสแต็ก ⇑มีรหัสจุด 20 ในเพจรหัส

21 0(((((((((((((((((((((_

ลดลง(0 21 ครั้งจากนั้นจึงลบล้าง_ครั้งแล้วลบล้าง

22 22

23 “B”“↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺B”B

แปลงสตริง“B”จากฐาน-24 ที่ตัวเลข 0-23 ↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺Bที่มี ผลที่ได้คือ23ผลที่ได้คือ

24 3₈×

3 × 8

25 ℍḥḥ

100 ℍลดลงครึ่งหนึ่งḥและลดลงครึ่งหนึ่งอีกครั้ง

C, 13 คะแนน

นี่เป็นเพียงค่าคงที่จำนวนเต็ม

0==0
__LINE__
3
4
5
6
7
8
9
1+1+1+1+1+1+1+1+1+1
'o'/'.' 
2*2*2*2-2-2
strlen("strlenstrlens")

1. 0==0ประเมินผลเป็น1
2. ถือว่ารหัสอยู่ในบรรทัดที่ 2 __LINE__= 2
3. ค่าคงที่จำนวนเต็ม
4. ค่าคงที่จำนวนเต็ม
5. ค่าคงที่จำนวนเต็ม
6. ค่าคงที่จำนวนเต็ม
7. ค่าคงที่จำนวนเต็ม
8. ค่าคงที่จำนวนเต็ม
9. ค่าคงที่จำนวนเต็ม
10. 1+1+1...= 1*10= 10
11. 'o'คือ 111 '.'หมายถึง ASCII ที่ไม่สามารถพิมพ์ได้ 0x10 111/10 = 11
12. (2<<2)= 8, 8*2= 16, 16-2-2= 12
13. ความยาวสตริง"strlenstrlens"= 13

โอห์ม , คะแนน21 22, 160 ไบต์ทั้งหมด

╓S@Ri
ΓΓ-Γ-Γ-
αê⌠
¡¡¡¡¼
5
▀lll▀l
ÑÑÑÑÑÑÑÿWÿk
ü`½½
9
..≥°
$$J
3dd
7ƒ
2≡≡≡Σ
║F
4º
0ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~
6DD++
8π
τ╛hτ*
"≤"≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤A
1111 11v11%L1111 11v11%L

ลองออนไลน์!

คำอธิบาย

1 ╓S@Ri

กดวินาทีของวันที่ / เวลาปัจจุบัน ( ╓S) รับช่วงรวมจาก 1 ถึงวินาที ( @) ย้อนกลับ ( R) รับองค์ประกอบสุดท้าย ( i) ซึ่งเป็น 1 เสมอ

2 ΓΓ-Γ-Γ-

Γ เท่ากับ -1 ดังนั้นนี่คือ (-1) - (-1) - (-1) - (-1) ซึ่งก็คือ 2

3 αê⌠

αêคือหมายเลขของออยเลอร์ (2.71828 ... ) ⌠คือเพดาน 3 คือผลลัพธ์

4 ¡¡¡¡¼

¡เพิ่มตัวนับ¼ผลักตัวนับ

5 5

แค่ตัวอักษร

6 ▀lll▀l

▀lll▀"of >ic"เป็นสตริงบีบอัดตัวอักษรซึ่งเทียบเท่ากับ lใช้ความยาวดังนั้นผลลัพธ์คือ 6

7 ÑÑÑÑÑÑÑÿWÿk

ก่อนอื่นเราจะเพิ่มตัวอักษรขึ้นบรรทัดใหม่ 7 ตัว ( Ñ) และสตริงว่าง ( ÿ) สแต็กถูกห่อในอาร์เรย์ ( W) แล้วพบดัชนีของสตริงว่างในอาร์เรย์นั้น

8 ü`½½

üเป็นอักขระเว้นวรรค `เพิ่มค่า ASCII ของมัน (32) จากนั้นจะลดลงครึ่งหนึ่งสองครั้ง ( ½½)

9 9

แค่ตัวอักษร

10 ..≥°

..เป็นตัวอักษร.ตัวอักษร มันจะได้รับ incremented ( ≥) ซึ่งแยกสตริงเป็นตัวเลขเริ่มต้นที่ 0 เพราะมันไม่ใช่ตัวเลขที่ถูกต้องและเพิ่มขึ้นเป็น 1 จากนั้นเราคำนวณ 10 ¹ ( °)

11 $$J

$ ผลักดันค่าปัจจุบันของการลงทะเบียนในขั้นต้น 1 ดังนั้นกด 1 สองครั้งเข้าร่วมสแต็กเข้าด้วยกันและพิมพ์

12 3dd

กด 3 แล้วเพิ่มเป็นสองเท่า

13 7ƒ

กดหมายเลข Fibonacci ที่ 7

14 2≡≡≡Σ

กด 2 คูณสามครั้งสามครั้งโดยปล่อยให้ 7 2 อยู่บนสแต็ก จากนั้นนำผลรวมของสแต็ก ( Σ)

15 ║F

║เป็นตัวคั่นสำหรับตัวอักษรตัวเลขฐาน 220 เนื่องจากนี่เป็นจุดสิ้นสุดของบรรทัดจึงไม่จำเป็นต้องยกเลิก

16 4º

คำนวณ 2 4

17 0ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~

òเป็นลบ bitwise ~เป็นลบเลขคณิต เมื่อรวมผู้ประกอบการเหล่านี้เราสามารถเพิ่ม 0 17 ครั้ง

18 6DD++

กด 6 ทำซ้ำสองครั้งและคำนวณ 6 + 6 + 6

19 8π

กดหมายเลขเฉพาะลำดับที่ 8

20 τ╛hτ*

กด 10 ( τ) รับองค์ประกอบแรก ( h) ของปัจจัยหลัก ( ╛) คูณด้วย 10

21 "≤"≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤A

เช่นเดียวกับตัวอย่างก่อนหน้าสตริง"≤"จะได้รับการแยกวิเคราะห์เป็น 0 เราลดลง 21 ครั้งจากนั้นรับค่าสัมบูรณ์

22 1111 11v11%L1111 11v11%L

ที่นี่เราคำนวณ 1111 div 11 mod 11 ซึ่งก็คือ 2 แล้วพิมพ์ 2 จากนั้นทำอีกครั้ง

PowerShell คะแนน12, 91 ไบต์ 14, 176 ไบต์

[byte]!![byte]                    # type gets cast to bool false, inverted, to int = 1
-   -$?-shl$?                   # -bool true is -1, shift left, negative. (Tab not space)
3
4
5
6
7
8
9
1+1+1+1+1+1+1+1+1+1
22/2                                           # use the 2
'uuuuuuuuuuuu'.LENGTH                          # string length
0xd
@{z=@{};Y=@{};YY=@{};w=@{};v=@{};U=@{};zz=@{};S=@{};r=@{};q=@{};p=@{};J=@{};K=@{};m=@{}}|% COU*             # count items in hashtable (space)

แก้ไข:

• ขอบคุณØrjan Johansen สำหรับการแนะนำเลขฐานสิบหกตัวอักษร 0xd สำหรับ 13 และการจัดเรียง 5 ใหม่เพื่อเพิ่ม 1 + 1 + 1 + 1 .. เป็นตัวเลือก
• เปลี่ยนความยาวของอาเรย์เป็นสตริงความยาว, [int] ถึง [ไบต์] และ hashtable เพื่อใช้ hashtables เป็นค่า, เพิ่มค่า(),""Pondering 15 ด้วยสิ่งที่ชอบ"ZZZZZZZZZZZZZZZA".InDeXof("A")แต่ไม่สามารถนำจุดหรือ 'e' มาใช้ซ้ำได้

PowerShell ไม่สามารถทำตัวแปรโดยไม่มี $, ไม่สามารถทำการยกกำลัง, การเลื่อนบิต, Pi, ceil () ฯลฯ ที่มีสัญลักษณ์พื้นฐานและส่วนใหญ่พิมพ์ coercian ไปยัง / จากบูลและถึง / จากตัวเลขเป็นสตริงดังนั้น มีขอบเขตค่อนข้างน้อยสำหรับการสร้างหมายเลขไวยากรณ์ต่ำ

TI-Basic (83 series) คะแนน21 22 23 24 25 (1003 ไบต์)

1:  A=A
2:  int(tan(tan(cos(cos(cos(B
3:  tanh⁻¹(√(√(√(√(√(√(√(√(√(√(C!°√(√(C!°
        √(√(√(√(√(√(C!°√(√(√(√(√(√(C!°√(
        C!°√(√(√(C!°√(C!°√(C!°√(√(√(√(√(
        √(C!°√(C!°√(C!°√(C!°
4:  4
5:  cosh(sinh⁻¹(cosh(sinh⁻¹(...sinh⁻¹(cosh(D    with 25 repetitions of cosh(
6:  6
7:  7
8:  8
9:  9
10: ₁₀^(₁₀^(E
11: 11
12: F nPr F/sin(tan⁻¹(...(sin(tan⁻¹(F nPr F     with 143 repetitions of sin(tan⁻¹(
13: det([[G≤G]...[G≤G]]ᵀ[[G≤G]...[G≤G           with 26 repetitions of G≤G
14: ln(tanh(not(H))...tanh(not(H)))
        ln(tanh(not(H)))^⁻not(H                 with 14+1 repetitions of tanh(not(H))
15: iPart(e^(e^(e^(I
16: sum(dim(identity(sum(dim(identity(sum(
        dim(identity(sum(dim(identity(J≥J
17: K nCr K+K nCr K+...+K nCr K                 with 17 repetitions of K nCr K
18: abs(i-i-...-i                               with 20 repetitions of i
19: rand→L:log(LL...LL→M:log(L→N:N⁻¹M           with 19 L's inside the log
20: mean(seq(OOO,O,O,sinh(sinh(cos⁻¹(O
21: ππ³√(π³√(ππ³√(ππ³√(ππ³√(π³√(³√(ππ³√(π³
        √(π³√(ππ³√(π³√(ππ³√(ππ³√(ππ³√(π³√(
        π³√(³√(ππ³√(ππ
22: 22
23: 3(3(3×√(3(3(3×√(3(3×√(3(3(3×√(3×√(3×√(
        3(3×√(3(3×√(3(3(3×√(3(3×√(3×√(3(3(
        3×√(3(3×√(3×√(3×√(3(3(3×√(3(3×√(3(
        3(3×√(3×√(3(3(3×√3
24: Fix 0
    sin⁻¹(ᴇ0
    AnsAnsAnsAnsAnsAnsAns
25: 5*5

อ้างถึงhttp://tibasicdev.wikidot.com/one-byte-tokensสำหรับรายการสิ่งที่ท้าทายทำและไม่อนุญาตที่นี่

ทั้งหมดนี้เป็นโปรแกรมที่สมบูรณ์เนื่องจากบรรทัดสุดท้ายของโปรแกรมจะถูกพิมพ์โดยอัตโนมัติ แต่ (ยกเว้นสำหรับ 17 ซึ่งยาวหลายบรรทัด) พวกเขายังสามารถเป็นตัวอย่างบนหน้าจอหลัก

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

คำอธิบาย

• A=A เป็นบูลีน 1 เนื่องจากตัวแปร Aมีค่าเท่ากับตัวเอง
• B เป็น 0 โดยค่าเริ่มต้น tan(tan(cos(cos(cos(Bคือประมาณ 2.21 แล้วเราก็ลงพื้น
• C!°เรเดียนคือ 1 องศาประมาณ 0.017 พลังเชิงบวกของสิ่งนี้คือ tanh (2) ประมาณ 0.964 เราเข้ารหัสพลังนั้นเป็นเลขฐานสองโดยใช้การคูณโดยนัย√(และจากนั้นก็เอาtanh⁻¹(จากนั้นใช้เวลา
• 4 คือตรงไปตรงมา
• cosh(sinh⁻¹(X$\sqrt{1+X^2}$
• 6-9 ตรงไปตรงมา
• ₁₀^( เป็นหนึ่งไบต์ในตัวสำหรับพลังของ 10 และ 10 ^ 10 ^ 0 = 10 ^ 1 = 10
• 11 คือ 11
• F nPr Fsin(tan⁻¹(X$\frac{1}{\sqrt{1+1/X^2}}$
• G≤Gเท่ากับ 1 ดังนั้น[[G≤G]...[G≤G]]เวกเตอร์คอลัมน์ 13x1 คือ การถ่ายโอนผลิตภัณฑ์ด้วยตัวมันเองจะทำให้เมทริกซ์[[13]]ซึ่งมีค่าเท่ากับ 13
• not(H)เป็น 1. tanh(not(H))เป็นเพียงตัวเลขบางตัวที่ไม่เท่ากับ 0 หรือ 1 และln(XXX....X)ln(X)^⁻1จะทำให้จำนวนของXในบันทึกแรกง่ายขึ้นซึ่งXไม่ใช่ 0 (เพื่อให้บันทึกมีอยู่) และไม่ใช่ 1 (เพื่อเราจะไม่หาร โดย 0)
• e^(e^(e^(F หาค่าประมาณ 15.15 แล้วเราก็ลงพื้น
• J≥Jคือ 1. identity(สร้างเมทริกซ์เอกลักษณ์ 1x1 dim(ค้นหาขนาดของแถวและคอลัมน์และsum(เพิ่มพวกมันเพื่อรับ 2 จากนั้นเราทำอีกครั้งเพิ่มมิติของเมทริกซ์ 2x2 ให้ได้ 4 และอีกครั้งเพิ่มมิติของเมทริกซ์ 4x4 เพื่อรับ 8 และอีกครั้งเพิ่มขนาดของเมทริกซ์ 8x8 เพื่อรับ 16
• K nCr K คือสัมประสิทธิ์ทวินาม 0 เลือก 0 หรือ 1 การบวก 17 เข้าด้วยกันจะให้ 17
• i-i-...-i ลดความซับซ้อนของ⁻18iและการ abs(ให้ 18
• rand→Lเก็บจำนวนจริงสุ่มเป็น L แต่เราไม่สนใจว่ามันคืออะไร เรากำลังคำนวณlog(L)⁻¹log(L^19)ซึ่งง่ายต่อการ 19
• sinh(sinh(cos⁻¹(Iมีค่ามากกว่า 4 ดังนั้นseq(III,I,I,sinh(sinh(cos⁻¹(Iให้รายการ{0 1 8 27 64}ที่มีค่าเฉลี่ยเลขคณิตเท่ากับ 20
• ตัวอย่างของการหลอกลวงที่ใช้ในการรับ 3. ที่นี่พลังบางอย่างπควรให้ 21; เราเข้ารหัสการใช้พลังงานใน ternary ³√(ว่าการใช้การคูณและโดยนัย
• 22 คือ 22
• อีกตัวอย่างของการหลอกลวงที่ใช้ในการรับ 3 และ 21 เราเข้ารหัสพลังของ 3 ซึ่งเท่ากับ 23 ในไตรภาคโดยใช้3×√(เป็นรูตคิวบ์และ(สำหรับการคูณ
• Fix 0เป็นการตั้งค่าสำหรับการแสดง 0 ดิจิตหลังจากทศนิยมการปัดเศษค่าทั้งหมดเป็นจำนวนเต็ม sin⁻¹(ᴇ0หาค่าπ / 2 และπ / 2 คูณด้วยตัวมันเอง 7 ครั้งให้ประมาณ 23.59 ซึ่งปัดเป็น 24
• 5*5คือ 25 (มันจะอนุรักษ์นิยมมากกว่าที่จะใช้5เพื่อให้ได้ 5 และปรับแก้ปัญหาที่ใช้สำหรับ 25 แต่วิธีนี้จะช่วยประหยัดพื้นที่ได้มากและ*ไม่ใช่ตัวละครที่มีประโยชน์มากเพราะมีการคูณโดยนัย)

SOGL , คะแนน16 18 20, 109 ไบต์, 47 ตัวอักษรที่ใช้

=                    push ""=""
ρ:¾/U                ceil(isPalindrome("")/(isPalindrome("")*(3/4))) -> ceil(1/(3/4)) -> ceil(4/3)
3                    push 3
MM¼÷                 100/(100*1/4)
æ⁄                   length of "aeiou"
6                    push 6
7                    push 7
Nτ                   log2(256)
9                    push 9
L                    push 10
⁹’                   byte with the 11th SOGL code point
Ιζrkk"⁸              `⁸`s UTF-8 codepoint to string, take off 1st 2 chars
'⁰                   messy compression
īuHHHHHHHHHHHHHH±    floor(0.1) `-1` 14 times, then change sign
aIIIIIIIIIIIIIII     A `+1` 15 times, A = 0
4²                   4^2
lllllllllllllllll”l  length of "lllllllllllllllll"
222222222++++++++    2+2+2+2+2+2+2+2+2
δ“○“-                429-420
Μ℮‘                  compressed string of "2ŗ" where ŗ defaults to 0

Brachylog 16 จำนวนเต็ม 86 ไบต์

1
2
3
4
5
6
7
8
9
ℕ<<<<<<<<<<
≜+₁₁
Ịbkkkkkkkị
Ḥl
ℤ₇×₂ṅ
"____**"pᶜ¹
⟦h>>>>>>>>>>>>>>>>ȧ

ลองออนไลน์! (อินพุตควบคุมโปรแกรมที่รันตั้งแต่ 1 ถึง N)

คำอธิบาย

                       The output is...

1                      1
2                      2
3                      3
4                      4
5                      5
6                      6
7                      7
8                      8
9                      9
ℕ<<<<<<<<<<            Strictly bigger than ... strictly bigger than 0
≜+₁₁                   0 + 11
Ịbkkkkkkkị             "12" converted to an integer
Ḥl                     The length of "Hello, World!"
ℤ₇×₂ṅ                  -(-7 × 2)
"____**"pᶜ¹            The number of unique permutations of "____**"
⟦h>>>>>>>>>>>>>>>>ȧ    The absolute value of stricly less than ... stricly less than 0

เยลลี่ , คะแนน 22, 177 ไบต์

1: Ṇ  : logical NOT. When there is no input, 0 is assumed, so this returns NOT(0)=1
2: ~A~A  : ~ is bitwise NOT and A is absolute value, implicit 0 input
         : 0~ = -1;   0~A = 1;   0~A~ = -2;  0~A~A = 2.
3: 3  : literal 3
4: -ı-²²×-Ḟ:
   -ı-     : literal complex number -1-1j
   ²²×-    : square (2j), then square(-4), then multiply by (×) negative 1 (-) to get 4+0i
   Ḟ       : get the real component, which is 4
5: 5  : literal 5
6: 6  : literal 6
7: 7  : literal 7
8: 8  : literal 8
9: ØDṪ : tail(Ṫ) of list of digits (ØD) to return 9
10: ⁵  : literal 10
11: 11 : literal 11
12: CNCNCNCNCNCNCNCNCNCNCNC : again, 0 is taken as input because there is no input
                            : C is complement and N is negate
                            : so each NC returns 1-(-n)=n+1 and is equivalent to increment, returning 12
13: “>>>>>»L    : encodes "#GlomAbducens" with “>>>>>» then returns the length in characters (13) with L
14: ‘‘‘‘‘‘‘‘‘‘‘‘‘‘   : default input is 0 again, and each ‘ increments it to get 14
15: Ị;Ị;Ị;Ị;Ị;Ị;Ị;Ị;Ị;Ị;Ị;Ị;Ị;Ị;ỊS : default input is 0 again.
                                   : each Ị returns abs(0)<1 = 1
                                   : these are concatenated together with ; then summed with S to get 15
16: ⁴  : builtin literal 16
17: ,,,,,,,,,,,,,,,,,ŒḂŒḊ : Each , is the pair dyad: x,y = [x,y] and x,[y,z] = [x,[y,z]]. 
                          : Thus each , increased the depth by 1, then ŒḊ returns the depth: 17
18: 9Ḥ : 9 doubled = 18
19: E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E : each E returns areallelementsidentical([0]) = 1
                                          : 19 of these are summed with +
20: 44440b44ạ/ : 44440 base 44 = [22,42,0].
               : ạ/ takes the absolute difference of terms: ||22-42|-0| = 20
21: ”TOHH : ”T is the character literal "T". OHH returns its ascii value 84 (O) halved twice (HH) = 21
22: literal 22

ลองทั้งหมดในคราวเดียวหรือลองทีละครั้ง (อาร์กิวเมนต์เป็นผลลัพธ์ที่คุณต้องการ)

ตัวละครที่ไม่ได้ใช้:

¡¢£¤¥¦©¬®µ½¿€ÆÇÐÑÞßæçðȷñ÷øœþ !"#$%&'()*.:<=?@BFGIJKMPQRUVWXYZ[\]^_`acdefghijklmnopqrstuvwxyz{|}¶°¹³⁶⁷⁸⁹⁺⁻⁼⁽⁾ƁƇƊƑƓƘⱮƝƤƬƲȤɓƈɗƒɠɦƙɱɲƥʠɼʂƭʋȥẠḄḌẸḲḶṂỌṚṢṬỤṾẈỴẒȦĊĖḞĠḢİĿṀṄȮṖṘṠẆẊẎŻḅḍẹḥịḳḷṃṇọṛṣṭụṿẉỵẓȧḃċḋėḟġḣŀṁṅȯṗṙṡṫẇẋẏż«’

Reng, คะแนน 40, 149 bytes

ลองที่นี่!

1.  e
2.  2
3.  ::l
4.  4
5.  5
6.  i`i`i`i`i`i`+++++
7.  7
8.  8
9.  9
10. A
11. ÇÇÇǹ
12. C
13* [[[[[[[[[[[[[mn~
14. E
15. F
16. G
17. H
18. I
19. J
20. K
21. L
22. M
23. N
24. O
25. P
26. Q
27. R
28. S
29. T
30. U
31. V
32. W
33. X
34. Y
35. Z
36. 6²
37. "%"
38* &fæ¦
39. D3*
40. 11±$1±±±±±±±±$11±$1±±±±$±$

ตัวอักษรตัวพิมพ์ใหญ่ทั้งหมดเป็นตัวเลข ทั้งหมดยกเว้นสองตัวอย่างนี้เป็นตัวอย่าง สองโปรแกรมคือ:

13. [[[[[[[[[[[[[mn~
38. &fæ¦

ลิงก์ที่ให้ไว้จะทำให้สามารถเห็นสแต็กได้ในขณะทำงาน ฉันจะเขียนคำอธิบายในภายหลัง

CJam, คะแนน 27, 168 ไบต์

1-3: X , Y,Z

ตัวแปรX, YและZจะเริ่มต้นได้ที่ 1, 2 และ 3 ตามลำดับ

4: ",,,,",

กดสตริง,,,,และใช้ความยาว

5-9: 5 , 6, 7, 8,9

ตัวอักษรตัวเลข

10-20 : A-K

ตัวแปรเริ่มต้น

21: U)))))))))))))))))))))

ตัวแปรถูกเตรียมใช้งานU 0กดUและเพิ่มขึ้น 22 ครั้ง

22: 22

ตัวอักษรตัวเลข

23: ';(((((((((';((((((((

ผลักดันตัวละคร;และพร่องมันครั้งที่ 9 ที่จะได้รับ2แล้วกด;อีกครั้งและพร่องมันครั้งที่ 8 3ที่จะได้รับ

24: 4m!

รับแฟคทอเรียลของ 4

25: TT=TT=+TT=TT=TT=TT=TT=++++

TT=1ผลักดัน 1 1+1 1 1 1 1++++รหัสนี้จะเทียบเท่ากับ

26: N:i~W-W-W-W-W-W-W-W-W-W-W-W-W-W-W-W-

Nผลักสตริงที่มีขึ้นบรรทัดใหม่ แปลงเป็นรายการของรหัสตัวอักษรที่ให้ผลผลิต:i unpacks มันให้ เทียบเท่ากับการเพิ่มเข้าไป เพิ่มขึ้น 10 สิบหกครั้งให้ 26[10]~10W-

27: LLLLLLLLLLLLLLLLLLLLLLLLLLL0]0#

ค้นหาดัชนี 0 ในรายการที่ 0 อยู่ที่ดัชนีที่ 27

ตัวละครยังคงมีอยู่: $%&*./1<>?@MOPQRSV[\^_`abcdefghjklmnopqrstuvwxyz{|}

หมายเหตุเล็กน้อยสำหรับการขยายตัวที่อาจเกิดขึ้น:

• ฉันอาจต้องเปลี่ยน 10-20 เพื่อใช้ตัวแปรสำหรับอย่างอื่น ถ้าฉันได้ตัวเลขที่สูงกว่า 1 ฉันสามารถใช้*(และผู้ประกอบการระดับบิตได้ แต่ฉันไม่คิดว่าพวกเขาจะช่วยได้มาก)

• ฉันยังมีSสิ่งที่ดีที่จะทำกับฉัน

• ถ้าฉันเปลี่ยน 26 เป็นN{}/iW-W-W-W-W-W-W-W-W-W-W-W-W-W-W-W-แล้ว:จะสามารถใช้ได้

• ฉันสามารถผลักดันรายการที่ว่างเปล่าและรับค่าศูนย์ด้วยตัวแปรที่มีอยู่ ฉันสามารถรับπได้ แต่มันก็ดูไม่ค่อยมีประโยชน์เว้นแต่ว่าฉันสามารถส่งมันไปที่จำนวนเต็มอย่างใดและm(สำหรับm[) และiถูกใช้ไปแล้ว

• ในแง่ของการจัดการอาเรย์ฉันสามารถ:

  • ใช้แผนที่ด้วย%หรือf
  • ใช้เท่ากับ *
  • ทำการดำเนินการบางอย่าง setwise
  • การแปลงฐาน (ดูเหมือนว่าจะมีแนวโน้ม แต่ฉันไม่รู้ว่าจะรับหมายเลขฐานได้อย่างไร)
  • สร้างอาร์เรย์โดยใช้|:M1|2|3|

Haskellคะแนน 13, 86 ไบต์

pi/pi
sum[sum[]^sum[],sum[]^sum[]]
3
4
5
6
7
8
9
length"eeeeeeeeee"
11
2+2+2+2+2+2
0xD

ลองออนไลน์!

ขอบคุณØrjan Johansen สำหรับการหาวิธีแก้ไขตัวอักษรของฉันทับซ้อนในขณะที่รักษาคะแนนสิบสาม (สำหรับการออกนอกเส้นทางของพวกเขาเพื่อแจ้งให้ฉันทราบเกี่ยวกับเรื่องนี้ในขณะที่คำตอบนี้ถูกลบ)

pi/pi1.0เป็น
sum[]ประเมิน0, 0^0การ1และการ sum[1,1] เพื่อถอดรหัสตัวเอง ผลตอบแทนถัวเฉลี่ยความยาวของสตริงซึ่งเป็น เป็น เป็นเลขฐานสิบหกสำหรับ239
length"eeeeeeeeee"10
2+2+2+2+2+212
0xD13