Jöle bir olduğu zımni bize ait tarafından, golf odaklı programlama dili Dennis . Burada sık sık cevaplar ortaya çıkıyor, Pyth ve CJam gibi diğer golf-y dillerini , kendi kod sayfalarını ve programları net bir şekilde ifade etmek için kullanılan güçlü zincir sistemini kullanarak yeniyor .

Jelly'te golf oynamak için yararlı ipuçları toplayalım. (Her zaman olduğu gibi, cevap başına bir ipucu, lütfen!)

Dize sıkıştırma

Eğer daha iyi duruma / otomatik dize kompresörünün arıyorsanız, denemek bu bir .

Çevrimiçi deneyin!

Sıkıştırılmış bir dize “...», noktaların temel 250 kodlu veri parçası olduğu gibi görünür . Dekompresyon algoritması biraz karmaşıktır: yığın, divmodbu tamsayının çeşitli kısımlarını kırarak ve bunlardan bir dize oluşturarak , “karışık temelli” bir tamsayı olarak yorumlanır .

Jelly dizelerini sıkıştırmak için küçük bir Python 3 arayüzü oluşturdum:

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

Kompresörü aşağıdaki gibi kullanın.

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 Bir dize oluşturucudur:

• .string(s) dizeye ham, yazdırılabilir ASCII karakterleri ekleyecektir.

  (Her karakter yaklaşık 0.827 sıkıştırılmış bayt tutar.)

• .dictionary(w)Jelly'in yerleşik sözlüklerinde bir ip arayacak. İsterseniz dizeye tek bir boşlukla başlayabilirsiniz. Bunun normal dize ekleme davranışından sapması veya bir sözlük kelimesinin büyük harfini çevirmesi gerekiyorsa, buna göre bayraklar ekleyecektir.

  (Kısa kelimeler için yaklaşık 1.997 bayt, uzun kelimeler için 2.433 bayt; bayrak varsa, 0.199 bayt ekleyin.)

Bu Jelly wiki öğretici oldu ne bir parçasıdır .

Zincirler

(Bu Tacit programlama için bir tür takip .)

Jelly bir zinciri nasıl değerlendirir? Bu zincir denilen edilip: As dikkate alınması gereken üç durum vardır, önce açıklandığı niladically , monadik veya dyadically .

1. Niladik zincirler

Bunlar en kolay olanı. Bir giriş parametresiz zincirini değerlendirmek başlar bir nilad ile, gibi α f g h, monadic zincirini değerlendirmek f g ho nilad de α. (Uyarılar. Bütün zincirli boş ise, yerine 0 döndürülürse α değildir kullanımının yerini, bir nilad α=0yerine).

Örneğin, 4½sadece bir ½değerlendirilir 4olan 2.

2. Monadic zincirleri

Monako zincirleri, göz önünde bulundurulacak bir bağ kalmayıncaya kadar soldan sağa doğru parçalanır. Ayrıca, ωburada bazı tartışmalar geçirdik . Cevaplanması gereken iki soru var:

Bu soldan sağa değerlendirmenin başlangıç ​​değeri nedir?

• Eğer zincirimiz bir niladla başlıyorsa αve onu sıfır veya daha fazla monad (benzeri ½), dyad-nilad çiftleri (gibi +2) ve nilad-dyad çiftleri (gibi 4*) izlerse : değerlendirerek başlarız αve sonra zincirin geri kalanını dikkate alırız .

• Aksi takdirde, bu zincire iletilen argümandan başlıyoruz ωve tüm zinciri ele alıyoruz .

Zincirden nasıl ineceğiz?

VŞimdiki değeri çağıralım - başlangıçta, yukarıda açıklanan değer, ancak zincirden geçtikçe güncelleniyor - ve

• basamak kullanan nilads,
• küçük harfler kullanarak monadlar,
• Operatör sembollerini kullanarak çiftlerinde +, ×, ÷.

Ardından, aşağıdaki desenler yukarıdan aşağıya doğru eşleştirilir:

                                 ┌───────────┬─────────┐
                                 │ 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.)

Bunu zincirde deneyelim +²×.

• +bir nilad değil, o yüzden başlıyoruz V = ω.
• Ardından, +²ikinci kalıbı eşleştirerek keseriz ve alırız V = ω+ω².
• Ardından, ×beşinci kalıbı eşleştirerek kopardık ve aldık V = (ω+ω²)×ω.
• Zincir şimdi boş, (ω+ω²)×ωsonuçta bizim de sonuçumuz.

