วุ้นเป็นนัยกอล์ฟที่มุ่งเน้นการเขียนโปรแกรมภาษาโดยเราเองมากเดนนิส มันโผล่ขึ้นมาในคำตอบที่นี่บ่อยขึ้นเรื่อย ๆ เต้นภาษากอล์ฟ y อื่น ๆ เช่น Pyth และ CJam โดยใช้หน้ารหัสของตัวเองและระบบลูกโซ่ที่ทรงพลังเพื่อแสดงรายการที่ชัดเจน

รวบรวมเคล็ดลับที่เป็นประโยชน์สำหรับการเล่นกอล์ฟในเยลลี่ (เช่นเคยหนึ่งเคล็ดลับต่อคำตอบโปรด!)

การบีบอัดสตริง

หากคุณกำลังมองหาคอมเพรสเซอร์สตริงที่ได้รับการปรับให้เหมาะสมที่สุด / อัตโนมัติลองใช้อันนี้ดู

ลองออนไลน์!

สตริงที่ถูกบีบอัดจะมีลักษณะเหมือนกัน“...»โดยที่จุดต่างๆนั้นเป็นข้อมูลอันเข้ารหัสจำนวนฐาน 250 อัลกอริธึมการคลายบีบอัดมีความซับซ้อนเพียงเล็กน้อย: ก้อนถูกตีความว่าเป็นจำนวนเต็ม“ ฐานผสม” โดยdivmodแยกส่วนต่าง ๆ ของจำนวนเต็มนี้และสร้างสตริงออกมา

ฉันได้สร้างอินเทอร์เฟซ Python 3 เล็กน้อยเพื่อบีบอัดสตริงเจลลี่:

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

class Compress(list):
    def character(self, c):
        if c in '\n\x7f¶':
            o = 95
        elif ' ' <= c <= '~':
            o = ord(c)-32
        else:
            raise ValueError(c + " is neither printable ASCII nor a linefeed.")
        self += [lambda z: 3*z+0, lambda z: 96*z+o]; return self
    def string(self, s):
        for c in s: self.character(c)
        return self
    def dictionary(self, w):
        ts = bool(self)
        if w[:1] == ' ': w = w[1:]; ts = not ts
        dct = dictionary.short if len(w) < 6 else dictionary.long
        W, sc = (w, 0) if w in dct else (w[:1].swapcase() + w[1:], 1)
        if W not in dct: raise ValueError(w + " isn't in the dictionary.")
        f = ts or sc; j = (2 if sc else 1) if ts else 0; i = dct.index(W)
        self += [lambda z: 3*z+2, lambda z: 3*z+j] if f else [lambda z: 3*z+1]
        self += [lambda z: 2*z+int(len(w) < 6), lambda z: len(dct)*z+i]
        return self
    def go(self):
        compressed = []; z = 0
        for f in self[::-1]: z = f(z)
        while z:
            c = z % 250
            if c == 0: c = 250
            z = (z - c) // 250
            compressed.append(code_page[c - 1])
        return '“{0}»'.format(''.join(compressed[::-1]))

ใช้คอมเพรสเซอร์ดังต่อไปนี้

print(Compress()
      .dictionary('public')
      .dictionary(' static')
      .dictionary(' boolean')
      .string(' is')
      .dictionary('Power')
      .string('Of')
      .dictionary('Ten')
      .string('(')
      .dictionary('long')
      .dictionary(' input')
      .string(') {\n ')
      .dictionary(' return')
      .string('\n   ')
      .dictionary(' input')
      .string(' ==')
      .go())

Compress เป็นตัวสร้างสตริง:

• .string(s) จะแทรกอักขระ ASCII แบบดิบและพิมพ์ลงในสตริงได้

  (อักขระแต่ละตัวมีค่าใช้จ่ายประมาณ 0.827 ไบต์ที่บีบอัด)

• .dictionary(w)จะค้นหาสตริงในพจนานุกรมในตัวของ Jelly คุณอาจเริ่มต้นสตริงด้วยช่องว่างเดียวหากคุณต้องการ หากสิ่งนี้จำเป็นต้องเบี่ยงเบนจากพฤติกรรมการเพิ่มสตริงปกติหรือพลิกตัวพิมพ์ใหญ่ของคำในพจนานุกรมก็จะเพิ่มการตั้งค่าตามลำดับ

  (ค่าใช้จ่ายประมาณ 1.997 ไบต์สำหรับคำสั้น ๆ 2.433 ไบต์สำหรับคำยาวหากมีแฟล็กให้เพิ่ม 0.199 ไบต์)

นี้เป็นส่วนหนึ่งของสิ่งที่กลายเป็นเจลลี่วิกิพีเดียกวดวิชา

ห่วงโซ่

(นี่คือการเรียงลำดับของการติดตามการเขียนโปรแกรม Tacit )

เยลลี่ประเมินโซ่อย่างไร ตามที่อธิบายไว้ก่อนที่จะมีสามกรณีที่จะต้องพิจารณาไม่ว่าห่วงโซ่นี้ถูกเรียกว่าniladically , monadicallyหรือdyadically

1. โซ่ Niladic

นี่เป็นพวงที่ง่ายที่สุด เพื่อประเมินโซ่ niladic ที่จะเริ่มต้นกับ nilad เช่นα f g hประเมินห่วงโซ่เอกf g hที่ αnilad (Caveats: ถ้าโซ่ทั้งหมดว่างเปล่าจะถูกส่งคืน 0 แทนหากα ไม่ใช่ nilad ให้เปลี่ยนใช้α=0แทน)

ยกตัวอย่างเช่น4½เป็นเพียงการ½ประเมินซึ่งเป็น42

2. โซ่ Monadic

โซ่แบบโมนาดิคจะถูกแยกย่อยจากซ้ายไปขวาจนกว่าจะไม่มีลิงก์เหลือให้พิจารณา นอกจากนี้เรายังผ่านการโต้แย้งωที่นี่ มีสองคำถามที่จะตอบ:

ค่าเริ่มต้นสำหรับการประเมินจากซ้ายไปขวาคืออะไร

• หากห่วงโซ่ของเราเริ่มต้นด้วย nilad αและตามด้วยศูนย์หรือมากกว่า (เช่น½), คู่ dyad-nilad (เช่น+2) และคู่ nilad-dyad (เช่น4*): เราเริ่มต้นโดยการประเมินαแล้วพิจารณาส่วนที่เหลือของห่วงโซ่ .

