Funciton , rekabetçi değil, 29199 bayt
Bu zorluğun tadını çıkardım, çünkü bazı çok yararlı kütüphane işlevlerinin acısızlığını vurguladı. Bu işlevlerin tümünü buraya (ve bayt sayısına) dahil edeceğim çünkü bu sorun gönderildikten sonra bunları yazdım.
Tek bir dosyada tam kaynak
açıklama
Her zaman olduğu gibi, javascript:(function(){$('pre,code').css({lineHeight:5/4});})()tarayıcı konsolunuzda yürüterek daha iyi bir görüntü elde edin.
① ɹ ⇄Geri
Bildiğiniz ya da bilmediğiniz gibi, Funciton, listeler için işlevlerle dolu, tek bir humongo tamsayıda kodlanmış değerler ve tembel değerlendirilmiş diziler için ayrı bir kütüphane ile birlikte gelir. de, kullanım lambda ifadeleri (anonim fonksiyonlar), tembel olmak için. Elbette dize işleme işlevleri için bir kütüphane de vardır.
Bu meydan okuma için, bir dizeyi tersine çevirmek için bir fonksiyona ve tembel olarak değerlendirilmiş bir diziyi tersine çevirmek için bir işleve ihtiyacım vardı. Şaşırtıcı bir şekilde, listeler için sadece bir tane vardı - tam olarak ihtiyacım yoktu. Tembel diziler ( ɹ) ve dizeler ( ⇄) için ters işlevler şunlardır :
╓───╖ ╔════╗ ┌────╖ ╓───╖
║ ɹ ║ ║ 21 ╟─┤ >> ╟──┐ ║ ⇄ ║
╙─┬─╜ ╚════╝ ╘═╤══╝ │ ╙─┬─╜ ┌──┐
┌─────┴─────┐ ┌─┴─╖ ├───────┴────────┤ │
┌─┴─╖ ┌───╖ │ │ ⇄ ║ │ ╔════╗ ┌───╖ │ │
┌─┤ ╟─┤ ɹ ╟─┐ │ ╘═╤═╝ │ ║ −1 ╟─┤ ≠ ╟─┴┐ │
│ └─┬─╜ ╘═══╝ │ │ ┌─┴─╖ ┌─┴─╖ ╚════╝ ╘═╤═╝ │ │
│ │ ┌───╖ │ │ │ ‼ ╟─┤ ? ╟──────────┤ │ │
│ └───┤ ʬ ╟─┘ │ ╘═╤═╝ ╘═╤═╝ ╔═══╗ ┌─┴─╖ │ │
│ ╘═╤═╝ │ ┌─┴─╖ ╔═══╗ ║ 0 ╟─┤ ≠ ╟──┘ │
│ ╔═══╗ ┌─┴─╖ │ ┌─┤ ʃ ╟─╢ 1 ║ ╚═╤═╝ ╘═══╝ │
└─╢ 0 ╟─┤ ? ╟───┘ │ ╘═╤═╝ ╚═══╝ │ │
╚═══╝ ╘═╤═╝ │ └────────────┘ │
│ └─────────────────────────────┘
Birinin kullandığı ʬtembel sekanslar, “tembel sekansın sonuna bir eleman eklemek”. Kullanılacak dize ʃ(alt dize) ve‼ (string concatenate) kullanır.
② ṖAsal
Her ne kadar n'yi tüm faktörlere sırayla bölmeye çalışarak asal çarpanlara ayırma yapabilseydim, asal sayılar üreten bir kütüphane işlevi istediğime karar verdim. Aşağıdaki fonksiyon n tamsayısını alır ve n'ye kadar tüm asal sayıları üretmek için Eratosthenes Elekini uygular . Bunu tembel bir dizi olarak yapar, bu yüzden gerçekten değerlendirdiğiniz kadar çok primer üretecektir.
╓───╖
║ Ṗ ║
╔═══╗ ╙─┬─╜
║ 0 ║ ┌─┴─╖
╚═╤═╝ │ ♭ ║
╔═══╗ ┌──┴─╖ ╘═╤═╝
║ 2 ╟─┤ Ṗp ╟───┘
╚═══╝ ╘══╤═╝
┌──────────────┐ │
│ ├─────────────────────────────────────────┐
│ ┌─┴─╖ │
│ ┌─┤ · ╟────────────────────────────┐ ╓┬───╖ │
│ │ ╘═╤═╝ ├───╫┘Ṗp ╟─┤
│ │ │ ╔═══╗ ┌────╖ ┌─┴─╖ ╙─┬──╜ │
│ │ │ ║ 1 ╟─┤ >> ╟─────┤ · ╟───┴─┐ │
│ │ │ ┌───╖ ╚═══╝ ╘══╤═╝ ╘═╤═╝ │ │
│ │ ┌─┴──┤ ♯ ╟─────┐ ┌──┴─╖ ┌───╖ │ │ │
│ │ │ ╘═══╝ ┌─┐ │ ┌──┤ Ṗp ╟─┤ ♭ ╟─┴─┐ │ │
│ │ │ ├─┘ └─┤ ╘══╤═╝ ╘═══╝ ┌─┘ │ │
│ │ │ ╔═╧═╕ ┌─┴─╖ ┌─┴─╖ ┌─┴─╖ │ │
│ │ └────────╢ ├─┤ · ╟─┤ ? ╟─────┤ · ╟─┐ │ │
│ │ ┌───╖ ╚═╤═╛ ╘═╤═╝ ╘═╤═╝ ╘═╤═╝ │ │ │
│ ┌─┴─┤ ♭ ╟─┐ ┌──┴─╖ │ ┌─┴─╖ │ │ │ │
│ │ ╘═══╝ └─┤ Ṗp ╟───┘ ┌─┤ ? ╟───────┘ │ │ │
│ ┌───╖ │ ╔════╗ ╘══╤═╝ │ ╘═╤═╝ │ │ │
┌─┴─┤ ÷ ╟──┘ ║ −1 ║ ┌──┴─╖ ╔═╧═╗ │ ┌┴┐ │ │
│ ╘═╤═╝ ╚══╤═╝ ┌─┤ >> ╟─┐ ║ 0 ║ └┬┘ │ │
│ ┌─┴─╖ ┌────╖ │ │ ╘════╝ │ ╚═══╝ │ │ │
│ │ × ╟─┤ << ╟─┘ ┌─┴─┐ ╔═╧═╗ │ │ │
│ ╘═╤═╝ ╘══╤═╝ ┌┴┐ ┌┴┐ ║ 1 ╟───────────────────┴─┐ │ │
└─────┘ ┌┴┐ └┬┘ └┬┘ ╚═══╝ ├─┘ │
└┬┘ │ └──────────────────────────────┘ │
┌─┴─╖ ┌─┴──╖ │
│ ÷ ╟─┤ << ╟─┐ │
╘═╤═╝ ╘════╝ ├──────────────────────────────────┘
┌┴┐ │
└┬┘ │
╔════╗ ┌─┴──╖ │
║ −1 ╟─┤ << ╟───────┘
╚════╝ ╘════╝
Yardımcı işlevi, Ṗpşunları alır:
0'a ulaşıncaya kadar azalmaya devam eden bir koşu sayacı.
Asal olmadığı bilinen her sayı için biraz ayarlanmış olan elek. Başlangıçta, en az anlamlı bit 2 sayısını temsil eder, ancak bu hakkı her yinelemede kaydırırız.
Bir dizi n sayı elek olan en düşük bit ile temsil edilir belirtir; bu her yinelemeyle birlikte artar.
Her bir yinelemede, elek en düşük biti 0 ise, asal bir n bulduk . Daha sonra , bir sonraki yinelemeye geçmeden önce elek içindeki her n- biti ayarlamak için bir NxN ızgarasının satırlarını, sütunlarını ve köşegenlerini doldurma bölümünde daha önce açıkladığım formülü kullanıyoruz .
Factor ḞAsal çarpanlara ayırma
╓───╖
║ Ḟ ║
╙─┬─╜
┌───────┴──────┐
│ ┌───╖ ┌────╖ │
└─┤ Ṗ ╟─┤ Ḟp ╟─┘
╘═══╝ ╘═╤══╝
│
┌────────────────────────────────────────────┐
│ ╓┬───╖ │
┌───────┴─┐ ┌───────────────────────┐ ┌─╫┘Ḟp ╟─┘
│ ╔═══╗ ┌─┴─╖ ┌─┴─╖ ┌───┐ ┌────╖ ┌─┴─╖ │ ╙────╜
│ ║ 0 ╟─┤ ╟─┤ · ╟─┘┌┐ └─┤ Ḟp ╟──┐ ┌─┤ · ╟─┴──┐
│ ╚═══╝ └─┬─╜ ╘═╤═╝ └┤ ╘═╤══╝ ├─┘ ╘═╤═╝ │
│ ┌─┴─┐ ┌─┴─╖ ╔═╧═╕ ┌─┴─╖ ┌─┴─╖ ┌─┴──╖ ┌─┴─╖
│ │ └─┤ · ╟─╢ ├─┤ ? ╟─┤ · ╟─┤ ÷% ╟─┤ · ╟─┐
│ │ ╘═╤═╝ ╚═╤═╛ ╘═╤═╝ ╘═╤═╝ ╘═╤══╝ ╘═╤═╝ │
│ │ ┌──┴─╖ │ ┌─┴─╖ ┌─┴─╖ └──────┘ │
│ │ │ Ḟp ╟───┘ ┌─┤ ? ╟─┤ ≤ ║ │
│ ┌─┴─╖ ╘══╤═╝ │ ╘═╤═╝ ╘═╤═╝ │
└─────┤ · ╟─────┘ ╔═╧═╗ │ ╔═╧═╗ │
╘═╤═╝ ║ 0 ║ ║ 2 ║ │
│ ╚═══╝ ╚═══╝ │
└──────────────────────────────────────────┘
Bu oldukça basittir. Sadece n'ye kadar asalları tekrarlayın ve hangilerinin n'yi böldüğüne bakın . Bir bölünme yaparsa n , ile devam etmeyi unutmayın aynı o böler eğer biz bunu birden çok kez dönmek böylece asal n birden çok kez . Bu, 2'den küçük herhangi bir sayı için boş diziyi döndürür.
④ ◇ ◆bir elmas üret
Bu işlev, bir karakter ve bir yarıçap verilen tek bir elmas üretir. Karakteri sadece elmanın ortasına yerleştirmek için kullanır.
┌───╖
┌─────────────────────┤ ♯ ╟───────────┬─────────┐
│ ┌───╖ ╔═══╗ ┌───┐ ╘═══╝ │ │
└─┤ ♫ ╟─╢ 0 ║ │ ┌─┴─╖ │ │
╘═╤═╝ ╚═══╝ │ │ ʭ ╟───┐ │ │
┌─┴─╖ ┌─────┘ ╘═╤═╝ │ │ │
│ ɱ ╟───┤ ┌───╖ ┌─┴─╖ ╔═══╗ ╓───╖ │ │
╘═╤═╝ └─┤ ɹ ╟─┤ ʓ ╟─╢ 1 ║ ┌─╢ ◇ ╟─┤ │
│ ╔═══╗ ╘═══╝ ╘═══╝ ╚═══╝ │ ╙───╜ │ │
│ ║ 0 ║ │ ┌─┴─╖ │
│ ╚═╤═╝ │ │ ♭ ║ │
╔═╧═╕ │ ╔════╗ │ ╘═╤═╝ │
┌───╢ ├─┘ ┌─╢ 21 ║ ┌─┴─╖ ┌─┴─╖ ┌─┴─┐
│ ╚═╤═╛ │ ╚════╝ ┌────────┤ · ╟───┤ · ╟─┐ ┌─┴─╖ │
│ ┌─┴─╖ ┌─┴──╖ ┌───┘ ╘═╤═╝ ╘═╤═╝ ├─┤ = ║ │
│ ┌─┤ ‼ ╟─┤ >> ║ │ │ ┌─┴─╖ │ ╘═╤═╝ │
│ │ ╘═══╝ ╘═╤══╝ │ │ ┌─┤ ? ╟─┘ │ │
│ │ ┌───╖ │ ┌──┘ │ │ ╘═╤═╝ │ │
│ └─┬─┤ ⇄ ╟─┘ │ ┌─────┐ │ │ ┌─┴─╖ │ │
│ │ ╘═══╝ ┌─┴─╖ ┌─┴─╖ ┌─┴─╖ ┌─┴─╖ └─┤ · ╟──┬──┘ │
│ └───────┤ · ╟─┤ ? ╟─┤ · ╟─┤ ‼ ║ ╘═╤═╝ │ │
│ ╘═╤═╝ ╘═╤═╝ ╘═╤═╝ ╘═╤═╝ ┌─┴─╖ │ │
│ └─────┘ └─┬───┘ ┌───┤ … ║ │ │
│ ┌─────┐ │ │ ╘═╤═╝ │ │
│ ╔══╧═╗ ┌─┴─╖ ┌─┴─╖ ┌─┴─╖ ╔═╧══╗ │ │
│ ║ 32 ║ │ … ╟─┤ ‼ ╟─┤ ‼ ║ ║ 32 ║ │ │
│ ╚════╝ ╘═╤═╝ ╘═══╝ ╘═╤═╝ ╚════╝ │ │
│ ┌─┴─╖ ╔═╧══╗ │ │
│ ┌───┤ − ╟───┬─┐ ║ 46 ║ │ │
│ ┌─┴─╖ ╘═══╝ │ │ ╚════╝ │ │
└─────────────┤ · ╟─────────┘ └──────────────┘ │
╘═╤═╝ │
└───────────────────────────────────┘
Bu tembel sekansları yoğun şekilde kullanır. Şöyle çalışır:
0'dan r'ye (dahil) tamsayılar dizisi oluşturun .
Böyle bir tamsayı a için , ( r - α ) boşluklarından ( …), ardından bir noktadan, ardından α boşluklarından oluşan bir dize oluşturun - α = r değilse , bu durumda daha az boşluk oluşturur ve harfi ekler. Şimdi elmasın sol üst çeyreğine sahibiz.
Bu dizelerin her birine, aynı dizenin başka bir kopyasını ekleyin, ancak karakterler ters çevrilmiş ( ⇄) ve ardından ilk karakter kaldırıldı ( >> 21). Şimdi elmasın üst yarısına sahibiz.
Bu sırayı alın ve ona aynı sırayı ekleyin, ancak ters ( ɹ) ve ilk eleman kaldırıldığında ( ʓ). Şimdi elimizde tüm elmas var.
Şimdi elması oluşturan teller var, ama biraz daha bilgiye ihtiyacımız var. Pırlantanın dikey ortasının nerede olduğunu bilmemiz gerekir. Başlangıçta bu elbette r , ancak bunun üstüne ve altına başka elmaslar ekledikten sonra, diğer elmas yığınlarını dikey olarak hizalayabilmemiz için “orta” elmasın konumunu takip etmemiz gerekecek. . Aynı şey elmasın yatay boyutu için de geçerlidir (elmasları üste ve alta eklerken buna ihtiyaç vardır). Ayrıca mektubu takip etmeye karar verdim; Çünkü aksi takdirde ⬗(ki biz sonraki bölümde olsun) fonksiyonu dört parametre olması gerekir, ama Funciton sadece üç izin verir.
┌─────────────────┐
│ ╓───╖ │
├──╢ ◆ ╟──┐ │
│ ╙───╜ │ │
│ ┌─────┴───┐ │
┌─┴─╖ │ ┌───╖ ┌─┴─╖ │
┌─┤ · ╟─┴─┤ › ╟─┤ › ║ │
│ ╘═╤═╝ ╘═╤═╝ ╘═╤═╝ │
│ ┌─┴─╖ │ ┌─┴─╖ │
│ │ ◇ ╟─────────┤ › ╟─┘
│ ╘═╤═╝ ╘═══╝
└───┘
›[ X , y , c , q ] içeren bir yapı oluşturmak için liste API'sini kullanırız ( bir listenin önüne öğeler ekleriz ); burada x , elmanın yatay merkezinin x koordinatıdır, y , y- taban çizgisinin koordinatı, c harftir ve q , dizelerin tembel dizisidir. Bu yapı, bundan sonraki tüm ara aşamaları içermek için kullanılacaktır.
Diamond ⬗Elmasları dikey olarak ekle
Bu işlev varolan bir elmas yığınını, yarıçapı ve yeni elmanın üste (doğru) veya alta (yanlış) eklenip eklenmeyeceğini gösteren bir boole alır.
┌─────────────────────────────────────────────────┐
┌─┴─╖ ┌───────────────────────────┐ ┌───╖ ┌─┴─╖
┌───┤ · ╟─────────┘ ╔═══╗ ┌───────────────┐ ├─┤ ‹ ╟─┤ ‹ ║
│ ╘═╤═╝ ║ 1 ║ │ ╓───╖ │ │ ╘═╤═╝ ╘═╤═╝
│ │ ╚═╤═╝ └─╢ ⬗ ╟─┐ │ ┌─┴─╖ │ ┌─┴─╖
│ │ ┌───╖ ┌───╖ ┌─┴──╖ ╙─┬─╜ │ └─┤ · ╟─┘ ┌─┤ ‹ ╟─┐
│ ┌─┴─┤ + ╟─┤ ♯ ╟─┤ << ║ │ │ ╘═╤═╝ │ ╘═══╝ │
│ │ ╘═╤═╝ ╘═══╝ ╘═╤══╝ │ ┌─┴─╖ │ │ │
│ │ ┌─┴─╖ └───────┴─┤ · ╟───┐ ┌─┴─╖ │ │
│ └───┤ ? ╟─┐ ╘═╤═╝ ┌─┴───┤ · ╟─┐ │ │
│ ╘═╤═╝ ├───────────────────┘ │ ╘═╤═╝ │ │ │
│ ┌───╖ ┌─┴─╖ │ ┌─────┐ │ ┌───╖ │ │ │ │
└─┤ › ╟─┤ › ║ │ ┌───╖ ┌─┴─╖ │ └─┤ − ╟─┘ │ │ │
╘═╤═╝ ╘═╤═╝ │ ┌─┤ ‼ ╟─┤ ‼ ║ │ ╘═╤═╝ │ │ │
│ ┌─┴─╖ │ │ ╘═╤═╝ ╘═╤═╝ ┌─┴─╖ ┌─┴─╖ │ │ │
┌───┤ · ╟─┘ │ ┌─┴─╖ ├───┤ · ╟─┤ … ║ │ │ │
┌───┐ │ ╘═╤═╝ └─┤ · ╟───┘ ╘═╤═╝ ╘═╤═╝ │ │ │
│ ┌─┴─╖ ┌─┴─╖ ┌─┴─╖ ╘═╤═╝ │ ╔══╧═╗ │ │ │
│ │ ʭ ╟─┤ ? ╟─┤ › ╟─┐ ╔═══╗ ╔═╧═╕ │ ║ 32 ║ │ │ │
│ ╘═╤═╝ ╘═╤═╝ ╘═══╝ │ ║ 0 ╟─╢ ├─────────┘ ╚════╝ │ │ │
│ ┌─┘ ┌─┴─╖ │ ╚═══╝ ╚═╤═╛ │ │ │
│ └─┬───┤ ʭ ╟─┐ ┌─┴─╖ ┌─┴─╖ │ │ │
│ ┌─┴─╖ ╘═══╝ ├───┤ · ╟─────┤ ɱ ║ │ │ │
└─┤ · ╟───────┘ ╘═╤═╝ ╘═╤═╝ │ │ │
╘═╤═╝ │ ┌─┴─╖ │ │ │
│ └─────┬─┤ ◇ ╟───────────────────────┘ │ │
│ │ ╘═══╝ ┌─┴─╖ │
│ └─────────────────────────────┤ · ╟─────┘
│ ╘═╤═╝
└─────────────────────────────────────────────────────┘
Bu da oldukça basittir; ‹yapıyı açmak için kullanın ; ◇yeni elmas oluşturmak için kullanın ; ɱyeni elmastaki her dizenin başına ve sonuna boşluk eklemek için (map) öğesini kullanın, böylece her biri aynı genişliğe sahip olur; ʭyeni dizeleri eski (altta ise) üzerine veya eski dizeyi yeni (üstte ise) üzerine ekleyin ; ve son olarak ›tüm yeni değerleri içeren yapıyı oluşturmak için kullanın . Özellikle, tabana ekliyorsak, y değişmez, ancak zirveye eklersek, y artar ♯(r << 1)( r , yeni elmasın yarıçapıdır).
Sta ❖Yığınları yatay olarak birleştirin
Hepsinin en büyük işlevi bu. Bunu doğru yapmanın oldukça zor olduğunu inkar etmeyeceğim. İki yığın alır ve doğru dikey hizalamaya saygı gösterirken yatay olarak birleştirir.
┌──────────────────────────────────┬───────────────────────┐
│ ┌──────────────────┐ ┌─┴─╖ ┌─┴─╖
│ │ ┌───────────┐ └───────┤ · ╟───┬───────────────┤ · ╟─────────────┐
│ │ ┌─┴─╖ │ ╘═╤═╝ │ ╘═╤═╝ │
│ │ │ ‹ ╟───┐ │ ┌─┴─╖ ┌─┴─╖ │ │
│ │ ╘═╤═╝ ┌─┴─╖ └─────────┤ · ╟─┤ · ╟─────────┐ │ │
│ │ ├─┐ │ ‹ ╟───┐ ╘═╤═╝ ╘═╤═╝ │ │ │
│ │ └─┘ ╘═╤═╝ ┌─┴─╖ ╓───╖ ┌─┴─╖ │ │ │ │
│ │ │ │ ‹ ╟─╢ ❖ ╟─┤ ‹ ║ │ │ │ │
│ │ │ ╘═╤═╝ ╙───╜ ╘═╤═╝ ┌─┴─╖ ┌─┐ │ │ │
│ │ │ │ └───┤ ‹ ║ └─┤ │ │ │
│ │ │ │ ╘═╤═╝ ┌─┴─╖ │ │ │
│ │ │ │ └───┤ ‹ ║ │ │ │
│ │ │ └─────────────────┐ ╘═╤═╝ │ │ │
│ │ │ ┌─┴─╖ ┌─┴─╖ ┌─┴─╖ ┌─┴─╖ │
│ │ │ ┌──────────────┤ · ╟─┤ · ╟─┤ · ╟─┤ · ╟──────┐ │
│ │ └──────┤ ╘═╤═╝ ╘═╤═╝ ╘═╤═╝ ╘═╤═╝ │ │
│ ┌─┴─╖ ┌─┴─╖ ┌─┴─╖ │ │ │ │ │
│ ┌─┤ · ╟─────────────┤ · ╟────────────┤ · ╟───┘ │ │ │ │
│ │ ╘═╤═╝ ╘═╤═╝ ╘═╤═╝ │ │ │ │
│ │ │ │ ┌────╖ │ ┌─┴─╖ │ │ │
╔═══╗ ┌────╖ │ │ │ │ ┌─┤ << ╟─┴─────────┤ · ╟─┐ │ │ │
║ 1 ╟─┤ << ╟────────┘ │ │ │ │ ╘═╤══╝ ╘═╤═╝ │ │ │ │
╚═══╝ ╘═╤══╝ ╔════╗ │ │ ┌─┴─╖ │ ┌─┴─╖ │ │ │ ┌──┴──┐ │
┌─┴─╖ ║ 32 ╟─┐ │ │ ┌─────────────┤ · ╟───┐ │ │ ♯ ║ │ │ │ ┌─┴─╖ ┌─┴─╖ │
│ ♯ ║ ╚════╝ │ │ └─┤ ┌───╖ ╘═╤═╝ │ │ ╘═╤═╝ ┌───╖ ╔════╗ │ │ │ ┌─┤ ? ╟─┤ < ║ │
╘═╤═╝ ┌───╖ │ │ └─┤ − ╟─────────┴─┐ │ │ └───┤ … ╟─╢ 32 ║ │ │ │ │ ╘═╤═╝ ╘═╤═╝ │
└─────┤ … ╟─┘ │ ╘═╤═╝ ┌─┴─╖ │ └───┐ ╘═╤═╝ ╚════╝ │ │ │ │ ┌─┴─╖ ├───┘
╘═╤═╝ │ ┌───╖ ┌─┴─╖ ┌───────┤ · ╟─┴─┐ ╔═╧═╗ ┌─┴─╖ ┌──────┘ │ │ └─┤ · ╟───┘
│ ┌─┴─┤ ʭ ╟─┤ ȶ ║ │ ┌───╖ ╘═╤═╝ │ ║ 1 ║ │ ⁞ ║ │ ┌────────┘ │ ╘═╤═╝
┌─┴─╖ │ ╘═╤═╝ ╘═╤═╝ └─┤ > ╟───┴─┐ │ ╚═══╝ ╘═╤═╝ │ │ ┌──────┘ └────┐
│ ⁞ ║ │ ┌─┴─╖ ┌─┴─╖ ╘═╤═╝ │ ┌─┴─╖ ┌───╖ │ │ │ ┌─┴─╖ ┌───╖ ┌───╖ ┌─┴─╖
╘═╤═╝ └───┤ ? ╟─┤ · ╟─────┴─┐ │ │ − ╟─┤ ȶ ╟─┴─┐ │ │ │ + ╟─┤ ♯ ╟─┤ › ╟─┤ › ║
┌─┴─╖ ╘═╤═╝ ╘═╤═╝ │ │ ╘═╤═╝ ╘═╤═╝ │ │ │ ╘═╤═╝ ╘═══╝ ╘═╤═╝ ╘═╤═╝
┌────────────────────┤ · ╟───────┴───┐ └─┐ ┌─┴─╖ └───┘ ┌─┴─╖ │ │ └───┘ │ │
│ ╘═╤═╝ ┌─┴─╖ │ ┌─┤ · ╟───────────┤ · ╟───┘ │ │
│ ┌────────────────┐ │ ┌───────┤ · ╟─┘ │ ╘═╤═╝ ╘═╤═╝ │ │
│ │ ╔════╗ ┌───╖ ┌─┴─╖ └───┤ ┌───╖ ╘═╤═╝ │ │ │ ┌─┴───┐ │
│ │ ║ 32 ╟─┤ ‼ ╟─┤ · ╟───┐ └─┤ ʭ ╟───┘ │ │ ┌─┴─╖ ┌─┴─╖ ┌─┴─╖ │
│ │ ╚════╝ ╘═╤═╝ ╘═╤═╝ │ ╘═╤═╝ ┌─────┘ │ │ ʭ ╟─┤ · ╟─┤ ? ╟─┐ │
│ │ ┌─┴─╖ ╔═╧═╕ ╔═╧═╕ ┌─┴─╖ ┌─┴─╖ │ ╘═╤═╝ ╘═╤═╝ ╘═╤═╝ │ │
│ │ │ ‼ ╟─╢ ├─╢ ├─┤ ʑ ╟───┤ ʭ ║ ┌─┴─╖ └─────┘ │ │ │
│ │ ╘═╤═╝ ╚═╤═╛ ╚═╤═╛ ╘═╤═╝ ╘═╤═╝ ┌───┤ · ╟─────────────────────────┘ │ │
│ └──────────┘ │ ╔═╧═╗ │ ├───┘ ╘═╤═╝ │ │
│ └───╢ 0 ║ ┌─┴─╖ ┌─┴─╖ └───────────────────────────────┘ ┌─┴─╖ ╔═══╗
│ ╚═══╝ │ ȶ ╟───┤ · ╟─────────────────────────────────────────────────────┤ › ╟─╢ 0 ║
│ ╘═╤═╝ ╘═╤═╝ ╘═══╝ ╚═══╝
│ ┌─┴─╖ ┌─┴─╖
│ ┌─────┤ ? ╟─┐ │ ɕ ║
│ ┌─┴─╖ ╘═╤═╝ │ ╘═╤═╝
│ ┌───╖ ┌─┤ < ╟───┬─┘ │ │
└────────────┤ ɕ ╟─┤ ╘═══╝ ┌─┴─╖ │ │
╘═══╝ └───────┤ · ╟───┘ │
╘═╤═╝ │
└─────────┘
İşte böyle.
İlk olarak, her yığın için, her biri yığının genişliğine göre ⁞boşluk ( …) içeren sonsuz bir dizgi dizisi ( ) oluşturun .
Y yığınlar değerleri bize hangi “aşağı hareket” ve ne kadar tek ihtiyaçlar. ȶDoğru uzunluğa kesilmiş ( ) uygun boşluk sırasını (uygun şekilde y1 - y2 veya y2 - y1 ) ekleyin .
Şimdi ɕ, bize yüksekliklerini söyleyen dize dizilerinin ( ) her birinin uzunluğunu belirleyin . Hangisinin daha uzun olduğunu öğrenin.
Her iki yığına sonsuz boşluk dizisi ekleyin.
ʑBunları bir araya getirmek için zip ( ) kullanın . Her bir dize çifti için, aralarındaki ‼fazladan boşlukla ( ) birleştirin .
Sonraȶ bunun sonucunu en yüksek yüksekliğe kesmek için kullanın . Bunu geç yaparak, bunlardan hangisinin dolguya ihtiyacı olduğu umurumda değil.
Son olarak, yapıyı tekrar oluşturun. Bu noktada, elmaslardaki karaktere artık ihtiyacımız yok, bu yüzden bunu 0 olarak ayarladık. X değeri sadece toplanır ve arttırılır (böylece yığının genişliği yine de hesaplanabilir ♯(x << 1)). Y değeri iki yüksek birine ayarlanır.
⑦ ↯bir karakter dizisindeki karakterlerin üzerinde Bıkmadan
Bu, kütüphaneye ekleyeceğim başka bir yararlı işlevdir. Bir dize verildiğinde, her karakter kodunu içeren tembel bir sıra verir.
╓───╖
║ ↯ ║
╙─┬─╜
┌──────────────┴────────────────┐
│ ┌─┐ ╔═══╗ ┌───╖ │
│ └─┤ ┌────╢ 0 ╟─┤ ≠ ╟─┴─┐
┌──────┴─┐ ┌┐ ╔═╧═╕ ┌─┴─╖ ╚═══╝ ╘═╤═╝ │
│ ├─┤├─╢ ├─┤ ? ╟──────────┤ │
│ │ └┘ ╚═╤═╛ ╘═╤═╝ ╔════╗ ┌─┴─╖ │
│ ╔══════╧══╗ ┌─┴─╖ │ ║ −1 ╟─┤ ≠ ╟───┘
│ ║ 2097151 ║ │ ↯ ║ ╚════╝ ╘═══╝
│ ╚═════════╝ ╘═╤═╝
│ ┌─┴──╖ ╔════╗
└─────────────┤ >> ╟─╢ 21 ║
╘════╝ ╚════╝
and2097151 ile bir dize yazmak ilk karakteri döndürür. >>21 ile onu kaldırır. Esolangs sayfasında açıklanan bir nedenle hem 0 hem de −1'i kontrol ediyoruz ; Bu, bu meydan okuma ile ilgili değildir, ancak kütüphane işlevinin doğru olmasını istiyorum.
⑧ ⬖ elmas yığınına dönüştürme karakteri
Bu işlev tek bir karakter alır ve bir karakteri temsil eden dikey yığının yapısını döndürür.
╔════╗
║ 96 ║ ╓───╖
╚══╤═╝ ║ ⬖ ║
┌───╖ ┌───╖ ┌─┴─╖ ╙─┬─╜
┌───┤ ɗ ╟─┤ Ḟ ╟─┤ − ║ │
│ ╘═╤═╝ ╘═══╝ ╘═╤═╝ │
│ ┌─┴─╖ ├──────┘ ┌──┐
│ │ ɹ ║ │ ┌───┤ │
│ ╘═╤═╝ ┌─────┘ │ │ │
╔═╧═╗ ┌─┴─╖ ┌─┴─╖ │ ┌┴┐ │
║ 1 ╟─┤ ╟─┤ · ╟─────┐ ╔═╧═╕└┬┘ │
╚═══╝ └─┬─╜ ╘═╤═╝ ┌─┴─╢ ├─┘ ┌┴┐
┌───────────┐ │ └─┐ │ ╚═╤═╛ └┬┘
┌─┴─╖ │ │ ┌───╖ │ └─┐ ╔═╧═╕ ┌──┴─╖ ╔═══╗
┌─────┤ · ╟───┐ │ └─┤ ◆ ╟─┘ ┌─┴─╢ ├─┤ << ╟─╢ 1 ║
┌──┴─┐ ╘═╤═╝ │ │ ╘═╤═╝ │ ╚═╤═╛ ╘════╝ ╚═╤═╝
│ ┌──┴─╖ ┌─┴─╖ ╔═╧═╕ ╔═╧═╕ ┌─┴─╖ ┌─┴─╖ ┌─┴─╖ ┌─┴─╖
│ │ >> ╟─┤ ⬗ ╟─╢ ├─╢ ├─┤ ʩ ╟───┤ · ╟─┤ ʑ ╟────────┤ ⸗ ║
│ ╘══╤═╝ ╘═╤═╝ ╚═╤═╛ ╚═╤═╛ ╘═╤═╝ ╘═╤═╝ ╘═╤═╝ ╘═╤═╝
│ ╔═╧═╗ ┌┴┐ │ ╔═╧═╗ │ └─────┘ ╔═╧═╗
│ ║ 1 ╟─┐└┬┘ └───╢ 0 ║ ║ 0 ║
│ ╚═══╝ ├─┘ ╚═══╝ ╚═══╝
└────────┘
Bu fonksiyon ilginç çünkü elmasların alta ve alta dönüşümlü olarak eklenmesini istiyorduk . İşte böyle yaptım:
İlk olarak 96'yı çıkarın (böylece 'a'1 olur), asal faktörleri ( Ḟyukarıda) alın, ɗdizi boşsa 1 öğesini eklemek için kullanın ve ardından ɹsırayı tersine çevirin ( ).
İlk elemanı çıkarın ve ◆yığını hızlı bir şekilde başlatmak için arayın .
Şimdi, ⸗0 ve 1 sayılarını süresiz olarak değiştiren tembel bir sıra oluşturmak için kullanın .
Bunun ʑüzerinde (zip) ve kalan ana faktörleri kullanın. Her asal faktör için, onu 1 ve or0/1 sola kaydırın. Şimdi asal sayıları ve üst / alt bilgileri kodlayan bir dizimiz var .
Son olarak, kullanın ʩ(sola / toplama katlayın). İlk değer, yukarıdaki ilk öğeden ürettiğimiz yığıntır. Her bir ν değeri ⬗için, önceki yığının, asal ( ν >> 1) ve üst veya alt ( ν & 1) olup olmadığını arayın (yeni bir elmas ekleyin ).
Program Ana program
Burada ana işi yapıyoruz.
┌─────┐
│ ┌─┴─╖
│ │ ⬖ ║
╔═══╗ ╔═╧═╕ ╘═╤═╝
║ 0 ╟─╢ ├───┘
╚═╤═╝ ╚═╤═╛ ┌───╖ ┌───╖ ╔═══╗
└─┐ └───┤ ɱ ╟─┤ ↯ ╟─╢ ║
┌─────────┐ └─────┐ ╘═╤═╝ ╘═══╝ ╚═══╝
│ ┌─┴─╖ │ ┌─┴─╖
│ ┌───┤ · ╟───┐ └─┤ ╟─┐
│ │ ╘═╤═╝ │ └─┬─╜ │
│ ┌─┴─╖ ╔═╧═╕ ╔═╧═╕ ┌─┴─╖ │
│ │ ❖ ╟─╢ ├─╢ ├─┤ ʩ ╟─┘
│ ╘═╤═╝ ╚═╤═╛ ╚═╤═╛ ╘═╤═╝
└───┘ ╔═╧═╗ │ ┌─┴─╖ ┌─┐
║ 0 ╟───┘ ┌─┤ ‹ ╟─┴─┘
╚═══╝ │ ╘═══╝
┌─┴─╖ ┌─┐
┌─┤ ‹ ╟─┴─┘
│ ╘═══╝
╔════╗ ┌───╖ ┌─┴─╖ ┌─┐
║ 10 ╟─┤ ʝ ╟─┤ ‹ ╟─┴─┘
╚════╝ ╘═╤═╝ ╘═══╝
│
İlk olarak, ɱgiriş dizesindeki ( ↯) karakterlerin ( ) üzerine eşleyin ve kullanarak her birini bir elmas yığını haline getirin ⬖. İlk öğeyi bu öğeden çıkarın ve ʩhepsini ( ❖) birleştirmek için diğerlerini ( ) katlayın . Son olarak, ‹dizelerin sırasına ulaşmak için yapıyı paketinden çıkarın ʝve ayırıcı olarak 10'u (yeni satır) kullanarak hepsine ( ) katılın .
Örnek çıktı
Giriş:
crusaders
Çıktı (hesaplanması 9 saniye sürdü; boyut sınırı nedeniyle buraya yazılamıyor).