3. İkili zincirler

Bunlar temelde monadik zincirlere benziyor, ancak bu sefer, iki λsol var (sol) ve ρ(sağ).

Başlangıç ​​değeri nedir?

• Üç çiftlerinde ile zincir başlar isterseniz + × %, biz başlayacak λ+ρve zincir düşünün × % ...sonraki.

• Aksi takdirde, λtüm zinciri başlıyor ve tüm zinciri göz önüne alıyoruz .

Zincirden nasıl ineceğiz?

Bu sefer, kalıplar

                                 ┌───────────┬─────────┐
                                 │ 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.)

Bunu zincirde deneyelim +×÷½.

• Üç çiftlerinde ile zincir başlar, bu yüzden başlayacak V = λ+ρve atmak +.
• Ardından, ×÷ikinci kalıbı eşleştirerek keseriz ve alırız V = (λ+ρ)×(λ÷ρ).
• Sonra, ½altıncı kalıbı eşleştirerek keseriz ve alırız V = sqrt((λ+ρ)×(λ÷ρ)).
• Zincir şimdi boş, bu yüzden bitti.

Özel kasalı sayısal değerler

Jelly'in sayısal çözümleyici için bazı özel durumlar:

• - için değerlendirir -1
• . için değerlendirir 0.5
• ȷolarak değerlendirilen 1000( ȷbilimsel gösterim içindir, örneğin 2ȷ6ise 2000000)
• ıdeğerlendirir 1j( ıkarmaşık sayılar içindir, örneğin 2ı3; 2+3j)

Aynı zamanda , bunun gibi bir 4ışeyin aslında olduğunu belirtmek de önemlidir .4+1j4

Bunları karıştırabilir ve eşleştirebilirsiniz, örneğin:

• -.olduğunu -0.5ve -ȷbir-1000
• -ıolduğu -1+1j, ı-olduğu -1jve -ı-olduğu-1-1j
• .ȷ dır-dir 500.0
• .ıolduğu 0.5+1j, ı.olduğu 0.5jve .ı.olduğu0.5+0.5j
• ȷıolduğu 1000+1j, ıȷolduğu 1000jve ȷıȷolduğu1000+1000j

Not ȷ-olduğunu 0.1, ancak herhangi bir aşırı bayt tasarruf gelmiyor mu .1. Daha sonra, 10 ( ⁵) için yerleşik değişkeni kullanılarak karşılık gelen bayt sayısında zaten yapılabilecek , ancak yerleşik durumun kullanılamaması veya kullanım gereksiniminden tasarruf etmek için nadiren yararlı olabilir ¤:

• ȷ.olduğu sqrt(10) ~ 3.162277, .ȷ.olduğu sqrt(10)/2 ~ 1.5811ve ȷ-.olduğu1/sqrt(10) ~ 0.31162

Optimize edilmiş dizel kompresör

Çevrimiçi deneyin!

Lynn'in gönderdiği bilgiler, sıkıştırılmış dizgilerin tam olarak ne olduğunu ve bu sıkıştırılmış dizeleri üretecek bir kompresöre sahip olduğunu ayrıntılarıyla anlatıyor. Jelly bir program ile etrafında müdahalesi Ancak, ben birleştirmek zorunda kalmak yorucu buldum .dictionaryve .stringen kısa dize elde etmek için, boşluk doğru yerleşimlerle birlikte ve benzeri ve benzeri.

Bu nedenle, Lynn'in komut dosyasına kullanıcı girdisini alacak bir uzantı oluşturmaya ve kullanıcının herhangi bir iş yapması gerekmeden sıkıştırılmasının en kısa yolunu bulmaya karar verdim. Betik oldukça uzun ve kodun kendisinden ziyade bir TIO bağlantısına ekledim.

Programın çalışma şekli, 3 farklı yöntem kullanarak sıkıştırmak ve hangisinin en kısa olduğunu belirlemek.

1. Metot 1, diğerlerine kıyasla en uzun sonucu üretme eğiliminde olan bir zamanda girişin her bir baytını kodlar. Girdi çok kısa olsa bile, hala oldukça uzun alternatifler oluşturmayı başarıyor. Örneğin, testsıkıştırılabilecek en kısa yol “¡ḌY»bu yöntemle geri döner “¡⁷ƑKʂ»(2 bayt daha uzun). Genel bir kural olarak, bu yalnızca dize 4 karakterden kısa olduğunda çalışır