• มิฉะนั้นเราจะเริ่มจากการโต้แย้งที่ส่งผ่านไปยังสายโซ่นี้ωและพิจารณาห่วงโซ่ทั้งหมด

เราจะเดินลงโซ่อย่างไร

ลองเรียกVค่าปัจจุบัน - ตอนแรกมันคือค่าที่อธิบายไว้ข้างต้น แต่มันจะได้รับการอัพเดทเมื่อเราผ่านสายโซ่ - และแสดงว่า

• nilads ใช้ตัวเลข
• monads ใช้ตัวอักษรตัวเล็ก
• dyads โดยใช้สัญลักษณ์ประกอบการ+, ,×÷

จากนั้นรูปแบบต่อไปนี้จะถูกจับคู่กับจากบนลงล่าง:

                                 ┌───────────┬─────────┐
                                 │ old chain │ new V   │
                                 ╞═══════════╪═════════╡
                                 │ + × 1 ... │ (V+ω)×1 │ *
                                 │ + f ...   │ V+f(ω)  │
                                 │ + 1 ...   │ V+1     │
                                 │ 1 + ...   │ 1+V     │
                                 │ + ...     │ V+ω     │
                                 │ f ...     │ f(V)    │
                                 └───────────┴─────────┘
      (* Only if `...` consists of monads, dyad-nilad pairs, and nilad-dyad pairs.)

ลองทำสิ่งนี้+²×กัน

• +ไม่ได้เป็น nilad V = ωดังนั้นเราจึงเริ่มต้นที่
• จากนั้นเราจะตัดตรงกับรูปแบบที่สองและได้รับ+²V = ω+ω²
• จากนั้นเราจะตัดตรงกับรูปแบบที่ห้าและได้รับ×V = (ω+ω²)×ω
• โซ่ว่างเปล่าดังนั้น(ω+ω²)×ωผลลัพธ์สุดท้ายของเราคือ

3. โซ่ไดยาดิค

สิ่งเหล่านี้เป็นเหมือนโซ่แบบ monadic แต่คราวนี้มีสองข้อโต้แย้งλ(ซ้าย) และρ(ขวา)

ค่าเริ่มต้นคืออะไร

• หากโซ่เริ่มต้นด้วยสามสีคล้าย+ × %กันเราเริ่มต้นλ+ρและพิจารณาห่วงโซ่× % ...ต่อไป

• มิฉะนั้นเราจะเริ่มจากλและพิจารณาห่วงโซ่ทั้งหมด

เราจะเดินลงโซ่อย่างไร

เวลานี้รูปแบบคือ

                                 ┌───────────┬─────────┐
                                 │ old chain │ new V   │
                                 ╞═══════════╪═════════╡
                                 │ + × 1 ... │ (V+ρ)×1 │ *
                                 │ + × ...   │ V+(λ×ρ) │
                                 │ + 1 ...   │ V+1     │
                                 │ 1 + ...   │ 1+V     │
                                 │ + ...     │ V+ρ     │
                                 │ f ...     │ f(V)    │
                                 └───────────┴─────────┘
      (* Only if `...` consists of monads, dyad-nilad pairs, and nilad-dyad pairs.)

ลองทำสิ่งนี้+×÷½กัน

• ห่วงโซ่เริ่มต้นด้วยสาม dyads ดังนั้นเราจึงเริ่มต้นที่และทิ้งV = λ+ρ+
• จากนั้นเราจะตัดตรงกับรูปแบบที่สองและได้รับ×÷V = (λ+ρ)×(λ÷ρ)
• จากนั้นเราจะตัดตรงกับรูปแบบที่หกและได้รับ½V = sqrt((λ+ρ)×(λ÷ρ))
• โซ่ว่างเปล่าตอนนี้เราก็เสร็จแล้ว

ค่าตัวเลขที่ใส่พิเศษ

ต่อไปนี้เป็นกรณีพิเศษสำหรับตัวแยกวิเคราะห์ตัวเลขของ Jelly:

• - ประเมินให้ -1
• . ประเมินให้ 0.5
• ȷประเมินเพื่อ1000( ȷสำหรับสัญกรณ์วิทยาศาสตร์เช่น2ȷ6เป็น2000000)
• ıหาค่าเป็น1j( ıสำหรับจำนวนเชิงซ้อน, เช่น2ı3คือ2+3j)

นอกจากนี้ยังเป็นที่น่าสังเกตว่าบางสิ่งบางอย่างเช่น4ıเป็นจริงมากกว่า4+1j4

คุณสามารถผสมและจับคู่สิ่งเหล่านี้ได้เช่น:

• -.เป็น-0.5และ-ȷเป็น-1000
• -ıเป็น-1+1j, ı-เป็น-1jและ-ı-เป็น-1-1j
• .ȷ คือ 500.0
• .ıเป็น0.5+1j, ı.เป็น0.5jและ.ı.เป็น0.5+0.5j
• ȷıเป็น1000+1j, ıȷเป็น1000jและȷıȷเป็น1000+1000j

ทราบว่าȷ-เป็นแต่ที่จะไม่บันทึกไบต์มากกว่า0.1 .1จากนั้นยังมีสิ่งต่อไปนี้ซึ่งสามารถทำได้ในจำนวนไบต์ที่สอดคล้องกันโดยใช้ตัวแปรบิวอินสำหรับ 10 ( ⁵) แต่อาจมีประโยชน์ในกรณีที่หายากซึ่งบิวอินนั้นไม่พร้อมใช้งานหรือเพื่อบันทึกเมื่อต้องการใช้¤:

• ȷ.เป็นsqrt(10) ~ 3.162277, .ȷ.เป็นsqrt(10)/2 ~ 1.5811และȷ-.เป็น1/sqrt(10) ~ 0.31162

การบีบอัดสตริงที่ปรับให้เหมาะสม

ลองออนไลน์!

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

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

วิธีการทำงานของโปรแกรมคือการบีบอัดโดยใช้วิธีการต่าง ๆ 3 วิธีและกำหนดว่าจะสั้นที่สุด:

1. วิธีที่ 1 เพียงเข้ารหัสแต่ละไบต์ของอินพุตในแต่ละครั้งซึ่งมีแนวโน้มที่จะให้ผลลัพธ์ที่ยาวที่สุดเมื่อเปรียบเทียบกับคนอื่น ๆ แม้ว่าอินพุตจะสั้นมาก แต่ก็ยังสามารถสร้างทางเลือกที่ค่อนข้างยาวได้ ตัวอย่างเช่นวิธีที่สั้นที่สุดที่testสามารถบีบอัดได้คือ“¡ḌY»ในขณะที่วิธีนี้จะส่งคืน“¡⁷ƑKʂ»(อีกต่อไป 2 ไบต์) ตามกฎทั่วไปจะใช้งานได้ก็ต่อเมื่อสตริงมีความยาวน้อยกว่า 4 อักขระ

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

   เครื่องหมายวรรคตอนรวมช่องว่างซึ่งเป็นที่ที่วิธีการหมายเลข 3 เข้ามาเล่น แต่ก่อนอื่นและการประเมินผลของวิธีที่ 2: ลองเปรียบเทียบวิธีที่หนึ่งและสองการบีบอัดสตริงHello, World!(มีคำเครื่องหมายวรรคตอนและช่องว่างจึงสมบูรณ์แบบ) ตัวละครที่บีบอัดโดยผลตัวละครในสตริงสุดท้ายของ“ŒCdẉa÷¹ṂȤƓ(Ẋ)»(15 ไบต์ยาว) “Hello, World!ซึ่งเป็นมันจะเปิดออกมาเป็นเวลานานกว่าวิธีที่ง่ายต่อการส่งออกสวัสดีโลก ตอนนี้ลองมาดูวิธีที่สอง สิ่งนี้สร้างสตริงที่บีบอัด“Ọƥ⁷Ƭė3⁶»ซึ่งมีน้ำหนักอยู่ที่ 9 ไบต์ซึ่งเป็นการปรับปรุงที่ดีกว่าเก่า อย่างไรก็ตาม Hello, World ที่สั้นที่สุด โปรแกรมใน Jelly คือ8 ไบต์ดังนั้นสิ่งที่สามารถปรับปรุงได้

3. นี่คือวิธีที่ 3 ทำให้สั้นลง แน่นอนว่าผลลัพธ์สำหรับ Hello World นั้นเป็นหลักสูตร“3ḅaė;œ»ที่สั้นที่สุดเท่าที่จะเป็นไปได้ ดังนั้นวิธีที่ 3 ทำเช่นนั้นวิธีที่ 2 ไม่ได้? วิธีที่ 3 รวมช่องว่างโดด ๆ ลงในช่องว่างนำหน้าซึ่งตัวขยายการบีบอัดของเยลลี่มีธงสำหรับ ในรหัสสำหรับทั้งคอมเพรสเซอร์และตัวขยายการบีบอัดคุณสามารถดูรหัสเช่นif flag_space: word = ' ' + wordแสดงให้เห็นว่าช่องว่างนำเป็น a) สนับสนุนและ b) ประหยัด byte ดังนั้นตัวแยกสตริงจากวิธีที่สองจึงถูกปรับเพื่อให้มีการรวมช่องว่างด้วยตนเองลงในสตริงโดยตรงหลังจากนั้นเพื่อสร้างสตริงนำ ซึ่งหมายความว่าHello, World!มีการแยกวิเคราะห์เป็น["Hello", ",", " World", "!"]ซึ่งเมื่อบีบอัดมีเพียง 6 ไบต์ (8 เมื่อรวมถึงตัวคั่น) นี่เป็นวิธีการบีบอัดที่สั้นที่สุดเกือบตลอดเวลายกเว้น "ส่วนขยาย" ที่ฉันเพิ่ม

นี่เป็นโปรแกรมจำนวนมาก แต่มีตัวเลือกเพิ่มเติมอีกสองสามตัวที่ช่วยให้สามารถบีบอัดข้อมูลได้มากขึ้น

• ตรวจสอบโปรแกรมหรือไม่ว่าแต่ละรุ่นที่ถูกบีบอัดถูกต้องโดยใช้เดนนิสsss decompressor ที่วุ้นใช้ (ตรงไปที่แหล่งที่มา)
• คุณสามารถเห็นสตริงที่บีบอัดต่างกันทั้งหมดโดยสร้างอาร์กิวเมนต์บรรทัดคำสั่งแรก--debugซึ่งแทนที่จะแสดงเพียงสตริงที่บีบอัดที่สั้นที่สุดแสดงทั้ง 3 พร้อมกับสำเนา "นี่คือระยะสั้นที่สุด"
• โปรแกรมจัดการ "ไม่ใช่คำ"

ที่ไม่ใช่คำพูด

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

ฉันสร้างฟังก์ชั่น ( trim) ที่แยกสตริงเป็นจุดที่อย่างน้อยหนึ่งในส่วนของสตริงเป็นคำ ตัวอย่างเช่นknownsจะแบ่งออกเป็น["known", "s"]และให้โปรแกรมเพิ่มคำแรกผ่านการเพิ่มพจนานุกรม ( .dictionary) และส่วนที่สองของคำผ่านการ.stringโทร แต่สิ่งนี้ยังเหลือสองกรณีขอบ: สตริงที่ไม่มีคำในพวกเขา (เช่นajdl) และไม่ใช่คำที่มีคำในตอนท้ายเช่นabctestซึ่งจะไม่แยกตามtrimฟังก์ชั่น

เนื่องจากไม่มีวิธีในการค้นหาคำในสตริงที่ไม่มีคำใด ๆ วิธีที่ง่ายและสั้นที่สุดในการจัดการสิ่งเหล่านี้คือการเพิ่มคำเหล่านั้นด้วยตัวอักษรแบบตัวอักษรผ่านการ.stringโทร ดังนั้นจะได้รับเพิ่มขึ้นโดยajdl .string('ajdl')ในขณะที่ไม่ใช่คำที่ลงท้ายด้วยคำที่ได้รับการยอมรับเป็นหลักดำเนินการ Trimmer แต่ในทางกลับกันและการใช้.dictionaryและ.stringวิธีอื่น ๆ รอบไปที่ Trimmer ไปข้างหน้า

ตามที่ปรากฎการตัดแต่งสตริงไม่ว่าจากจุดเริ่มต้นหรือจุดสิ้นสุดแน่นอนว่าสั้นกว่าการเพิ่มอักขระแต่ละตัวลงในคอมเพรสเซอร์ตามที่แสดงโดยอินพุตabctest this stringซึ่งก่อให้เกิดผลลัพธ์การดีบักของ

Original        : abctest this string