2. İkinci yöntem diziyi sözcüklere ve noktalama işaretlerine böler; ikisi kompresöre farklı şekillerde eklenir. Sözlüğün bir parçası olan kelimeler, .dictionarybasitçe kod noktalarıyla eklendiklerinden daha fazla sıkıştıran Lynn kodu yöntemiyle eklenir. Ancak noktalama işaretleri, ne yazık ki sözlüğün bir parçası olmadığı için kod noktasıyla eklenmelidir.

   Noktalama işaretleri, 3 numaralı yöntemin devreye girdiği boşlukları içerir, ancak önce ve 2. yöntemin değerlendirilmesi: dizeyi sıkıştıran yöntemlerden birini ve ikisini karşılaştıralım Hello, World!(kelimeler, noktalama işaretleri ve boşluklar, mükemmeldir). Karakterleri karakterlere göre sıkıştırmak, sonuç olarak, “ŒCdẉa÷¹ṂȤƓ(Ẋ)»Merhaba, Dünya !: çıktısının daha kolay bir yolundan daha uzun olan (15 byte uzunluğunda) bir son dizgeyle sonuçlanır “Hello, World!. Şimdi ikinci yönteme bir göz atalım. Bu “Ọƥ⁷Ƭė3⁶»9 bayt ağırlığında sıkıştırılmış dizgiyi üretir , eskisine göre daha büyük bir gelişme. Ancak, en kısa Merhaba, Dünya! Jelly programında 8 bayttır , bu yüzden bir şey geliştirilebilir

3. İşte yöntem 3 geliyor, daha da kısalıyor. Beklendiği gibi, Merhaba, Dünya için çıktı elbette ki “3ḅaė;œ»mümkün olan en kısa program. Peki, yöntem 3 ne işe yarar, bu yöntem 2 ne yapmaz? Metot 3, yalnız boşlukları, Jelly dekompresörünün bayrağının bulunduğu önde gelen boşluklarla birleştirir. Hem kompresör hem de dekompresör kodunda if flag_space: word = ' ' + word, ön boşlukların a) desteklendiğini ve b) bayt tasarrufu olduğunu gösteren kodları görebilirsiniz . Bu nedenle, ikinci yöntemden dize ayırıcı, boşlukları kendi başlarına dizgede doğrudan dizgilerle birleştirerek, öncü dizgiler yaratır. Bu , sıkıştırıldığında yalnızca 6 bayt olan (sınırlayıcılar dahil edildiğinde 8) olduğu gibi Hello, World!ayrıştırılır ["Hello", ",", " World", "!"]. Bu, eklediğim "eklenti" hariç, hemen hemen her zaman en kısa sıkıştırma yöntemidir,

Bu programın büyük kısmıdır, ancak verileri daha da sıkıştıracak birkaç seçenek daha vardır.

• Program, her sıkıştırılmış versiyonun doğru olup olmadığını, Jelly'in kullandığı Dennis'in sss dekompresörünü kullanarak kontrol eder (doğrudan kaynağa gidin).
• Tüm sıkıştırılmış dizeleri --debug, sadece en kısa sıkıştırılmış dizgiyi göstermek yerine, 3 'ü "Bu en kısa" kopya ile birlikte gösteren ilk komut satırı argümanını yaparak görebilirsiniz.
• Program "olmayan kelimeler" i yönetiyor

Sigara kelimeler

Bu mesajı gördükten sonra Lynn'in kompresörü üzerinde çalışmaya başladım, çatladım ve sıkıştırmanın en kısa yolunu bulamadığım için hayal kırıklığına uğradım (kayıt için 29 ya da 32 bayt). Ancak geliştirmelerimi test ederken, bu kelimelerin knownsJelly'in sözlüğünde olmadığını gördüm . Bu nedenle, bu "sözcüksiz" kelimelerin mümkün olan en kısa Jelly koduyla sıkıştırılması için bir yol bulmaya başladım.

trimDizeyi, dizenin parçalarından en az birinin sözcük olduğu nokta olarak bölen bir işlev ( ) yarattım . Örneğin knownsbölünmüş ["known", "s"]olacak ve programın ilk kelimeyi bir sözlük add ( .dictionary) aracılığıyla ve kelimenin ikinci bölümünü bir .stringarama yoluyla eklemesini sağlayacaktır . Ancak bu yine de iki ayrı durum bırakıyor: İçlerinde hiçbir kelime bulunmayan dizgiler (gibi ajdl) ve sonunda işlevden abctestayrılmayan sözcükler içeren sözcükler trim.

İçinde sözcüğü olmayan bir dizgede sözcük bulmanın bir yolu olmadığından, bunları ele almanın en basit ve en kısa yolu, bir .stringçağrı yoluyla karakter karakterlerine eklemektir . Böylece ajdleklenirdi .string('ajdl'). Tanınan sözcüklerle biten sözcük olmayanlar, esasen düzelticiyi ancak tersten uygular .dictionaryve .stringileri doğru düzelticiye uygulanır ve diğer yöne doğru gider.

Görünüşe göre, dizgeyi, başlangıçtan veya sondan kırpmak, elbette, abctest this stringbir hata ayıklama çıktısı üreten bir girdi tarafından gösterildiği gibi, her bir karakteri kompresöre eklemekten daha kısadır .

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⁸ụƘ$,»
=====

Optimal çıkış (düzelticiyi kullanan) ve olmayan (bir jöle için) 4 byte olmayan arasındaki fark. Son olarak, dizginin kendisinin şu anda hesaba katılmış olan sıkıştırılmış versiyondan daha kısa olduğu durumlar vardır.

Tabii ki, bunun için çok fazla kredi orijinal kompresörü oluşturmak için Lynn'e gidiyor

³⁴⁵⁶⁷⁸⁹Genellikle kullanılan bazı değerlerin golf oynamak için üst üste üç ila dokuz ( ) kullanabilirsiniz, ancak bu komut satırı argümanlarının miktarına ve bağlantı olması durumunda bağlantıların argümanlarına bağlıdır.

• ³ 100 döndürür ve yalnızca girdi yoksa çalışır.
• ⁴ 16 döndürür ve yalnızca en fazla bir girdi varsa çalışır.
• ⁵ 10 döndürür ve yalnızca en fazla iki giriş varsa çalışır.
• ⁶ en fazla üç girdi varsa boşluk döndürür.
• ⁷ En fazla dört giriş varsa, yeni bir satır döndürür.

Ancak, beş giriş varsa, şansınız kalmaz.

Son zamanlarda, dilin yeni bir sürümü ³100'e düşürdü ve değerleri ya da argümanlarını döndüren bazı yeni atomlar ortaya çıkardı .

• ⁸ kendilerine sol bir argüman olan bağlantılar dışında her yerde boş bir liste döndürür.
• ⁹ kendilerine iletilen doğru argüman olan bağlantılar dışında her yere 256 döndürür.

Bir bağlantınız varsa ve her iki taraftan da argümanlarınız varsa, buna rağmen, şansınız tükenir.

Kötüye kullanılan string böcekler

Krediler , bundan önce yararlanmak için Adnan'a git, ipleri esnekleştirmek için bir program yaz .

Jelly'in bir gün karakter aritmetiği elde etmesi gerekiyor, ancak bu gerçekleşene kadar Python'un çoğu aritmetik operatörü aşırı yüklediğinden ve Jelly'in tip kontrolü yapmadığından faydalanabiliriz.

Örneğin

“abcd”Ḥ

şu anda yararlı bir şey Ḥyapmamalıydı , ancak (mutsuz) olarak uygulandığı için

lambda z: z * 2

ve aritmetik atomlar 0 derinliğinde vektörleşir (yani, sayı veya karakter üzerinde çalışırlar), yukarıdaki Jelly kodu

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