Optimised       : “¡J+v(p⁸ụƘ$,»
Seperate spaces : “Ç⁴ṭḍµḄ7oeṂdḷp»
No trimmer      : “¤ɦ?Ɓ¢#fḲOạ⁾¶ɼȥƬ»
All characters  : “µẓþ"Y7_ḣṗḢ))9Þ⁴⁺Ẉ²)ɱ»
Non-compressed  : “abctest this string
Shortest        : “¡J+v(p⁸ụƘ$,»
=====

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

แน่นอนว่าเครดิตจำนวนมากสำหรับสิ่งนี้จะไปที่ Lynn เพื่อสร้างคอมเพรสเซอร์ดั้งเดิม

คุณสามารถใช้ตัวยกสามถึงเก้า ( ³⁴⁵⁶⁷⁸⁹) เพื่อเล่นกอล์ฟบางค่าที่ใช้โดยทั่วไป แต่สิ่งนี้ขึ้นอยู่กับจำนวนของอาร์กิวเมนต์บรรทัดคำสั่งและในกรณีของลิงก์บนอาร์กิวเมนต์ของลิงก์

• ³ ส่งคืน 100 และใช้ได้เฉพาะเมื่อไม่มีอินพุต
• ⁴ ส่งคืน 16 และใช้ได้เฉพาะเมื่อมีอินพุตมากที่สุดหนึ่งรายการ
• ⁵ ส่งคืน 10 และใช้ได้เฉพาะเมื่อมีอินพุตมากที่สุดสองรายการ
• ⁶ ส่งคืนช่องว่างหากมีอินพุตไม่เกินสามรายการ
• ⁷ ส่งคืนบรรทัดใหม่หากมีอินพุตไม่เกินสี่รายการ

อย่างไรก็ตามหากมีห้าอินพุตคุณโชคไม่ดี

เมื่อเร็ว ๆ นี้รุ่นใหม่ของภาษาได้ลดค่า³เป็น 100 และแนะนำอะตอมใหม่บางอย่างที่คืนค่าหรือ (สำหรับลิงก์) อาร์กิวเมนต์ของพวกเขา

• ⁸ ส่งคืนรายการว่างเปล่าทุกที่ยกเว้นลิงก์ที่มีอาร์กิวเมนต์ซ้ายส่งให้
• ⁹ ส่งคืน 256 ทุกที่ยกเว้นลิงก์ที่มีอาร์กิวเมนต์ถูกต้องส่งผ่านไปยังพวกเขา

หากคุณอยู่ในลิงค์และมีข้อโต้แย้งจากทั้งสองฝ่ายผ่านไปคุณก็โชคไม่ดี

ข้อผิดพลาดของสตริง

เครดิตไปAdnanสำหรับการใช้ประโยชน์จากนี้เป็นครั้งแรกในการเขียนโปรแกรมเพื่อ elasticize สตริง

เยลลี่ควรจะได้รับเลขคณิตตัวละครในวันหนึ่ง แต่จนกว่าจะเกิดขึ้นเราสามารถใช้ประโยชน์จากข้อเท็จจริงที่ว่า Python โอเวอร์โหลดตัวดำเนินการทางคณิตศาสตร์ส่วนใหญ่และเยลลี่นั้นจะไม่ทำการตรวจสอบประเภท

ตัวอย่างเช่น

“abcd”Ḥ

ไม่ควรทำอะไรที่มีประโยชน์ในตอนนี้ แต่เนื่องจากḤ(unhalve) มีการใช้งานเป็น

lambda z: z * 2

และอะตอมเลขคณิตเวกเตอร์ที่ความลึก0 (กล่าวคือพวกมันทำงานกับตัวเลขหรือตัวอักษร), โค้ดเยลลี่ข้างต้นให้ผลตอบแทน

['aa', 'bb', 'cc', 'dd']

โปรดระมัดระวังว่าสิ่งนี้จะสร้างสตริง Python ที่แท้จริง (ประเภท Jelly ไม่ควรมี) ดังนั้นสิ่งนี้จะไม่สามารถใช้ได้ในทุกสถานการณ์

ในทำนองเดียวกัน+/อาจมีประโยชน์ในการเชื่อมสตริงเข้าด้วยกันด้วยคำเตือนเดียวกัน

เครื่องอัดสตริงที่เหมาะสมที่สุด

เมื่อเร็ว ๆ นี้ฉันได้ขอให้ Erik the Outgolferเพิ่มโปรแกรมบีบอัดสตริงที่ปรับปรุงแล้วลงในหน้าอ้างอิง JHTแต่พวกเขาบอกว่า

ขออภัยดูเหมือนว่าคอมเพรสเซอร์จะไม่สามารถใช้งานได้อย่างเต็มที่
แต่ก็บอกได้ว่า“ugtestslug”เป็นไปได้ที่สั้นที่สุดugtestslugในขณะ“#ṀȮụḄPƇ»ที่ทำงานเช่นกัน

ดังนั้นฉันตัดสินใจที่จะใช้เครื่องอัดสตริงที่ดีที่สุด

วิธีง่ายๆ แต่รับประกันว่าจะหาค่าที่น้อยที่สุดเท่าที่จะเป็นไปได้

ใช้ข้อมูลจากการส่งออกไปยังstdin stdoutเช่นเดียวกับคอมเพรสเซอร์ดั้งเดิม¶หรือ (อักขระขึ้นบรรทัดใหม่ตามตัวอักษร) สามารถป้อนเป็นบรรทัดใหม่

การพยายามรันด้วยเครื่องหมายวรรคตอนจำนวนมาก (เช่นอินพุต¶-----¶) จะส่งออกสตริงที่ไม่มีการบีบอัด

แน่นอนมากของสินเชื่อเพื่อการนี้ไปลินน์สำหรับการสร้างคอมเพรสเซอร์เดิม

นี้เป็นส่วนหนึ่งของสิ่งที่กลายเป็นเจลลี่วิกิพีเดียกวดวิชา

การเขียนโปรแกรม Tacit

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

arityของการเชื่อมโยงเป็นแนวคิดที่สำคัญมาก ทั้งหมดของอะตอม - built-ins เช่น+และ½- arities มีการแก้ไข ลิงก์จะถูกจัดเรียงเป็นสามหมวดหมู่ขึ้นอยู่กับ arity:

• Niladsไม่มีการโต้แย้ง (arity 0); นอกเหนือจากคำสั่ง I / O และคำสั่ง stateful พวกเขาส่วนใหญ่แทนค่าคงที่ ตัวอย่างเช่นตัวอักษร3เป็น nilad

• Monadsรับหนึ่งอาร์กิวเมนต์ (arity 1) (ไม่มีการเชื่อมต่อกับการเขียนโปรแกรมการทำงาน monads ที่นี่) ตัวอย่างเช่น½(สแควร์รูท) เป็น monad

• สีย้อมใช้สองอาร์กิวเมนต์ (arity 2): อาร์กิวเมนต์ซ้ายและขวา ตัวอย่างเช่น+เป็น dyad

(โดยใช้คำคุณศัพท์เราบอกว่าลิงก์เป็นniladic , monadicหรือdyadic )

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

ตัวอย่างเช่น+½เป็นห่วงโซ่ของ+(นอกจาก) และ½(รากที่สอง) ในฐานะที่เป็น arities ที่เกี่ยวข้องขององค์ประกอบของห่วงโซ่นี้คือ 2 และ 1, เราเรียกมันว่า2,1 โซ่ ล่ามมีกฎที่เฉพาะเจาะจงสำหรับที่จะหมดสภาพโซ่ตั้งอยู่บนพื้นฐานของพวกเขา arities: กฎเหล่านั้นบอกว่าได้รับการป้อนข้อมูลนี้คำนวณเชื่อมโยงใหม่n n + sqrt(n)(คุณสามารถอ่าน+½ว่า“ ... บวกกับรากที่สองของมัน” )

การเขียนโปรแกรมวุ้นแล้วเป็นหลักศิลปะของการเรียนรู้กฎเหล่านี้อย่างดีและการแต่งโซ่ฉลาดที่ได้งานทำที่โดยปริยาย

นี้เป็นส่วนหนึ่งของสิ่งที่กลายเป็นเจลลี่วิกิพีเดียกวดวิชา

โครงสร้างโปรแกรม

บรรทัดในโปรแกรม Jelly แต่ละคนเป็นความหมายเชื่อมโยง ลิงค์เป็นฟังก์ชั่นพื้นฐาน บรรทัดล่างหมายถึง“ main”: เป็นลิงก์ที่ได้รับการประเมินโดยใช้อาร์กิวเมนต์ที่ส่งผ่านบนบรรทัดคำสั่ง

การเชื่อมโยงทั้งหมด แต่สุดท้ายแล้วความหมายฟังก์ชั่น: คุณสามารถดูได้โดยใช้นักแสดง ยกตัวอย่างเช่นçเป็น“การเชื่อมโยงดังกล่าวข้างต้นคนนี้เป็นผู้ประกอบการไบนารี (คู่)” พิจารณาตัวอย่างโปรแกรมนี้ซึ่งคำนวณกำลังสองของผลรวมของการขัดแย้ง:

+
ç²

นี่เป็นเหมือน pseudocode:

define f:
    the built-in link +
define main:
    apply the dyad f
    square the result

นี้เป็นส่วนหนึ่งของสิ่งที่กลายเป็นเจลลี่วิกิพีเดียกวดวิชา

ลิงค์หลายห่วงโซ่

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

พิจารณาโปรแกรมนี้:

C+H

นั่นเป็นส่วนเติมเต็มบวกครึ่ง มันต้องใช้เวลาคุ้มค่าการป้อนข้อมูลและการคำนวณn (1-n)+(n/2)ไม่น่าตื่นเต้นเกินไปฉันรู้ แต่โครงสร้างเป็นแบบนี้จริงๆ:

ลิงค์ที่เราเขียนคือจริงๆแล้วโซ่ที่มีห่วงโซ่เดียว

สมมติว่าเราต้องการคำนวณ(1-n)+(1-n)(n/2)แทน ห่วงโซ่ dyadic +×จะทำงาน: ตามกฎการผูกมัดมันคำนวณλ+(λ×ρ)ซึ่งมีลักษณะเหมือนสิ่งที่เราต้องการ แต่แค่เปลี่ยน+โดย+×ในโปรแกรมของเราจะไม่ทำ: C+×Hเป็น 1,2,2,1 โซ่ - สมบูรณ์แล้วเพิ่ม (อาร์กิวเมนต์) จากนั้นคูณด้วยครึ่งหนึ่ง - ((1-n)+n)×(n/2)คอมพิวเตอร์

เราต้องการที่จะรักษาวุ้น+×เป็นหน่วยและทำให้ 1,2,1 ห่วงโซ่ของการย่อยโซ่C, และ+× ลิงค์หลายสายให้เราทำอย่างนั้น! ในการสร้างพวกเราใช้ตัวแยกโซ่ : ในภาพด้านบนพวกเขาจะแนะนำสี่เหลี่ยมสีน้ำเงินใหม่ของ arity 0, 1 และ 2 ตามลำดับ ในกรณีของเราเราสามารถจัดกลุ่มโซ่ตามที่เราต้องการโดยการเขียน:H øµðCð+×µH

ไม่มีทางที่จะซ้อนสิ่งเหล่านี้ได้อีก คุณจะต้องกำหนดลิงก์หลายลิงก์แทน

ถ้า TMTOWTDI เลือกอันที่เหมาะกับโซ่ของคุณ

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

ตัวอย่างเช่นวิธีที่ตรงไปตรงมาในการหาผลรวมของอาร์เรย์ทั้งหมดในอาร์เรย์ 2D คือ

S€

ซึ่งแมปผลรวมอะตอมกับองค์ประกอบทั้งหมดของอาร์เรย์

ตอนนี้บอกว่าคุณมีห่วงโซ่ monadic ที่ประกอบด้วยอะตอม

*

แผนที่ซึ่งแต่ละxของอาร์เรย์ 2 มิติให้เป็นx x ตัวอย่างเช่นสำหรับA = [[1, 2], [3, 1], [2, 3]] การเรียกสายโซ่จะให้ผล[[1, 4], [27, 1], [4, 27] .

ตอนนี้เราต้องการหาผลรวมของแต่ละคู่ น่าเสียดาย,

*S€

ไม่ทำงานเนื่องจาก*ไม่ได้ทำหน้าที่เหมือนเบ็ดอีกต่อไป (โดยใช้ตัวเองเป็นอาร์กิวเมนต์ขวา) แต่เป็นส้อมหมายความว่าได้รับนำไปใช้กับแรกและผลที่ได้คืออาร์กิวเมนต์ขวาของS€*

แก้ไขสิ่งนี้ได้ง่ายพอ:

*¹S€
*⁸S€

ทั้งสองผลิตผลลัพธ์ที่ต้องการ: *¹เป็นทางแยกที่¹เป็นฟังก์ชั่นตัวตนและ*⁸เป็นบนยอดที่⁸มีการอ้างอิงถึงอาร์กิวเมนต์ด้านซ้ายของห่วงโซ่ ( A )

อย่างไรก็ตามมีวิธีการบันทึกไบต์! บนยอดḅ1(แปลงจากเอกจำนวนเต็ม) นอกจากนี้ยังคำนวณผลรวมของแต่ละอาร์เรย์ในแต่ไม่เหมือน, เป็นdyadicการเชื่อมโยงS€ḅ

โซ่

*ḅ1

ส่งคืน[5, 28, 31] (ตามต้องการ) ตั้งแต่ḅเป็น dyadic *ตะขอแทนที่จะฟอร์ก

การบีบอัดจำนวนเต็ม

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

ตอนนี้ Jelly มีหน้าโค้ดของตัวเองเป็นค่าคงที่อัลกอริทึมการบีบอัดสำหรับจำนวนเต็มจะแสดงใน Jelly อย่างง่ายที่สุด:

ḃ250ịØJ”“;;”’ṄV

ลองออนไลน์!

(โปรแกรมข้างต้นยังมีการตรวจสอบเพื่อแสดงค่าที่จำนวนเต็มคลายไป)

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

ใช้ผลิตภัณฑ์ด้านนอกเพื่อสร้างเมทริกซ์จำนวนเต็มที่มีประโยชน์

นี่คือส่วนสำคัญที่ฉันสร้างของโพสต์นี้ด้วยการจัดรูปแบบตาราง HTML ที่ดีกว่าเล็กน้อย

þสามารถติดตั้งผลิตภัณฑ์ด้านนอกอย่างรวดเร็วกับ dyads และทำให้ dyad ดำเนินการกับองค์ประกอบแต่ละคู่ในอาร์กิวเมนต์ซ้ายและขวา €Ð€มันเป็นชวเลข ตัวอย่างเช่นถ้าเรามีรหัส[1,2]+€Ð€[0,10]ที่เราจะตัดให้สั้นลงและพวกเขาจะให้ผลผลิตทั้ง[1,2]+þ[0,10] [[1,2],[11,12]]ฉันจะอ้างถึง dyad ที่þใช้ (เช่น+þ) เป็น dyad ผลิตภัณฑ์ด้านนอก

เมื่อจำนวนเต็มเป็นหนึ่งในอาร์กิวเมนต์ของ dyad ผลิตภัณฑ์ด้านนอก Jelly จะใช้ช่วงของตัวเลขนั้นก่อนจากนั้นใช้ผลลัพธ์เป็นอาร์กิวเมนต์ เมื่อทราบสิ่งนี้ตัวอย่างข้างต้นสามารถตัดให้สั้นลงไป2+þ[0,10]อีก สิ่งนี้เป็นจริงสำหรับทั้งข้อโต้แย้งด้านซ้ายและขวาของผลิตภัณฑ์จากภายนอก

ผลิตภัณฑ์ด้านนอกบางชนิดเมื่อทำหน้าที่แบบ monadically บนจำนวนเต็มจะได้เมทริกซ์จำนวนเต็มจำนวนหนึ่งที่สามารถเป็นประโยชน์ในการเล่นกอล์ฟ ตัวอย่างเช่น=þเมื่อนำไปใช้กับจำนวนเต็มnผลผลิตn×nเมทริกซ์เอกลักษณ์ ลอง=þออนไลน์!

ด้านล่างเป็นตารางของ dyads และประเภทของเมทริกซ์ที่พวกมันให้ผลผลิตเมื่อเปลี่ยนเป็น dyads ของผลิตภัณฑ์ด้านนอกและทำ monadically บนจำนวนเต็ม สีย้อมที่อยู่ในแถวเดียวกันจะให้เมทริกซ์เดียวกัน มี dyads ฉันยังไม่ได้รวมอยู่ในตารางเช่นมี&, |, %, w, ẇและḍที่ยังผลิตจำนวนเต็มเมทริกซ์ แต่รูปแบบของพวกเขาจะไม่เป็นที่เรียบง่ายและมีแนวโน้มที่จะเป็นประโยชน์ในสถานการณ์ที่น้อยลง ลองwþออนไลน์!

+ ------------------------------------------------- ---- +
| Dyad | เมทริกซ์ผลลัพธ์ ตัวอย่าง |
+ ------------------------------------------------- ---- +
| = ⁼ | | 1 0 0 |
| ċ | เมทริกซ์เอกลักษณ์ 0 1 0 |
| | | 0 0 1 |
+ ------------------------------------------------- ---- +
| | องค์ประกอบด้านบนเส้นทแยงมุมคือ 1, | 0 1 1 |
| <| องค์ประกอบอื่น ๆ ทั้งหมดเป็น 0 | 0 0 1 |
| | | 0 0 0 |
+ ------------------------------------------------- ---- +
| | องค์ประกอบด้านล่างเส้นทแยงมุมคือ 1, | 0 0 0 |
| > | องค์ประกอบอื่น ๆ ทั้งหมดเป็น 0 | 1 0 0 |
| | | 1 1 0 |
+ ------------------------------------------------- ---- +
| | องค์ประกอบเส้นทแยงมุมคือ 0, | 0 1 1 |
| n ⁻ | องค์ประกอบแนวทแยงมุมคือ 1 | 1 0 1 |
| | | 1 1 0 |
+ ------------------------------------------------- ---- +
| a ȧ | | 1 1 1 |
| ṛị | ดัชนีแถวของแต่ละองค์ประกอบ | 2 2 2 |
| | | 3 3 3 |
+ ------------------------------------------------- ---- +
| o ḷ | | 1 2 3 |
| ȯ | ดัชนีคอลัมน์ของแต่ละองค์ประกอบ | 1 2 3 |
| | | 1 2 3 |
+ ------------------------------------------------- ---- +
| | เส้นทแยงมุมหลักคือ 0, Upper | 0 1 2 |
| _ | เส้นทแยงมุมคือ 1, 2 ... , ล่าง | -1 0 1 |
| | เส้นทแยงมุมคือ -1, -2 ... | -2 -1 0 |
+ ------------------------------------------------- ---- +
| | เส้นทแยงมุมหลักคือ 0, ต่ำกว่า | 0 -1 -2 |
| _ @ | เส้นทแยงมุมคือ 1, 2 ... , Upper | 1 0 -1 |
| | เส้นทแยงมุมคือ -1, -2 ... | 2 1 0 |
+ ------------------------------------------------- ---- +
| | เส้นทแยงมุมหลักคือ 0, Upper | 0 1 2 |
| ạ | และเส้นทแยงมุมล่างคือ 1, | 1 0 1 |
| | 2, 3 ... | 2 1 0 |
+ ------------------------------------------------- ---- +
| | | 2 3 4 |
| + | ดัชนีแถวบวกดัชนีคอลัมน์ | 3 4 5 |
| | | 4 5 6 |
+ ------------------------------------------------- ---- +
| | แถวขั้นต่ำ | 1 1 1 |
| « | และดัชนีคอลัมน์ | 1 2 2 |
| | | 1 2 3 |
+ ------------------------------------------------- ---- +
| | สูงสุดของแถว | 1 2 3 |
| » | และดัชนีคอลัมน์ | 2 2 3 |
| | | 3 3 3 |
+ ------------------------------------------------- ---- +

รายการคำสั่งและตัวอักษร

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

คำสั่งเหล่านี้จะปรากฏใช้เรียกไปยังiterableฟังก์ชั่นในjelly.py

def iterable(argument, make_copy = False, make_digits = False, make_range = False):
    the_type = type(argument)
    if the_type == list:
        return copy.deepcopy(argument) if make_copy else argument
    if the_type != str and make_digits:
        return to_base(argument, 10)
    if the_type != str and make_range:
        return list(range(1, int(argument) + 1))
    return [argument]

นี่คือรายการที่ไม่สมบูรณ์ของสิ่งที่คำสั่งรายการเหล่านั้นจะทำ

ห่อในรายการ

การส่งคืนที่ง่ายที่สุดจากiterableเพื่อตัดอาร์กิวเมนต์ในรายการและส่งคืนที่จะประมวลผลโดยฟังก์ชัน สิ่งนี้จะเกิดขึ้นหากข้อโต้แย้งนั้นยังไม่มีอยู่ในรายการเป็นสตริงและiterableอาร์กิวเมนต์ของจะไม่เรียกใช้วิธีการอื่น

-------------------------------------------------------------------------------
| Command | Description     | Process                       | Effect          |
-------------------------------------------------------------------------------
| F       | Flattens a list | 4953F -> [4953]F -> [4953]    | Same as W       |
-------------------------------------------------------------------------------
| G       | Format a list   | 4953G -> [4953]G -> [4953]    | Same as W       |
|         | as a grid       |                               |                 |
-------------------------------------------------------------------------------
| I       | Increments      | 4953I -> [4953]I -> <nothing> | Empty list      |
-------------------------------------------------------------------------------
| S       | Sums a list     | 4953S -> [4953]S -> 4953      | Same as ¹       |
-------------------------------------------------------------------------------
| Ṭ       | Boolean array,  | 4Ṭ -> [4]Ṭ -> [0, 0, 0, 1]    | n-1 zeroes,     |
|         | 1s at indices   |                               | 1 at end        |
-------------------------------------------------------------------------------
| Ụ       | Sort indices by | 4Ụ -> [4]Ụ -> [1]             | Yields [1]      |
|         | by their values |                               |                 |
-------------------------------------------------------------------------------
| Ė       | Enumerate list  | 4Ė -> [4]Ė -> [[1, 4]]        | Yields [[1, n]] |
-------------------------------------------------------------------------------
| Ġ       | Group indices   | 4Ġ -> [4]Ġ -> [[1]]           | Yields [[1]]    |
|         | by values       |                               |                 |
-------------------------------------------------------------------------------
| Œr      | Run-length      | 4Œr -> [4]Œr -> [[4, 1]]      | Yields [[n, 1]] |
|         | encode a list   |                               |                 |
-------------------------------------------------------------------------------

แปลงเป็นฐาน 10

ฟังก์ชั่นที่นี่เรียกร้องiterableให้แปลงเป็นตัวเลขไปยังรายการตัวเลขDจากนั้นเรียกใช้กับตัวเลขเหล่านั้น

-------------------------------------------------------------------------
| Command | Description     | Process                      | Effect     |
-------------------------------------------------------------------------
| Q       | Unique elements | 299Q -> [2, 9, 9]Q -> [2, 9] | Unique     |
|         | ordered by      |                              | digits     |
|         | appearance      |                              | of n       |
-------------------------------------------------------------------------
| Ṛ       | Non-vectorized  | 4953Ṣ -> [4, 9, 5, 3]Ṛ       | Reverses D |
|         | reverse         | -> [3, 5, 4, 9]              |            |
-------------------------------------------------------------------------
| Ṣ       | Sort a list     | 4953Ṣ -> [4, 9, 5, 3]Ṣ       | Sorts D    |
|         |                 | -> [3, 4, 5, 9]              |            |
-------------------------------------------------------------------------

แปลงเป็นรายการที่มีช่วง

ฟังก์ชั่นที่นี่แปลงตัวเลขเป็นช่วงR = [1 ... n]แล้วเรียกใช้ในช่วงนั้น

-----------------------------------------------------------------------------------------
| Command | Description       | Process                             | Effect            |
-----------------------------------------------------------------------------------------
| X       | Random element    | 4R -> [1 ... 4]X -> 2               | Random element    |
|         |                   |                                     |  of R             |
|         |                   |                                     |                   |
-----------------------------------------------------------------------------------------
| Ḋ       | Dequeue from list | 4R -> [1 ... 4]Ḋ -> [2, 3, 4]       | Range [2 ... n]   |
-----------------------------------------------------------------------------------------
| Ṗ       | Pop from list     | 4Ṗ -> [1 ... 4]Ṗ -> [1, 2, 3]       | Range [1 ... n-1] |
-----------------------------------------------------------------------------------------
| Ẇ       | Sublists of list  | 4Ẇ -> [1 ... 4]Ẇ                    | All sublists of R |
|         |                   | -> [[1], [2], [3], [4], [1, 2],     |                   |
|         |                   |     [2, 3], [3, 4], [1, 2, 3],      |                   |
|         |                   |     [2, 3, 4], [1, 2, 3, 4]]        |                   |
-----------------------------------------------------------------------------------------
| Ẋ       | Shuffle list      | 4Ẋ -> [1 ... 4]Ẋ -> [2, 1, 3, 4]    | Shuffles R        |
-----------------------------------------------------------------------------------------
| Œ!      | All permutations  | 3Œ! -> [1, 2, 3]Œ!                  | All permutations  |
|         | of a list         | -> [[1, 2, 3], [1, 3, 2],           | of R              |
|         |                   |     [2, 1, 3], [2, 3, 1],           |                   |
|         |                   |     [3, 1, 2], [3, 2, 1]]           |                   |
-----------------------------------------------------------------------------------------
| ŒḄ      | Non-vectorized    | 4ŒḄ -> [1 ... 4]ŒḄ                  | Bounces R         |
|         | bounce,           | -> [1, 2, 3, 4, 3, 2, 1]            |                   |
|         | z[:-1] + z[::-1]  |                                     |                   |
-----------------------------------------------------------------------------------------
| Œc      | Unordered pairs   | 4Œc -> [1 ... 4]Œc                  | Unordered pairs   |
|         | of a list         | -> [[1, 2], [1, 3], [1, 4], [2, 3], | of R              |
|         |                   |     [2, 4], [3, 4]]                 |                   |
-----------------------------------------------------------------------------------------
| Œċ      | Unordered pairs   | 4Œċ -> [1 ... 4]Œċ                  | Unordered pairs   |
|         | with replacement  | -> [[1, 1], [1, 2], [1, 3], [1, 4], | with replacement  |
|         | of a list         |     [2, 2], [2, 3], [2, 4], [3, 3], | of R              |
|         |                   |     [3, 4], [4, 4]]                 |                   |
-----------------------------------------------------------------------------------------
| ŒP      | Powerset of       | 3ŒP -> [1 ... 3]                    | Powerset of R     |
|         | a list            | -> ['', [1], [2], [3], [1, 2],      |                   |
|         |                   |     [1, 3], [2, 3], [1, 2, 3]]      |                   |
-----------------------------------------------------------------------------------------
| Œp      | Cartesian         | 4,2Œp -> [[1 ... 4], [1 ... 2]]Œp   | Cartesian product |
|         | product of z's    | -> [[1, 1], [1, 2], [2, 1], [2, 2], | of [1 ... z[i]]   |
|         | items             |     [3, 1], [3, 2], [4, 1], [4, 2]] | for i in z        |
-----------------------------------------------------------------------------------------

บางครั้งมันก็คุ้มค่าที่จะอ่านจากอินพุตมาตรฐานเมื่อมีสองอินพุตที่แน่นอน

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

เช่นถ้าคุณใช้หนึ่งในสองปัจจัยการผลิตเพียงครั้งเดียวและที่เป็นปัญหาดังกล่าวว่าไม่สามารถอ่านได้โดยปริยายจาก⁴(เช่นคุณจำเป็นอย่างใดอย่างหนึ่งที่จะทำให้⁴ชัดเจนหรืออื่น ๆ การใช้จ่ายของตัวละครใน}, @หรือชอบ) พิจารณาการอ่านจากอินพุตมาตรฐานด้วยƓแทนที่จะวางไว้บนบรรทัดคำสั่ง ที่ช่วยให้คุณวางอินพุตได้อย่างแม่นยำในตำแหน่งที่คุณต้องการผ่านตำแหน่งของคุณƓในขณะที่มั่นใจได้ว่าอินพุตอื่น ๆ จะถูกนำมาจากอินพุตอื่นของคุณ ที่มีค่าใช้จ่ายไบต์และบันทึกไบต์และขึ้นอยู่กับปัญหาอาจบันทึกไบต์ที่สองโดยให้ขอบเขตเพิ่มเติมเพื่อจัดเรียงรหัสอีกครั้ง

มีหลายวิธีที่ nonobvious Ƒเพื่อตรวจสอบคุณสมบัติของการโต้แย้งในการใช้เป็น ด้านล่างมีบางส่วน ฉันซ้ายออกความอุดมสมบูรณ์ของการใช้งานของอย่างนี้ (เช่นAƑ, ŒuƑ, 3Ƒ) เพราะพวกเขามีอยู่แล้ววิธีที่ง่ายที่สุดในการบรรลุพฤติกรรมของพวกเขา

OƑ  Is number?
ỌƑ  Is character? (errors on negative numeric input)
ḂƑ  Between 0 and 2? 0<=x<2 (python). <2aAƑƊ or of course ⁼Ḃ$ in Jelly.
ḞƑ  Is integer?
UƑ  Like `ŒḂ`, but checks if all sublists of depth 1 are palindromes.
ṠƑ  Is one of -1, 0, 1? (e-r1¤$)

รู้สึกอิสระที่จะแก้ไขสิ่งนี้เพื่อเพิ่มกรณีที่น่าสนใจมากขึ้น

คุณอาจต้องการที่จะลองบรรณาธิการออนไลน์วุ้นลูกได้รับการออกแบบเพื่อให้ง่ายต่อการสร้างรหัสในJelly ภาษา

คุณสมบัติรวมถึง:

• ชุดคำสั่งที่มีอะตอมและอักขระไวยากรณ์ทั้งหมดซึ่งจัดเรียงตามประเภท
• โปรแกรมแยกวิเคราะห์ออนไลน์รู้จักตัวอักษรและอะตอมขนาด 2 ไบต์ในรหัส
• ตัวแปลวุ้นในเบราว์เซอร์ประยุกต์เพื่อเรียกใช้รหัส Jelly ของคุณบนเว็บเพจใน javascript
• ลิงค์โดยตรงสำหรับการถ่ายโอนรหัสไปยัง TIO หรือเซสชัน Jelly Balls อื่น
• คำแนะนำอัตโนมัติ
• ปรับให้เหมาะสมสำหรับอุปกรณ์มือถือ

ลองดูสิ: https://jellyballs.github.io

• รายงานการติดตามโดยละเอียดแสดงข้อโต้แย้งและผลลัพธ์ของทุกขั้นตอนที่ดำเนินการ

• รายงานรหัสแสดงคำอธิบายของทุกขั้นตอน

• หน้าสูตรอาหารที่มีตัวอย่างเยลลี่

• หน้ารหัสแบบโต้ตอบของ 256 Jelly อักขระ