Bunun gerçek Python karakter dizileri üretmesine dikkat edin (Jelly'in sahip olmaması gereken bir tür), bu nedenle bu her durumda kullanılamaz.

Aynı şekilde, +/aynı uyarılarla dizeleri birleştirmek için de yararlı olabilir.

Optimal dize kompresörü

Son zamanlarda sorulan Erik Outgolfer eklemek için optimize dize kompresör için JHT referanslar sayfasında , ancak söz konusu olduğu

üzgünüm, ama bu kompresör tam olarak uygulanması görünmüyor
diyor “ugtestslug”en kısa mümkündür ugtestslugederken, “#ṀȮụḄPƇ»aynı zamanda iş yapar

Bu yüzden en uygun dize kompresörünü uygulamaya karar verdim.

Basit yaklaşım, ancak mümkün olan en küçük değeri bulma garantisi (ve dolayısıyla bayt sayısı)

Girdi almak stdin, çıktı almak stdout. Orijinal kompresör gibi, ¶veya (değişmez yeni satır karakteri) yeni satır olarak girilebilir.

Çok fazla noktalama işareti (örneğin, giriş ¶-----¶) ile çalıştırmaya çalışmak , sıkıştırılmamış dizgenin çıktısını alacaktır.

Tabii ki, bunun için çok fazla kredi orijinal kompresörü yarattığı için Lynn'e gidiyor .

Bu Jelly wiki öğretici oldu ne bir parçasıdır .

Tacit programlama

Jelly tam bir programlama dilidir. Bu, mevcut bağlantıları bir zincir halinde birleştirerek , açıkça tartışılan argümanlardan açıkça bahsetmeden bağlantıları (işlevleri) tanımladığınız anlamına gelir . Argümanların bu kompozisyonda "nasıl aktığı" hangi yollarla bağların düzenlendiği kalıpla tanımlanır. Bunun bir örneği yakında verilecek, ancak önce bazı kavramları tanıtmamız gerekecek.

Arity bir bağlantı çok önemli bir kavramdır. Bütün atomlar - yerleşikler, benzerler +ve ½- sabit elementlere sahiptirler. Bağlantılar, varlıklarına bağlı olarak üç kategoriye ayrılır:

• Niladlar tartışmazlar (arity 0); Bazı G / Ç ve durum bilgisi komutları dışında, çoğunlukla sabit değerleri temsil eder. Örneğin, hazır bilgi 3bir nilad.

• Monad'lar bir argüman alır (arit 1) (Burada işlevsel programlama monadlarına bağlantı yoktur .) Örneğin, ½(karekök) bir monaddır.

• Dyads iki argüman alır (arity 2): sol ve sağ argüman. Örneğin +, bir dyad.

(Biz bir bağlantı olduğunu söylemek, sıfatlar kullanarak giriş parametresiz , monadic veya diyadik .)

Peki, bir program yazarken tanımladığımız bağlantıların ariteliği nedir? Varsayılan olarak, bunlar değişkendir - yani, kaç tane argüman kullanılacağını belirtmek arayan kişiye bağlıdır ve ana link durumunda , programın kaç tane argümanın geçtiğine bağlıdır.

Örnek olarak, (toplama) ve (karekök) +½zinciridir . Bu zincirin elementlerinin ilgili ariteleri 2 ve 1 olduğundan, buna 2,1 zinciri diyoruz . Tercümanın, zincirlerini, temellerine göre ayırma konusunda belirli kuralları vardır: bu kurallar, girdi verildiğinde , bu yeni bağlantının hesaplanmasını zorunlu kılar . ( “... artı karekökü” olarak okuyabilirsiniz . )+½nn + sqrt(n)+½

Jöle programlama, o zaman, esasen de bu kuralları öğrenme ve iş halletmek zeki zincirlerini oluşturan sanatıdır zımnen .

Bu Jelly wiki öğretici oldu ne bir parçasıdır .

Program yapısı

Jelly programındaki her satır bir bağlantı tanımıdır . Bağlantılar temelde fonksiyondur. Alt satırda “ main” gösterilir: komut satırında iletilen argümanlar kullanılarak değerlendirilen bağlantıdır.

Sonuncusu dışındaki bütün linkler, fonksiyon tanımlarıdır: Onlara aktör kullanarak başvurabilirsiniz . Örneğin ç, “ikili bir operatör olarak (dyad) bunun üstündeki bağlantı” dır . Argümanlarının toplamının karesini hesaplayan bu örnek programı göz önünde bulundurun :

+
ç²

Bu bir tür sahte kod gibidir:

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

Bu Jelly wiki öğretici oldu ne bir parçasıdır .

Çok zincirli bağlantılar

Başka bağlantılar zinciri oluşturarak bir bağlantı tanımladığınızı yazdığımı hatırlıyor musunuz? Ben bütün gerçeği söylemiyordum: gerçekte, iki katmanlı bir süreç. Bir bağlantı bir zincir zinciridir ve varsayılan olarak dış zincir sadece birim uzunluğa sahiptir.

Bu programı düşünün:

C+H

Bu tamamlayıcı artı yarı . Bir giriş değeri alır nve hesaplar (1-n)+(n/2). Çok heyecan verici değil, biliyorum. Ancak yapı gerçekten böyle:

Yazdığımız link, aslında tek bir zincir içeren bir zincir.

(1-n)+(1-n)(n/2)Bunun yerine hesaplamak istediğimizi varsayalım . Üçlü zincir +×işe yarar : zincirleme kurallarına göre hesaplar λ+(λ×ρ), ki bu da ihtiyacımız olana çok benziyor. Ancak, sadece değiştirilmesi +yoluyla +×yapmayacağım Programımızda: C+×HBir 1,2,2,1-zinciridir - tamamlayıcısı ardından yarı yarıya çarpın, sonra (argüman) ekleyin - hesaplama ((1-n)+n)×(n/2).

Biz tedavi için Jelly istediğiniz +×bir birim olarak ve alt zincirlerinin bir 1,2,1-zinciri yapmak C, +×ve H. Çok zincirli bağlantılar tam da bunu yapmamıza izin veriyor! Onları oluşturmak için, zincir ayırıcıları kullanıyoruz øµð : yukarıdaki resimde sırasıyla 0, 1 ve 2 ariteli yeni bir mavi dikdörtgen yerleştireceklerdi. Bizim durumumuzda, zincirleri aşağıdaki şekilde yazarak istediğimiz şekilde gruplandırabiliriz Cð+×µH:

Bunları daha da iç içe geçirmenin bir yolu yok. Bunun yerine birden çok bağlantı tanımlamanız gerekir.

TMTOWTDI ise, zincirinize uygun olanı seçin.

Düzgün olmayan bir dilin avantajlarından biri, değişken referanslar kullanmadan genellikle kaçabilmenizdir . Ancak, bu yalnızca zincirinizdeki bağlantılar doğru uçlara sahipse işe yarar.

Örneğin, bir 2D dizisindeki tüm dizilerin toplamını almanın en basit yolu

S€

bu, toplam atomu dizinin tüm elemanları üzerinde eşleştirir.

Şimdi, atomdan oluşan monadik bir zincire sahip olduğunuzu söyleyin.

*

her hangi haritalar x Bir 2D dizinin X ^X . Örneğin, A = [[[1, 2], [3, 1], [2, 3]] için zinciri çağırmak [[1, 4], [27, 1], [4, 27]] sonucunu verir. .

Şimdi, her bir çiftin toplamını almak istiyoruz. Ne yazık ki,

*S€

çünkü artık *bir kanca gibi davranmıyor ( A'nın kendisini doğru argüman olarak kullanması ), ama bir çatal gibi , ilk önce A'yaS€ uygulanan anlam ve sonuç da doğru argüman .*

Bunu düzeltmek yeterince kolaydır:

*¹S€
*⁸S€

Her iki üretmek arzu edilen sonuç: *¹a, çatal¹ kimlik fonksiyonudur ve *⁸bir olduğu üstünde burada, ⁸zincir sol bağımsız değişkeni (başvurusudur bir ).

Ancak, bir bayt kurtarmanın bir yolu var! Tepesinde ḅ1(tamsayı tekli dönüştürmek) aynı zamanda, her bir dizi toplamını hesaplar bir ^A , ancak farklı olarak S€, ḅa, diyadik bağlantısı.

Zincir

*ḅ1

döner [5, 28, 31] (istenildiği gibi); çünkü ḅdidik, *çatal yerine kanca

Tamsayı sıkıştırma

Dize sıkıştırma, İngilizce metin üretilirken kullanışlıdır, ancak diğer tür verileri sıkıştırmanız gerekirse, bu oldukça etkisizdir. Dolayısıyla, büyük bir sabit sabiti programınızda saklamak istediğiniz çoğu zaman, onu bir tamsayı olarak saklamak en iyisidir.

Artık Jelly, sabit olarak kendi kod sayfasına sahip olduğuna göre, tamsayılar için sıkıştırma algoritması en basit şekilde Jelly'de ifade edilir:

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

Çevrimiçi deneyin!

(Yukarıdaki program ayrıca, tamsayının sıkıştırdığı değeri göstermek için bir kontrol içerir.)

Yalnızca bir tamsayı tamsayı olarak kullanmanın yanı sıra, üzerinde temel dönüşüm yaparak bir karakter dizesi oluşturmak için dizge oluşturmak için de kullanabilirsiniz. ṃAtomu bu işlem otomatik ve tek bir bayt (alfabe dışında içine sıkıştırılmış olan) dekompresyon tüm süreci tarif çünkü oldukça yararlıdır.

Kullanışlı tamsayılı matrisler oluşturmak için dış ürünleri kullanın

İşte biraz daha güzel HTML tablosu biçimlendirme ile bu yazının yarattığı bir özeti.

Dıştaki ürün hızlı þdyadlara eklenebilir ve dyadın sol ve sağ argümanlarındaki her bir eleman çifti üzerinde etki etmesine neden olur. İçin stenodir €Ð€. Örneğin, kodumuz olsaydı, [1,2]+€Ð€[0,10]onu kısaltabilirdik [1,2]+þ[0,10] ve her ikisi de verecekti [[1,2],[11,12]]. Dış ürün dyad'ı þ(örneğin +þ) uygulanmış bir dyad'a atıfta bulunacağım .

Bir tamsayı bir dış ürün dyadının argümanlarından biriyse, Jelly önce bu sayının aralığını alır ve sonucu argüman olarak kullanır. Bunu bilerek, yukarıdaki örnek daha da kısaltılabilir 2+þ[0,10]. Bu, bir dış ürün dyadının hem sol hem de sağ argümanları için geçerlidir.

Bir tamsayı üzerinde monadik olarak hareket ederken bazı dış ürün boşlukları, golf oynamada (özellikle de ASCII sanat zorlukları) yararlı olabilecek ancak aksi takdirde yapılanmaları çok sayıda bayt alabilecek bazı tamsayı matrisleri verir. Örneğin =þbir tamsayıya uygulandığında nbir n×nkimlik matrisi verir . Çevrimiçi deneyin =þ!

Aşağıda, bir dış tablolara dönüştüğünde elde ettikleri bir matris türü ve bir tamsayı üzerinde monadik olarak hareket eden bir tablo tablosu verilmiştir. Aynı sırada listelenen iplikler aynı matrisleri verir. Ben gibi tabloya dahil değil çiftlerinde vardır &, |, %, w, ẇve ḍayrıca matrisleri tamsayı üretmek ama onların desenler basit olarak değildir ve muhtemelen daha az durumlarda yararlı olacağını söyledi. Çevrimiçi deneyin wþ!

+ ------------------------------------------------- ---- +
| Dyad | Sonuç matrisi | Örnek |
+ ------------------------------------------------- ---- +
| = ⁼ | | 1 0 0 |
| ċ | Kimlik matrisi | 0 1 0 |
| | | 0 0 1 |
+ ------------------------------------------------- ---- +
| | Köşegen üzerindeki elemanlar 1, | 0 1 1 |
| <| diğer tüm elemanlar 0 | 0 0 1 |
| | | 0 0 0 |
+ ------------------------------------------------- ---- +
| | Çapraz altında elemanları 1, | 0 0 0 |
| > | diğer tüm elemanlar 0 | 1 0 0 |
| | | 1 1 0 |
+ ------------------------------------------------- ---- +
| | Çapraz elemanlar 0, | 0 1 1 |
| n ⁻ | çapraz elemanlar 1'dir | 1 0 1 |
| | | 1 1 0 |
+ ------------------------------------------------- ---- +
| a ȧ | | 1 1 1 |
| ṛ ị | Her bir öğenin satır dizini | 2 2 2 |
| | | 3 3 3 |
+ ------------------------------------------------- ---- +
| o ḷ | | 1 2 3 |
| ȯ | Her bir öğenin sütun dizini | 1 2 3 |
| | | 1 2 3 |
+ ------------------------------------------------- ---- +
| | Ana diyagonal 0, üst | 0 1 2 |
| _ | köşegenler 1, 2 ..., daha düşük | -1 0 1 |
| | köşegenler -1, -2 ... | -2 -1 0 |
+ ------------------------------------------------- ---- +
| | Ana diyagonal 0, daha düşük | 0 -1 -2 |
| _ @ | köşegenler 1, 2 ..., üst | 1 0 -1 |
| | köşegenler -1, -2 ... | 2 1 0 |
+ ------------------------------------------------- ---- +
| | Ana diyagonal 0, üst | 0 1 2 |
| ạ | ve alt köşegenler 1, | 1 0 1 |
| | 2, 3 ... | 2 1 0 |
+ ------------------------------------------------- ---- +
| | | 2 3 4 |
| + | Satır dizini artı sütun dizini | 3 4 5 |
| | | 4 5 6 |
+ ------------------------------------------------- ---- +
| | Minimum satır | 1 1 1 |
| «| ve sütun indeksleri | 1 2 2 |
| | | 1 2 3 |
+ ------------------------------------------------- ---- +
| | Maksimum satır sayısı | 1 2 3 |
| »| ve sütun indeksleri | 2 2 3 |
| | | 3 3 3 |
+ ------------------------------------------------- ---- +

Komutları ve hazır bilgileri listele

Eğer çoğunu kullanmak çalışırsanız olmayan Vektörizasyonu liste komutları bir üzerinde edebi n veya değişmezleri listesinde z , liste komutu ilk çeşit listesine dönüştürmek ve daha sonra bu listedeki komutu yürütecektir.

Bu komutlar iterable, jelly.py içindeki fonksiyona yapılan çağrıları kullanır .

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]

İşte bu liste komutlarının ne yapacağına dair bazı eksik listeler.

Bir liste halinde sarar

En basit dönüş iterable, argümanı bir listeye sarmak ve işlev tarafından işlenecek olana dönmek için döndürülür. Bu, argüman zaten bir liste değilse, bir dize ise ve iterableargümanları başka yöntemler için çağrılmazsa olur.

-------------------------------------------------------------------------------
| 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 tabanına dönüştür

Buradaki işlevler iterablebir sayıyı sayıların listesine dönüştürür Dve ardından bu sayıların üzerinde çalışır.

-------------------------------------------------------------------------
| 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]              |            |
-------------------------------------------------------------------------

Menzilli listeye dönüştür

Buradaki işlevler bir sayıyı aralığa dönüştürür R = [1 ... n]ve ardından bu aralıkta çalıştırılır.

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

Tam olarak iki giriş olduğunda standart girdiden okumak bazen yararlı olabilir

Jelly, komut satırı argümanlarından girdi almak için optimize edilmiştir. Bununla birlikte, metinler yerine monadlar yazmak için de optimize edilmiştir; Gündeliklerle birlikte, her yerleşik için o kadar çok anlam vardır ki, karakterleri birbirinden ayırmak için sık sık harcamanız gerekir, oysa monadlarda genellikle aynı şeyi söylemenin birçok yolu vardır.

Eğer sadece bir kez iki girdilerden biri kullanın ve eğer Gibi, sorun kolayca dolaylı gelen okunamaz şekildedir ⁴(yani sizin yapmak ya ihtiyacını ⁴açık, ya da başka bir karakter geçirmek }, @ya da benzeri) , Ɠkomut satırına yerleştirmek yerine standart girdiden okumayı düşünün ; bu, tam olarak Ɠdiğer her türlü girişin diğer girişinizden alınmasını sağlarken , girişinizi istediğiniz yere yerleştirerek tam olarak yerleştirmenizi sağlar . Bu bir bayt maliyeti ve bir bayt tasarrufu sağlar ve soruna bağlı olarak, size kodu yeniden düzenlemek için daha fazla kapsam vererek, ikinci bir bayt tasarruf sağlayabilir.

Kullanarak bir argümanın özelliklerini kontrol etmenin birkaç açık olmayan yolu vardır Ƒ. Aşağıda birkaç tane var. Ben bu hızlı ait pek çok kullanım dışında kalan (Ör AƑ, ŒuƑ, 3Ƒ) onların davranışlarını ulaşmanın en basit yöntemler çünkü zaten.

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¤$)

Daha ilginç vakalar eklemek için bunu düzenlemek için çekinmeyin.

Jelly Dilinde kolayca kod oluşturmak için tasarlanmış bir çevrimiçi editör Jelly Balls denemek isteyebilirsiniz .

Özellikler şunlardır:

• Türe göre düzenlenmiş tüm atomları ve sözdizimi karakterlerini içeren komut paleti
• Koddaki değişmezleri ve 2 bayt atomları tanıyan çevrimiçi çözümleyici
• Jelly kodunuzu javascript'te web sayfasında çalıştırmak için basitleştirilmiş tarayıcı içi Jelly yorumlayıcısı
• Kodu TIO veya başka bir Jelly Balls oturumuna aktarmak için doğrudan bağlantılar
• Otomatik ipuçları
• Mobil cihazlar için optimize edildi

Bir deneyin: https://jellyballs.github.io

• Yürütülen her adımın argümanlarını ve sonuçlarını gösteren detaylı izleme raporu

• Her adımın açıklamasını gösteren kod raporu

• Jelly örnekleri ile Tarifler sayfası

• 256 Jelly karakterinin etkileşimli kod sayfası