Meydan okuma:

Göreviniz, her birinin bir tamsayı çıktığı / yazdırdığı / döndürdüğü, olabildiğince çok sayıda program / fonksiyon / snippet yazmaktır. İlk program tamsayı 1, ikincisi 2vb. Çıktı vermelidir .

Programlar arasında hiçbir karakteri tekrar kullanamazsınız. İlk program Yani, eğer: x==xo zaman karakterleri kullanamaz xve =diğer programların herhangi birinde yine. Not: Aynı karakteri bir programda birçok kez kullanmasına izin verilir.

Puanlama:

Kazanan, en yüksek olanı satacak. Bir beraberlik olması durumunda, kazanan toplamda en az bayt sayısını kullanan gönderim olacaktır.

Kurallar:

• Tüm tam sayılar için yalnızca tek bir dil kullanabilirsiniz
• Snippet'lere izin verilir!
• Adil olması için tüm karakterlerin seçtiğiniz dilde tek bir bayt kullanılarak kodlanması gerekir.
• Çıktı ondalık olmalıdır. Bilimsel gösterimle veya başka bir alternatif formatla yazdıramazsınız. Float çıkışları, ondalık basamağın arkasında gösterilen tüm rakamlar olduğu sürece geçerlidir 0. Yani, 4.000kabul edilir. FPA'ya bağlı yanlışlıklar çıktıda gösterilmediği sürece kabul edilir.
• ans =, önde gelen ve sondaki boşluklara ve yeni hatlara vb. izin verilir.
• Doğru çıkış STDOUT’a döndürüldüğü sürece STDERR’yi göz ardı edebilirsiniz.
• Tamsayının STDERR'ye çıktısını seçebilirsiniz, ancak yalnızca STDOUT boşsa.
• Sembolden bağımsız dillere (örneğin Lenguage ) izin verilmez
• Harfler büyük / küçük harfe duyarlıdır a != A.
• Programlar bağımsız olmalı
• Boşluk yeniden kullanılamaz
• Çıkışta ASCII basamak kullanmalısınız

Açıklamalar teşvik edilir!

JavaScript (ES7), puan 17, 176 bayt

Yapamayacağını söylediler, ben de yaptım: D (@FullDecent'ın yardımları için teşekkürler)

""**""
~(~/~//~/~/)/~/~/
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

Kullanılmayan karakterler:

#&,:?@ABDGHIJKLMOPQRTUVWYZ\_bcdfijkmopqrsuvwyz|

18'in mümkün olduğunu sanmıyorum ama 17'de de aynı şeyi söyledim ...

açıklama

JavaScript çok zayıf yazılmış bir dildir; sayı olmayan bir değer üzerinde matematiksel bir işlem gerçekleştirmeye çalışırsanız, JS önce onu bir sayıya dönüştürmek için elinden geleni yapacaktır. Bu, birçok ilginç çözüme olanak sağlar. Rakamları mümkün olduğu kadar kullanmaktan kaçınmaya çalıştım, böylece daha sonra kullanılabilirler.

1. **ES7'deki üsteletme operatörüdür. Bir sayıya zorlandığında boş dize olur 0, böylece bu hesaplanır 0 ** 0; bu, 1JavaScript'e göredir.
2. Biraz saçma ama işe yarıyor. /~/bir regex değişmezi ve ~/~/döndürür -1, yani bu ~(-1 / -1) / -1= ~(1) / -1= -2 / -1= 2. ( fikir için @ GOTO0'a kredi verir )
3. Basitçe 3.
4. Şimdi basitçe 4.
5. NaNbu nedenle, falsy olan !NaNisimli trueeşdeğer olan, 1. Böylece ifade 1 - -1 - -1 - -1 - -1= 1 + 1 + 1 + 1 + 1= olur 5.
6. Basitçe 6.
7. Basitçe 7.
8. Basitçe 8.
9. Basitçe 9.
10. Bu biraz JSF *** sihir kullanır . +[]olduğu 0, böylece, [[]][+[]]birinci elemanın döner [[]](yani, []) ve ++bu artırım 1. Sonra bir dizeye zorlanan ve yapan +[+[]]diziyi ekler .[0]"10"
11. Basitçe 11. Ben aslında 11&11113 ve 33/311 için kullandım , ancak bir daha ne kadar aptal olduğumu fark ettim.
12. Bu strateji herhangi bir sayı üzerinde işe yarayabilir: bir dizi uzunluk 12ve kullanım oluşturun .length.
13. Sadece bunu almak için bir süre 2s ve >s ile uğraştım . Tekrar şanslı oldum: 222 >> 2öyle 55ve 55 >> 2öyle 13.
14. Bu oldukça zor. Temel fikir 14hex ( 0xE) içinde oluşturmaktır , ancak 0başka bir basamağa ihtiyacımız var . Bunun yerine ``^``dizgenin sonucunu hazırlarız xE; boş bir sayıya zorlanan dize 0, bu nedenle 0 ^ 0= döndürür 0. Sonra sonuç, her iki değeri de sayılara dönüştüren boş dizeyle XORed olur; "0xE" ^ ""olduğunu 14.
15. Bu şimdi oldukça kolay: 0XFdeğeri olan onaltılık bir değişmezdir 15.
16. Hepsinden en zoru mu? Önce değişkeni ayarlamak Ciçin CSS == CSS(yani, true). Sonra sonuç almak ve gerçekleştirmek << Ctemelde çarpar dört kez, 1tarafından 2 ** 4.
17. JavaScript 2 ^53'te tamsayı hassasiyetini kaybetmeye başlar ve bu, ya da 555...555%55olmayan bir sayı döndürür . Buralarda oynarken çok şanslı oldum.05

Birçok sayıda işe yarayacak stratejiler:

• -!NaN5Çok hızlı olsa da (şu anda ) herhangi bir sayı üzerinde çalışacaktı .
• ~/~/herhangi bir sayı (şu anda üzerinde çalışacak 2o alır olsa) çok büyük , çok hızlı.
• +[](şu anda 10) herhangi bir sayı üzerinde çalışacaktı , ancak 10ya da üzerinde çok kolay 11.
• .length herhangi bir sayı üzerinde çalışacaktı.
• `${-``}xE`-`` Doğru yaparsanız hemen hemen her numara üzerinde çalışacak.
• C<<C16Eğer varsa iki (şu anda ) herhangi bir gücü veya herhangi bir int üzerinde çalışacak |.

Jelly , 47 tam sayılar, 519 bayt

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

Her satır ayrı, dolu bir programdır.

Çevrimiçi deneyin! (test paketi ve kesişme denetleyicisini içerir)

Nasıl çalışır

Komut satırı argümanları olmayan her tam program ana linkini (son satırda tanımlanır) niladik olarak, yani giriş yapmadan yürütür. Zincirdeki ilk bağlantı bir nilad ise, tüketilir, çağrılır ve hem ana bağlantının argümanı hem de dönüş değeri sonuç olarak ayarlanır; zincirinin ilk halkası, bir monad ya bir gayenin ise, bu olup değil tüketilen ve örtük fikir ve dönüş değeri 0 yerine kullanılır. Her iki durumda da, zincirin geri kalanı monadik olarak gerçekleştirilir.

Jelly birkaç durumda çıktısını düzenler. Özellikle, bir singleton dizisi etrafındaki parantezler olmadan yazdırılır, yani 42 ve [42] ve yazdırdıktan sonra ayırt edilemez. Bunu birkaç kez kullanacağız.

1 - 10

e

Mevcut dönüş değeri ise atomu testleri 0 argüman ait 0 . Öyle, 1e döndürür .

BI$⁼#

BI$bir hızlı bağlantıdır, özellikle ikili atomu ve artış atomunu hızlı $gruplandırarak oluşturulan monadik bir zincirdir . Birleştirildiğinde, bir tamsayıyı taban 2'deki basamak dizisine dönüştürür, ardından elde edilen basamakların ileri farklarını hesaplar. Dizinin yalnızca bir öğesi varsa, ileriye dönük fark yoktur ve boş bir dizi döndürür (falsy); en az iki rakam varsa, boş olmayan bir dizi (truthy) döndürür.BIII

Hızlı #önceki hızlı bağlantıyı tüketir ve yeterli eşleşme bulunana kadar eşleşme dizisini döndürene kadar bunu 0 , 1, 2,… öğesine uygular . Hesaplanır gerekli miktarda ⁼dönüş değeri / argüman karşılaştırır, 0 gr, kendisine 1 . Böylece, programın tamamı , taban 2'de iki basamaklı ilk negatif olmayan tam sayı olan [2] döndürür .

⁾⁾⁾Ụ^/

⁾⁾⁾bir dize değişmezi, özellikle de ⁾⁾ dizesidir . Not up atom Ụ, endekslerini karşılık gelen değerlerine göre sıralar; Her iki karakter de eşit olduğundan, bu [1, 2] sonuç verir . Elde edilen dizi bit ^/yönünde XOR ile azaltılır , bu nedenle tüm program 3 döndürür .

ı***ıḞḞ

ıargümanı başlatır ve hayali birime geri döndüren değer i . *olan üs alma kimin doğru argüman ana bağlantının argüman varsayılan dyad. Bu nedenle, ***ıdeğerlerini hesaplar ((i ⁱ ) ⁱ ) ⁱ 4.81 + 0i ≈ , Ḟatomu ( kat gerçek bağımsız değişkenler için, gerçek kısmı kompleks olanlar için), gerçek parçanın (hesaplar 4.81 ), daha sonra Ḟelde zeminler, 4 .

5
6
7

Bu üç program tek bir hazır bilgi içeriyor ve tam olarak ne istersen onu yapıyor.

.::::

Değişmez 0.5. için bir kısa yoldur ve argüman ve dönüş değerini başlatır. Tam sayı bölümü DYAD'ın en ( ana bağlantılar argüman) doğru bağımsız değişken varsayılan, bu hesaplar 0.5 / 0.5 / 0.5 / 0.5 / 0.5 gr, 8 .:::::

9

Başka bir değişmez.

EȮ<

Hepsi eşit atomu Edöner 1 argüman olarak tüm elemanlar aynı olup olmadığını ve 0 değilse. Bir tamsayı argümanı z [z] ye yükseltilir , bu nedenle örtük argüman 0 için 1E değerini döndürür .

Şimdi, çıkış atomu 1'den STDOUT'a Ȯyazdırır . Daha sonra 1'i atomdan küçük olan 0 kullanarak örtük argüman 0 ile karşılaştırırız . Sonuç (1 <0) = 0'dır ve program bittiğinde dolaylı olarak yazdırılır.<

11 - 20

⁻GṘ

Izgara atomu Gbağımsız değişken ile ilgili görsel olarak hoş bir tablo oluşturmak için çalışır. Düz tamsayı argümanı için (burada: 0 ), onu yalnızca bir diziye sarar. Düz eşit değildir atomu ⁻örtülü argüman karşılaştırır 0 (sağa sonucu [0] ) elde edildi, 1 bağımsız değişkenleri eşit değildir çünkü. Temsil atomu Ṙbaskılar 1 STDOUT ve sonucu verir. Programın sonunda, son getirinin değeri örtük bir şekilde basılıyor, bu yüzden 11'lik bir çıktı veriyoruz .

=`p`VV×`DQV

Kendi kendine hızlı olan `, bir dyad'ı aynı sol ve sağ argümanlarla çağırarak monata dönüştürür. İlk olarak, 0=` argümanını kendisiyle karşılaştırarak 1'i verir .

Kartezyen ürün atomu p, bağımsız değişkenler olarak listelerini bekler, bu nedenle tam sayı teşvik 1 aralığı [1, ..., 1] = [1] . [1] 'p` in Kartezyen ürününü ve kendisini alır [[1, 1]] .

Eval atomu Vdaha sonra, dizeleri (sadece sayı ve harf içeren) tüm düz diziler döner giriş parametresiz jöle programları elde edilen dizeleri değerlendirir. [[1, 1]] önce [“11”] 'e dönüştürülür , daha sonra [11]' iV veren dizgeyi değiştirir . Bir kez daha, bu diziyi "11" e çevirir , sonra 11 verimini verir .V

Şimdi, 11'i kendisiyle ×`çarparak 121'i veriyor . Ondalık atomu döner 121 içine [1, 2, 1] , benzersiz bir atomu ikinci atar 1 ve bir kez daha, onları birleştirerek geri sonuçlanan tamsayı basamaklı bir listesini döner 12 .QV

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

~bir bit-bazında değil atomudur. İkinin tamamlayıcı aritmetiğiyle, z argümanını z ile ~ z = - (z + 1) arasında eşleştirir . Abir mutlak değeri atomu, böylece de oluşturulan - (z + 1) = z + 1 . İlk geri dönüş değeri 0 ile , ~Ageri dönüş 13'ün 13 kopyası .

⁷ṾṾṾw

Sabit ⁷, '\ n' newline karakterini tutar ve argüman ve return değerini başlatır.

Uneval atomu Ṿargümanı bir dizge gösterimini oluşturmak için çalışır z bu kodun oluşan bir jöle programı döneceğini böyle z .

İlk çağrı ustalıkla bir karakter değişmezliği olan "" \ n " dizesini döndürür . Bir sonraki çağrı "" "," \ n " - bir karakter değişmezi döndürür . Üçüncü ve son çağrı "" "," "," ,, "", "\ n" - karakter değişmezlerinin bir özetidir.

Son olarak, pencere endeksi atomu wsağ argüman teşvik '\ n' dizesine "n \" ile başlayan bir alt dize ilk indeksi bulmak "\ n" . Bu 14 döndürür .

⁴ḟ€⁴Ṁ

⁴16 sabittir . Quicklink filter her false ( ḟ€), sol argümanını ( 16) [1,…, 16] aralığına yükseltir , ardından öğeleri üzerinde yinelenir.

Her öğe için z , ḟ⁴önce z'yi [z] ' ye terfi ettirir , sonra 16'nın (varsa) tüm oluşumlarını kaldırır . Bu, [[1], [2],…, [14], [15], []] dizilerini verir, burada son dizi boş olduğundan 16 içerdi .

Son olarak, maksimum atom Ṁseçer [15] .

mmmmċ

Modüler atomu m- argümanlar ile adı x (dizi) ve y (tamsayı), genellikle her alır | y | ^inci elemanı x , ilk başlayarak 0> y , son birlikte, y <0 . Ancak, y = 0 olduğunda , tersi ile birleştirilmiş x değerini döndürür .

Sol tamsayı argümanı 0 ilk önce [0] a yükseltilir . İlk kopya mbirleştirir [0] kendisi ile, elde edildi : [0, 0] . Kalan kopyalar bu sonucu [0, 0, 0, 0] , sonra [0, 0, 0, 0, 0, 0, 0, 0] ve son olarak [0, 0, 0, 0, 0, 0'a dönüştürür. , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] .

Sonunda, sayım atomu ċörtük argüman 0'ın sonuç dizisinde göründüğü sayıyı sayarak 16 döndürür .

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

ṭolduğunu tack atomu ve sağ birine sol argüman ekler. Yana ṭve aşağıdaki ḍdiyadik olan tüm çağrıları ṭörtülü argüman geçmesine 0 doğru argüman olarak ṭ. İlk arama [0, 0] , ikinci [0, [0, 0] ve sekizinci ve son [0, [0, [0, [0, [0, [0, [0, [0, 0]]]]]]]] .

ḍolduğu bölünebilme atomu; argümanlar için x ve y , bu döner 1 olduğu X bölünemeyen bir y , 0 değilse. Ḅtam sayılar için bir işlem yapılmadığından , oluşturulan dizideki her tam sayı tarafından bölünebilirlik için 0ḍḄ test eder. 0 kendiliğinden bölünebilir, bu yüzden [1, [1, [1, [1, [1, [1, [1, [1, 1]]]]]]]] elde ederiz .

Şimdi, birleşik atom Ḅdüz diziler üzerinde çalışır. Bir çift [a, b] için basitçe 2a + b döndürür . Daha önce belirtildiği gibi, Ḅtamsayılar no-op: bir tamsayıdır bağımsız değişken c yükseltildikten [c] ve [c] içinde bir baz basitçe c .

İlk arama için Ḅazaltmaktadır [1, 1] için 3 , bu şekilde elde [1, [1, [1, [1, [1, [1, [1, 3]]]]]]] . Bir sonraki çağrı azaltır [1, 3] ile 5 , bir sonraki [1, 5] için 7 dokuzuncu kadar benzeri ve Ḅgeri dönüş 17 .

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

Ṇolan düz mantıksal NOT atomu ve kapalı bir argüman haritalar 0 ile 1 . +ekleme atomudur, bu nedenle on sekiz kopyanın her biri +Ṇönceki geri dönüş değerini (başlangıçta 0 ) arttırır . Böylece tüm program 18 döndürür .

CNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNC

Cbir tamamlayıcı atomu ve bağımsız değişken harita z için 1-z . Nolduğu negate atomu ve bağımsız değişken harita z için -z . Birlikte, CNharitalar z için - (1-Z) = Z-1 , on sekiz adet kapalı argüman edecek, böylece 0 içine -18 . Son Cverim uygulaması 1 - (-18) = 19.

ĖḌĖḌ

Numaralandırmak atomu Ėgöstergesi değer çiftlerini oluşturmak, bir dizideki numaralanmaktadır. Örtük fikir 0 yükseltildikten [0] , daha sonra Ėelde edilir : [[1, 0]] . Undecimal atomu, sonuçta, 10 tabanında bir düz dizi tamsayı dönüştürür [10] , bu özel durumda.

İkinci çağrı Ėdönüşümleri [10] içerisine [[1, 10]] , ikincisi Ḍson dönüşür [20] .

21 - 30

ṫṣȦJṫȦ⁸ȦJ

Kuyruk atomu ṫ(bir iki atomlu) dizin başlar sol argüman ekine seçmek sol tamsayı değeri teşvik, sağ bileşen olarak belirtilen (1 tabanlı ve modüler) x için [x] ' . Her iki bağımsız değişken 0 olarak ayarlandığında çağrıldığında , [0]ṫ döndürür .

Her türlü atom Ȧdöner 1 argümanı truthy ve herhangi bir derinlikte, hiç sıfır içeriyorsa 0 , aksi. Burada, örtük argümanı 0 döndürmek için onu bir kimlik işlevi olarak kullanırız . En bölünmüş atom ṣsol argüman bölmeler [0] onun sağ Tartışmanın oluşumda 0 , bu nedenle döner [[], []] burada.

Endeksleri atomu Jdönüş değeri etkisiz bırakır ve aralık, sonuçta indisleriyle ile değiştirir [1, 2] Bu özel durumda. Ȧve ṫher ikisi de eskisi gibi çalışır, bu nedenle [1, 2] son dizinde başlayan posta sırasına indirgenerek [2] olur .

Niladik bağlantılarda, sabit [] değerini ⁸tutar . Bu, parçalanamayan bir niladdır, yani herhangi bir şekilde zincire uymaz. Sonuç olarak, önceki dönüş değeri ( [2] ) STDOUT'a yazdırılır, ardından niladın değeriyle ( [] ) değiştirilir.

Yana [] falsy olup, Ȧdönüştürür 0 . JAtomu teşvik 0 için [0] , daha sonra indeksi (listesini verir [1] programı tamamlandığında örtülü basılır).

22

Başka bir değişmez. Repdigitler onları kullanmak için en iyi yer gibi görünüyor.

“@ṃ»

Bu Jelly'in dahili string sıkıştırmasını kullanır. Endeksleri @ ve M Jelly kod sayfasında olan 64 ve 220 ve dize hazır 250 farklı karakter içerebilir, bu nedenle bu ilk tamsayı hesaplar 250 × 65 + 220 = 16470 .

16470 , 3 ile bölünebilir, bu nedenle bölüm 16470/3 = 5490 , yazdırılabilir bir ASCII karakterini veya bir satır beslemeyi kodlar. Bunların 96'sı ve 5490 = 96 × 57 + 18'dir , yani yazdırılabilir ASCII karakterini '2' olan 0-temelli indeks 18'de çözdük .

57 ile ayrıldık , bu da 3 ile bölünebiliyor , yani 57/3 = 19 = 96 × 0 + 19 bölümü , 0 tabanlı indeks 18'de '3' olan yazdırılabilir ASCII karakterini kodluyor .

Bu 0 bırakır ; kod çözme işlemi durur. Üretilen karakterler "23" oluşturmak için birleştirilir

!ḤḤ!

Faktöriyel atomu !örtülü bağımsız değişken döner 0 içine 1 . İki çağrıları unhalve atomu Ḥedecek 1 içine 2 , daha sonra 2 içine 4 . Sonunda, 4! hesaplar ! = 24 .

³HH

Komut satırı argümanlarının yokluğunda sabit 100³ tutar . İki çağrıları döner 100 içine 50 , daha sonra 50 içine 25 .H

ØaM

Sabit Øaküçük harfli alfabe tutar. En büyük atom , en büyük Möğelerin tüm indekslerini verir ve z , en büyük küçük harf olduğundan, sonuç [26] .

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

Birleştirilmiş atomun yirmi altı kopyası ;, ilk sıfır değerini 0 ve varsayılan argümanın 0 yirmi altı örneğini birleştirerek 27 sıfır dizisini oluşturur.

¬bir mantıksal NOT atomu, yani ;¬bir ekler 1 sıfır dizisine. Bir sonraki ¬, dizideki tüm elemanları etkisiz hale getirip, bizi 27 ve 1 sıfır dizisiyle bırakıyor.

ḅolduğu unbase atomu tamsayı sağ bileşen olarak belirtilen tabanından sol argümanı arasında bir rakam dizisi dönüştürür. ḅ¬unary'den tamsayıya dönüşür, bu nedenle sadece bir toplam yapar. 27'den oluşan bir dizi için bu, 27 döndürür .

irið8c

Dizin atomu isol argüman teşvik 0 için [0] , daha sonra sağ argüman endeksi bulmak 0 gr, bu dizide 1 .

Aralık atomu rondan bir artan veya azalan aralığı sağ birine argüman bıraktı oluşturur. Doğru argüman örtük argüman 0'dır , yani bu [1, 0] verir . İkinci bir çağırma idizinini bulur 0 içinde , [1, 0] , sonuçta 2 .

ðyeni, ikili bir zincir başlıyor. Yukarıdaki zincir niladik olduğu için, bu zincirin hem sol hem de sağ argümanı, ilk zincirin dönüş değerine eşit olacaktır ( 2 ). ciçinde kombinasyonları atomu. Sol argüman 8 ve sağ argüman 2 ile , 8C2 = 8! / (6! 2!) = 28 döndüren , 8 elemanın tüm benzersiz, sırasız 2 kombinasyonlarını sayar .

⁶ḲĠṂ°İṂĊ

Sabit ⁶bir boşluk karakteri tutar ve argüman ve dönüş değerini '' olarak ayarlar . Kelime atomu Ḳkarakteri teşvik ' tekil dizeye "" ve sonuçta, boşluklar it at böler [[], []] .

Grup atomu Ġgrupları aynı elemanların tüm indisleri. Son dönüş değerinin her iki elementi eşit olduğundan, burada [[1, 2]] değerini döndürür . Minimum atomu bu dizinin en az bir (yalnızca) elemanı, elde özler [1, 2] .

Derece atomu °, sonuçta radyan altmış tabanlı derece iki tamsayılar dönüştürür 1 ° x 2π / 360 ° = π / 180 ve ° × 2π / 360 ° = π / 90 2 . Ters atomu, sonuçta çarpımsal Tersi alır 180 / π ≈ 57.3 ve 90 / π ≈ 28.6 .

Ardından, bir Ṃkez daha minimum değer alır, 28.6 . Son olarak, ceil atomu Ċdönüştüren 28.6 içine 29 .

œṡ¹ẆẆTUṖṖṖṖP

Kimlik atomu ¹döner 0 örtülü değişken için 0 . Çevresinde bölme atomu œṡbağımsız değişkenler (her ikisi de her iki teşvik 0 için) [0] , ardından böler [0] eşit bitişik altdizilimlerden çevresinde [0] . Bu , [[], []] ürününü verir .

Kayan pencere atomu Ẇbağımsız değişken tüm bitişik Altdizilim oluşturur. Birinci derece dönüştüren [[], []] içine [[]], [[], [[]], [[]]] , ikinci örnek dönüştürür [[], [[]], [[[]] []]] olarak
[[[[]]], [[[]]], [[[], []]], [[[]], [[]]], [[[]], [ [], []]], [[[]], [[]], [[], []]]] .

Gerçek atomu Ttruthy elemanların tüm indisleri listeler. İlk seviyedeki dizilerin hiçbiri boş değil, bu nedenle bu [1, 2, 3, 4, 5, 6] sonuç veriyor . Yukarı çıkan atom Ubu diziyi tersine çevirerek [6, 5, 4, 3, 2, 1] değerini verir .

Pop atomunun dört kopyası Ṗson dört elementi kaldırarak bizi [6, 5] ile bıraktı . Son olarak, ürün atomu Pbu diziyi 30'a dönüştürür .

31 - 40

ȷ½RṪ

ȷ1 × 10 ³ = 1000 için bir kestirme yoldur . Karekök atomu ½verir 31.6 , aralık atomu Rdönüşür [1, ..., 31] . Son olarak, kuyruk atomu 31Ṫ döndüren son elemanı çıkartır .

LµdddddµFL

Uzunluk atomu Lörtülü argüman teşvik 0 için [0] vermek üzere, daha sonra uzunluğu alır 1 . µmonadik yeni bir zincir başlatır ve sonuç 1 argümanı olur.

X ve y argümanları için , divmod atomu [x / y, x% y] değerinid verir . Her aramada y = 1 olacaktır , dolayısıyla sonuç daima [x, 0] olacaktır .

İlk çağrı , [1, 0] veren x = 1 ile başlar . sadece tam sayılarda çalışır, bu nedenle sonraki çağrılarda vektörleşir. İkinci çağrı [[1, 0], [0, 0]] , üçüncü [[[[1, 0], [0, 0]], [[0, 0], [0, 0]]] verir , ve beşinci ve sonuncusu, bir tane ve 31 sıfır içeren bir dizi derinlik 5'tir.d

µbir kez daha yeni, monadik bir zincir başlar ve öncekinden gelen dizi kendi argümanı olur. Düz atomu Ftek bir ve 31 sıfır bir düz dizi, sonuçta bu dizi unnests. Son olarak, Lsonuçta 32 , dönen uzunluğunu alır .

33

Başka bir repdigit, başka bir değişmez.

WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWŒḊ

Sarma atomunun her örneği , argümanını z'yi [z] 'e dönüştürür . 0 başlangıç ​​değeri ile birlikte, 34 örneğin tümü birlikte [[[[[[[[[[[[[[[[[[[[[[[[[[0]]])] ]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]] . Son olarak, derinlik atomu ŒḊ, 34 döndüren, elde edilen dizinin maksimum derinliğini hesaplar .

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

Pencere olsa atomu ẇbağımsız değişkenler (her ikisi de varsayılan için her ikisi de teşvik 0 kadar) [0] , ** [0] ** bitişik bir alt dizisinde maddesi olması durumunda o zaman testler [0] . Öyle, 1ẇ döndürür .

ɓyeni, ikili bir zincir başlıyor. Yukarıdaki zincir niladik olduğu için, bu zincirin hem sol hem de sağ argümanı, ilk zincirin dönüş değerine eşit olacaktır ( 1 ). Zincir iki farklı, iki atomlu atomdan yararlanır: bitshift left ( æ«) ve bitwise OR ( |).

Üç ya da daha fazla sayıda ipucu ile başlayan bir ikili zincir, ilk önce zincirin argümanları ile ilk perdesi çağırır. İşte, bu 1 << 1 = 2 verir . Takip eden altı dyad, en sağ dyadın ilk önce zincirin argümanları ile çağrıldığı, daha sonra en sola birinin her iki tarafa önceki geri dönüş değerleri ile çağrıldığı çiftler ( çatallar ) olarak gruplanır .

İçin æ«æ«, aldığımız 2 << (1 << 1) 2 << 2 = 8 = . Ardından, 8 << (1 << 1) = 8 << 2 = 32 olarakæ«æ« hesaplar . Şimdi, bizi 32 alır | (1 << 1) = 32 | 2 = 34 .|æ«

Son olarak, iz, |bir kanca gibi davranır ve bir önceki dönüş değeri ile sol argümanı ve zincirin sağ argümanı olarak adlandırılır. Bu 34 döndürür | 1 = 35 .

⁹ṚḢ²

İkinci bir argüman olmadığında, sabit 256⁹ tutar . Ters atomu teşvik 256 diziye [2, 5, 6] ve elde etmek için ters [6, 5, 2] . Daha sonra, kafa atomu birinci elemanı çıkartır ve kare atomu ** 6² = 36 * döndürür.Ḣ²

‘‘‘0‘‘‘‘‘‘‘

Arttırma atomu ‘tarafından argüman artırır 1 , bu nedenle ‘‘‘, ilk dönüş değeri edecek 0 halinde 3 . Aşağıdaki 0 , ayrılmaz bir niladdır, yani herhangi bir şekilde zincire uymaz. Sonuç olarak, önceki dönüş değeri ( 3 ) STDOUT'a yazdırılır, ardından niladın değeri ( 0 ) ile değiştirilir.

Aşağıdaki 7 kopyaları ‘sırayla bu 0 içine 7 programı tamamlandığında örtülü yazdırılır.

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

Eksiltme atomu ’tarafından argüman azaltır 1 , bu otuz sekiz adet, ilk geri Değeri 0 içine -38 . Mutlak fark atomu ạarasındaki işaretsiz bir farkını hesaplar -38 ve kapalı argüman 0 , dönen 38 .

-____---__________

--1 için kısa yoldur ve bağlantının argümanını ve dönüş değerini -1 olarak ayarlar . Her biri _, eğer sağ argümanı varsayılan olarak -1 ise varsayılan olan dyadik çıkarma atomunun bir örneğidir .

İlk önce (-1) - (-1) - (-1) - (-1) - (-1) = 3-____- değerini hesaplar . Aşağıdaki -1 ayrılmaz bir niladdır, bu nedenle önceki dönüş değeri ( 3 ) STDOUT'a basılır, sonra niladın değeri ( -1 ) ile değiştirilir.

Daha sonra, (-1) - (-1) = 0 değerini -_hesaplar ; burada hazır bilgi sol argümanı ayarlar ve dönüş değerini sağa olarak kullanır. Aşağıdaki dokuz kopya , varsayılan argümanı -1 , geri dönme değerinden çıkarır ve 9 biter ve program sona erdiğinde dolaylı olarak yazdırılır.-__

”(O

”(hazır bir karakterdir ve sıralı atom O, Unicode kod noktasına bakar, 40'ı verir .

41 - 47

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

Üçüncü bir komut satırı bağımsız yokluğunda sabit ⁵tutan 10 . Unlength atomu Ḷözellikle 0 tabanlı dizi oluşturur [0, ..., 9] değişkeni için 10 her iki tarafına da, yer tekrar atomu x. Sonuncusu, sol argümanının öğelerini sağ olanın tekrarlarıyla eşleştirir ve her bir öğeyi karşılık gelen sayıda tekrarlar. İle [0, ..., 9] hem sol ve sağ argüman olarak, biz böylece vb sıfır sıfır, tek tek, iki ikişer ikişer, olsun

Atomun içindeki dizinị , sağ argümanının elemanını solunda belirtilen dizine getirir. Sol argüman 10 ( ⁵solda) ve sağ argümanla [1, 2, 2, 3, 3, 3, 4, 4, 4, 4,…, 9] (önceki sonuç), bu 4 verir .

Bu noktaya kadar olan zinciri parçalanamayan bir nilad izler ⁵, bu nedenle önceki geri dönüş değeri ( 4 ) STDOUT'a basılır , geri dönüş değeri 10 olarak ayarlanır ve zincirin geri kalanı her zamanki gibi ayrıştırılır.

Daha önce olduğu gibi ⁵ḶxḶ, diziyi [1, 2, 2, 3, 3, 3, 4, 4, 4, 4,…, 9] verecek . Bu kez, çağrı sıralanmış atomu Ṣbağımsız değişken ile 10 teşvik 10 için , [1, 0] , o zaman elde etmek üzere sıralar [0, 1] . Diyadik kafa atomu hemen uzunlukları önekleri getirir 0 ve 1 bize bırakarak sola sonucundan [[1], []] . Yazdırıldığında, 1 dışında hiçbir şey görünmeyecektir.

⁽{ʂ%⁽{}

⁽ve onun iki takip eden karakteri sayısal bir değişmezdir. Eğer j ve k Jelly'in kod sayfasındaki kod noktaları ve (j, k) <(124, 250) ise , 1001 + 250j + k tamsayısını alırız . Kod noktaları '{' , '}' , ve 'ʂ' olan 123 , 125 ve 167 , bu yüzden hazır bilgi değerlendirir sol 1001 + 250 x 123 + 167 (= 31918) doğru bir değerlendirir ise, 1001 + 250 x 123 + 125 (= 31876) .

Sol tamsayı sağdakinin iki katından daha küçük olduğundan, sonuç (… + 167)% (… + 125) = (… + 167) - (… + 125) = 167-121 = 42'dir .

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

Karışık atomu Ẋolan argüman elemanları sırasını rasgele; z sayısal bir argüman önceden [1,…, z] aralığına yükseltilir . Örtük argüman 0 için , bu aralık boştur ve [] değerini Ẋverir . Tüm atomu döner 1 kendi argüman tüm unsurları, truthy ise 0 değilse. Boş bir dizi sahte öğeler içermediğinden, buraya 1 döndürür .ẠẠ

Zip atomu ż(bir iki atomlu) argümanlar alır x ve y ve çift aktarır [x, y] . X ve y tamsayıları için , bu basitçe [[x, y]] değerini verir, bu nedenle ż, 1 ve 0 argümanlarıyla (örtük argüman) adlandırılan bu belirli , [[1, 0]] döndürür . Diyadik eval atomu vsonra, tüm düz diziler (içeren tek sayılar ve karakter) i dizeleri içine sol argüman döner programların argümanlar olarak sağ argümanla monadic Jöle programları gibi çıkan dizeleri değerlendirir. ["10"] tarihinden beriyalnızca değişmezlerden oluşur, bu doğru argümanı görmezden gelir vve basitçe sonuçlanır [10] .

Kopya hızlı ©üzere ataşeler vkayıt içine sonuç ve kopyaları. Daha sonra geri çağırma atomunun ®(bir nilad) meydana gelmesi , kayıt defterinden [10] alacaktır .

Bundan sonraki üç żvçalışma kopyası [10] - [[10, 0] - [100] ila [10000] ile eşleştirilmiştir . Sipariş atomu ọsol argüman, bu nedenle burada da doğru bir bölünemeyen bir kaç kez yapılan testler, bu sırasını hesaplar , 10 ile (getirilen ®olarak) 10000 = 10 ⁴ , sonuçta [4] .

Aşağıdaki ®ayrılmaz bir niladdır, bu nedenle önceki dönüş değeri ( [4] ) STDOUT'a basılır, sonra niladın değeri ( 10 ) ile değiştirilir. Daha Ạsonra 1 vererek başvuru yaparız . (Bu bir nilad olarak gereklidir ve bunu takiben bir dyad bu noktada ayrılabilir olacaktır.)

Daha önce olduğu gibi żvżvżv, geçerli dönüş değerine üç sıfır ekleyerek 1 değerini [1000] değerine getirir . Son olarak, ọ®sırasını hesaplar 10 içinde 1000 = 10 ³ ve 3 programı tamamlandığında bekletilmektedir edilir.

44

Yine başka bir repdigit, başka bir değişmez.

111111l11&K1111111Kl11&

Birincisi ve en önemlisi, hazır bilgi 111111argümanı ve başlangıç ​​dönüş değerini 111111 olarak ayarlar . Diğer çalıştırmalar 1aynı zamanda değişmezdir.

lbir logaritma doğru bir belirtilen tabanına sol argüman logaritmasını hesaplar atomu. Üzerinde çağrıldığında 111111 doğru argüman ile 11 , biz olsun log ₁₁ 111111 ≈ 4,85 .

Kelime atomu Kboşluk bir liste bağımsız değişken katılır, bir sayısal / karakter teşvik sonra z için [z] . Burada, biz sadece bağlantının argümanını açmak için kullanabilirsiniz 111111 içine [111111] . (Burada bir dizi gerektirmiyoruz, ancak kimlik atomları tükendi.) Bitsel AND atomu &, dönüş değerlerini her iki tarafa da götürür, gerektiğinde tamsayıya çevirir ve bitsel olarak hesaplar. Bu özel durumda, [4.85 & 111111] = [4 & 111111] = [4] değerini döndürür .

Aşağıdaki 1111111ayrılmaz bir niladdır, bu nedenle önceki dönüş değeri ( [4] ) STDOUT'a basılır, sonra niladın değeriyle ( 1111111 ) değiştirilir. Kdaha sonra bu tam sayıyı [1111111] 'e çevirir . (Bu bir kez daha gerekli değildir, ancak bir dyadın izlediği bir nilad bu noktada ayrılabilir olacaktır.)

Daha önce olduğu gibi, log ₁₁ 1111111 ≈ 5.81l11 hesaplar , ardından [5.81 & 111111] = [5 & 111111] = [5] değerini döndürür .&

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

Birden fazla kullanıcı tanımlı bağlantılardan oluşan tek program budur. Son bağlantı ana bağlantıdır ve program başladığında yürütülür, geri kalanlar yardımcı bağlantılardır. Hızlı, Çher zaman geçerli olanın üzerindeki bağlantıya atıfta bulunur ve bunu monadik olarak gerçekleştirir. Aynı şekilde, hızlı olan Ñher zaman geçerli olanın altındaki bağlantıyı da ifade eder (etrafını saran) ve aynı zamanda tek taraflı olarak da yürütür.

Üst bağlantı oluşur çift atomu ,argümanlar döner ikilisinin - x ve y içine [x, y] - ve toplam atomu S- bir tamsayıdır argüman teşvik eden bir monadın z için [z] ilave edilerek ve azaltan bir dizi bağımsız değişkeni. Bağlantı ,SSbir n tamsayı argümanı ile çağrıldığında , Σ [n, Σn] = Σ [n, n] = 2n değerini hesaplar .

Orta Yukarıdaki bağlantı atomu, yukarıda sözü edilen, hızlı oluşur Çve önemsiz atomu Ịveren bir monadın - 1 sayısal bağımsız değişkenler için z ile 1 ≤ -1 ≤ z , ama 0 diğerleri için. ỊBir tamsayı argümanına iki kere uygulamak n, esas olarak 1 ile yer değiştirir , çünkü birincinin çıktısı Ị( ikincinin girişi ) her zaman önemsizdir. Bu sonuç daha sonra Ç( n argümanı ile çağrılan) dönüş değeri ile eşleştirilir ve sonuçta ortaya çıkan çift azalır S. Toplamda hesaplıyoruzΣ [(| n | ≤ 1) ≤ 1, 2n] = Σ [1, 2n] = 2n + 1 .

Bu iki yardımcı bağlantı yerindeyken, ana bağlantı artık ikili basamağa bakarak negatif olmayan herhangi bir tam sayı oluşturabilir. 0 başlangıç ​​değeri olan zincir ÇÑÇÇÇÑ, nihai sonucu hesaplar ((((((0 × 2 + 1) × 2) × 2 + 1) × 2 + 1) × 2 + 1) × 2 = ((5 ×) 2 + 1) × 2 + 1) × 2 = 46 .

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

Bir sonraki ana atom, argümanından kesinlikle daha büyük olan en küçük pozitif asal sayıyı bulur. İlk geri dönüş değeri 0 olduğunda , onbeş çalıştırma Ænonbeşinci sayıdır ( 47) .

beyinbeyin , skor 2, 255 144 10 bayt

... Evet, en iyi fikir değil çünkü birlikte çalışacak 8 karakterim var (tarpitler tarpit yapacak) ama ne kadar mümkün olduğunu görelim. Bence bu mümkün. : P Bu cevap, beyin fırtınasının kullandığı sekiz karakterden altısını gösterir, diğer ikisi ,ise girdi olan ve .çıktı olan.

+
>--[<->-]

Çevrimiçi olarak görselleştirin!

açıklama

Her sayı kasetteki başlangıç ​​hücresinde oluşturulur ve saklanır. Ağır bir şekilde birkaç tercümana uygulanmayan sarma hücrelerine dayanır.

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 , skor 38, 327 bayt

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: 𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝐥

Açıklama:

• 1 için, “eşitlik kontrolü” belirtecini kullanıyoruz, burada Neim boş girdiyi açmaya çalıştığında 0 alır.
• 2'den 9'a kadar sadece sayısal harfleri kullanırız.
• 10'dan 32'ye kadar, Neim aslında hepsi için bir bayt sabiti var (evet, çılgınca).
• 33 için, yalnızca increment komutunu kullanırız. İlk baytta Neim, bir şeyi arttırmaya çalışır, böylece onu artırabilir, ancak giriş boş olduğundan, varsayılan olarak açılır 0.
• 34 için aynı yaklaşımı kullanıyoruz, fakat azaltıyoruz ve mutlak değeri alıyoruz.
• 35 için, sıfır faktörlülüğün bir olduğu gerçeğinden faydalanıyoruz ve bunu çoğaltarak ve tekrar tekrar ekleyerek kullanıyoruz.
• 36 için, ℂeşliklilik için 0 ve 0'ı kontrol ediyoruz , ki bunlar. Bu, 1 iter. Sonra 𝐋, sadece 2 içeren tekil bir listeyle sonuçlanan ilk prime ulaşırız. Sonra 2'yi 𝐠sayı olarak iten en büyük elementi ( ) alırız . Ardından listeyi alana kadar bu işlemi tekrarlıyoruz [2 3 5 7 11]. Ondan sonra 𝐝, listeden çıkan deltaları hesaplamak için kullanırız [1 2 2 4]. Sonra, 𝐬9 olan toplamı almak için kullanırız , sonra 0 ile 9 arasındaki özel aralığı hesaplar ve sonuç olarak elde ederiz [0 1 2 3 4 5 6 7 8]. Sonunda 𝐬37 almak için tekrar kullanılır.
• 37 için, αnegatif olanı temsil eden bir sabittir ve tekrar tekrar bastırır ve çıkarırız (tekrar boş girişte girmeye çalıştığımız zaman 0'dan yararlanılır)
• 38 için, bir kez daha boş giriş için varsayılan 0'ı kullanarak, kendine 0 ekleyerek uzun bir liste oluşturarak uzunluğu hesaplıyoruz.

Burada denenebilir

Python 2, 15

İşte bir başlangıç, daha fazlasını aramak

15 yaşına girmeme yardım eden leo sayesinde

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

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

Japt , 448 bayt, skor 42

Shaggy , ETHproductions ve Oliver arasındaki büyük işbirliği .

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

Bu (faydalı) karakterler kaldı:

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

açıklamalar

Başlamadan önce Japt hakkında bilinmesi gereken birkaç şey, bunu sıklıkla kullandım. İlk olarak, Japt, büyük harflerden oluşan, girdi için ayrılmış 6 değişkene sahiptir U-Z. Bu değişkenlerden hiçbir girdi geçilmezse, varsayılan olarak tümüdür 0. İkinci şey bu ipucu ile kaplıdır .

Çevrimiçi tercümanda denemek için herhangi bir parçacık üzerine tıklayın .

v

Bir dizi uygulandığında, vyöntem, bir tam sayı alır n , bağımsız değişken olarak ve döner 1 numara ile bölünebilir ise n , 0 değilse. Eğer n için bunu daha sonra varsayılan sağlanmazsa 2 . 0 (varsayılan değer U) 2 ile bölünebilir , bu nedenle bize 1 değerini verir .

y

İlkiyle çok benzer. Bir sayıya uygulandığında, yyöntem bir n tamsayısını argüman olarak alır ve iki sayının GCD'sini döndürür. Eğer n için bunu daha sonra varsayılan sağlanmazsa 2 . Yana 0 ile bölünebilir 2 , OBEB (0, 2) bize bizim verir 2 .

Íà

àkombinasyonlarının sayısını verir [1...this]döndürür, 3

Qiiii)iiii)âQ

Qvarsayılanları tek bir tırnak işaretine getirir. ibir dize başında başka bir dize ekler; # 3'te açıklandığı gibi , her iiii)biri JS'ye eşdeğerdir .i("i".i("i")), bu nedenle idizenin başına iki kopya ekler. Bunu iki kez yapın ve dizginiz olur iiii". âQdaha sonra 4 olan dizedeki .search(Q)ilk dizini vererek taklit eder ."

ÂHq

LÁL

´Vn´VnVnVn

Daha önce belirtildiği gibi, Vvarsayılan olarak 0'dır . Operatör ´için kısayol --olduğundan kod şu JS'ye eşdeğerdir:

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

X.n(Y)Y - X veya -X + Y'ye eşittir ; ilk -1 , ve ikinci -2--V döndürür , bu yaklaşık olarak - (- 1) + (- (- 2) + (- (- 2) + - (- 2)) 'ye eşdeğerdir . Basitleştirilmiş, biz 1 + 2 + 2 + 2 = 7 olsun .

8
9

Kelimenin tam anlamıyla, 8 ve 9 .

A
B
C
D
E
F
G

Bunlar dahil olmak üzere 10 - 16 sabitleridir .

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

J-1 olarak ayarlanmıştır . Japt yorumlayıcısı bir şekilde bunu doğru şekilde ayrıştırmayı başarıyor (J--) - (--J) - (--J) - (--J) - (--J). Biraz daha matematik yaparak, bunun (-1) - (-3) - (-4) - (-5) - (-6) veya -1 + 3 + 4 + 5 + 6 = 17'ye eşit olduğunu bulduk. .

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

¾Tahmin edebileceğiniz gibi, bir kısayol .75. Bir diziye 0,75'lik 24 kopya koyduktan sonra toplamı 0,75 * 24 = 18x veriyoruz .

;Iìw

Sanırım bu benim favorim. ;Programın başlangıcında, Japt sabitlerinin bazılarının değerlerini değiştirir; o olmadan Iise 64 , ama onunla, Iolan 91 . ìwrakam ve ishal listesine dönüştürür wdiziyi ters listesinde, sonra bize almak için yeniden bir sayıya dönüştürür 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

Ve final ~~bunu 20'ye çıkarmamız için bir tamsayıya döşemeye yarar .

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

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

Sonuç 1 + 2 + 3 + 4 + 5 + 6 , yani 21 olur .

22

Bir edebi 22 .

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

Äkısayol olduğu için +1bu sadece 23 1 sn.

4á

Bu [1, 2, 3, 4], 4 olan permütasyon sayısını bulur ! = 24 .

5²

²p2kısaca, ikisinin gücüne bir sayı veren bir kısayol . 5 ** 2 , 25'dir .

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

°++operatör için bir kısayol veya ayrıştırılamazsa + +,. Daha önce belirtildiği gibi, hiçbir giriş olmadığında, Uvarsayılan olarak 0'dır . Bu yüzden kod, # 17 : ' (++U), (U++) + + (++U) + + (++U) + + (++U) + + (++U) + + (++U)ye çok benzeyen eşdeğerdir , ilk önce artırılır , daha sonra tekrar tekrar artırılır ve nihai sonuç 1 + 3 + 4 + 5 + 6 + 7 = 26 olacak şekilde eklenir .U1

»³³

³3p argümanı olan yöntemin kısayolu . Ancak, bir sol-parantezden hemen sonra küçük bir harf görünürse ( kısayol olur), bir dize haline gelir. Bu, bir yönteme geçmesini ve bir işlev olarak adlandırılmasını sağlar (yani eşleştiriyor ). Bu durumda, ancak, bizim döner , o zaman biz gücüne onu yükseltmek ( bize veren bir sayıya uygulanan güç yöntemiyle), 27 .»((m³.p(3)("p",3)33p

7/¼

¼, muhtemelen şimdiye dek bildiğiniz gibi, bu bir kısayoldur .25, bu nedenle bu 7 / 0.25 = 28 değerini hesaplar .

$'_____________________________b'$bb

$Sembollere sarılmış herhangi bir şey saf JavaScript olarak değerlendirilir, bu nedenle a'dan sonra gelen 29 alt çizgi dizisinden oluşan bir dizilim vardır b. (Olmadan $, 'tek bir karakter dizisi olacaktır.) bBir dizi tatbik yöntem dizisi içindeki Terimin birinci indeks döndürür. Açıklandığı gibi 3. son bbir dizeye dönüştürülür, bu yüzden ilk indeksi kapma konum bbizim dize, içinde 29 .

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

µ-=ve Éiçin bir kısayol -1. Etkisi 30 kopya çıkartmaktır -1 den 0 verir, 30 .

"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"aa

Çok # 29 gibi. aYöntem, bir dizeye uygulandığında, o dizede Terimin son indeksini döndürür. 0 indeksleme kullanarak a, 32 as'lik bir dizedeki son dizin 31'dir .

Sc

Stek bir alana önceden tanımlanmıştır ve tek cbir karakter dizgisinde karakter kodunu döndürerek 32 verir .

33

Edebiyat 33 .

Mg011

MgNNn Fibonacci sayısını döndürür. 011olduğu 9 sekizlik; 9. Fibonacci sayısı 34 .

##

#Bir sonraki karakterin char kodunu döndürür. Kendisinin karakter kodu 35# olur ve buradaki işimizi özellikle kolaylaştırır.

6p

püstel ve ikinci bir argüman olmadan varsayılan olarak 2 olur ; bu nedenle, bu 6 ** 2 = 36 yazdırır .

Rí í í í í è.

Bu oldukça zor. Rtek bir yeni satır karakteri için varsayılan değerler (daha sonra bu yeni satır önemli olur). íBir dizgede, herhangi bir argüman olmadan, her karakteri alır ve dizini ekler: oldukça işe yaramaz bir dönüşüm, ancak 5 yinelemenin sonucu şudur: ( Rdeğişmez bir yeni satır yerine)

R
R0
R001
R0010213
R001021304251637
R0010213042516370849210511112613314715

Her bir girişin basitçe bir sonrakinin öneki olması ilginç ... Ama yine de, son kısım, sonuçta è.kaç tane eşleşme bulunduğunu sayar /./g. Dize 38 karakter vardır; ancak, /./gsadece yeni satır olmayan karakterlerle eşleştiğinden, sonuç 37'dir .

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

Backticks sıkıştırılmış bir dize işaretleyin ve ¥karşı açar ll. lBir ip üzerinde length verir , bu yüzden dekompresyondan sonra, bu 38 verir .

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

Oooh çocuk, bu bir sersem. İlk olarak, elde trueile ¨N( ¨açılımı >=ve Nbir girişli boş bir dizi), daha sonra bu dönüştürme 1ile |N. Oradan dışarıya oldukça çılgına dönüyor:

ò    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 yalnızca yakın parenler yerine geçmiştir ve ihmal edilmiştir.) Sonuncusu odizideki son öğeyi çıkarır ve 39 değerini verir .

º¤¤*º¤

Çoğunlukla # 3 ile aynı numara . 2 argümanı olan yöntemin ¤kısayolu . Bununla birlikte, bu durumda, transpillenmiş kod basitleştirilmiştir veya basitleştirilmiştir . sayıyı veren bir base-2 string olarak döndürür ; dolaylı olarak bunu bir sayıya dönüştürür ve 40 vererek, 4 ile çarpar .s(("s", 2).s(2) * (("s", 2) * (("s", 2))))(2).s(2) * (2 * 2).s(2)"10"* (2 * 2)

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

Öncekine benzer. 1 argümanı olan yöntemin Åkısayolu . Bu durumda, ancak, sadece 1 döndürür her transpiles . olan 32. ve bir 8 ; bunlar 41 almak için birlikte XORed .s(Å("s", 1)1<<1<<1<<1<<1<<11<<1<<1<<11

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

±+=ve ¶için bir kısayol ===. Bu kodun aslında olduğu anlamına gelir

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

Y===Y her zaman doğrudur, bu yüzden bunu basitleştirebiliriz:

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, puan 17, 130 Bayt

kullanılan karakterler 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 Boolean sabit Z (ayarlanmadı) eşit sabit Z

2 FTP_MOREDATA, PHP'de 2 değeri olan bir sabittir

3 bitwise ve karakter; ve w

4 bitsel Sola kaydırma ve mantıksal değil boş diziyi kaydırma yapma

7 bitwise Veya chars # ve $ and 1

9 SIGKILL, PHP'de 9 değeri olan bir sabittir

10 bitwise Shift her adım 8 olan bir tamsayıdır, bu nedenle 333333, 41666, 5208, 651, 81, 10 adımlarına sahibiz.

13 X dizesinde char X sayılır ... en baştan

15 onaltılık değer f = 15

Ha ile YV dizeleriyle 17 bit yönünde Xor

Tüm snippet'ler bir dizideki öğelerdir

Çevrimiçi deneyin!

PHP, puan 16, 94 Bayt

kullanılan karakterler 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 Boolean sabit Z (ayarlanmadı) eşit sabit Z

2 bit yönünde ve karakter: ve w

3 Pi boş dizi aracılığıyla tamsayı değerine sıfıra dönüştürüldü

7 bitli xor veya A ve v karakterleri

10 değişken $ s ayarlanmadı! $ S = $ s değişken uzunluğa sahip bir concat

13 111/2 = 55/2 = 27/2 = 13 Tamsayılı bölme bit yönünde

15 onaltılık değer f = 15

Tüm snippet'ler bir dizideki öğelerdir

Çevrimiçi deneyin!

PHP, puan 14, 84 Bayt

kullanılan karakterler $!_^[]()%/+~-=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 Boolean sabit Z (ayarlanmadı) eşit sabit Z

3 Pi boş dizi aracılığıyla tamsayı değerine sıfıra dönüştürüldü

7 ERA, 131116 mod 11 = 7 değerine sahip bir sabittir

10 değişken $ s ayarlanmadı! $ S = $ s değişken uzunluğa sahip bir concat sıfır

13 onaltılık değer d = 13 14 bit yönünde değil ve eksi işareti NULL değerine 14 yükseltir

Tüm snippet'ler bir dizideki öğelerdir

Çevrimiçi deneyin!

R, skor 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 sayesinde fazladan bir tane var.

Kullanılan karakterler:

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

MATL , skor 21 22 23 sayı (273 bytes)

22'den 23'e kadar sayıları uzattığımız için J Doe'ye teşekkürler !

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

Çevrimiçi deneyin! Bağlantıdaki her pasaj, yığını temizlemek ve böylece bir sonraki pasajdan izole etmek içinD(ekran) veya]D(döngüyü açıkça kapat ve göster)sona erer.

açıklama

0~

İttir 0. Yadsımak. Verir trueolarak görüntülenir ki, 1.

'bd'd

Dize itin 'bd'. Karakterlerin kod noktaları arasındaki ardışık fark.

{P}gk

Sayı içeren hücre dizisini itin pi. Sayısal diziye dönüştür (örneğin, tek bir sayıya). Aşağı yuvarlama.

HH^

İtin 2iki kez. Güç.

5

Sayısal hazır bilgi.

6

Sayısal hazır bilgi.

7

Sayısal hazır bilgi.

8

Sayısal hazır bilgi.

9

Sayısal hazır bilgi.

3 3.333333333333333*

İttir 3. İttir 3.333333333333333. Çarpmak. Kayan nokta doğruluğu nedeniyle bu verir 10.

11

Sayısal hazır bilgi.

IEE

İttir 3. 2İki kere çarpın .

[B]Yq

İtin [6](aynı olan 6). Compute n -inci asal.

llllllllllllllNwxwxwxwxwxwxwxwxwxwxwxwxwxwx

114 kez bas . Yığındaki öğelerin sayısı. Yığının kalanını temizle.

KUKUa-

İttir 4. Meydan. Aynısını yap. Herhangi biri: verir 1. Çıkarın.

4W

İttir 4. 2buna yükseltildi.

FFFFFFFFFFFFFFFFFn

Diziyi it [false false ... false](17 kez). Dizideki öğelerin sayısı.

TTTTTTTTTTTTTTTTTTs

Dizi [true true ... true](18 kez) itin . Dizinin toplamı.

rrrrrrrrrrrrrrrrrrrhhhhhhhhhhhhhhhhhhz

Aralıktan (19) alınan 19 rasgele sayıya basın. Yatay olarak 18 kez birleştirin. Dizideki sıfır olmayan elemanların sayısı.

OOOOOOOOOOOOOOOOOOOOvZyX>

020 kere bas . Yığın içeriğini dikey olarak birleştirmek (bir sütun vektörü verir). Boyut: diziyi verir [20 1]. En fazla dizi

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

1j(Hayali birim) 21 kez itin . 20 kez ekleyin. Tarafından bölün 1j.

22

Sayısal değişmez

`@QQQQQQQQQQQQQQQQQQQQQQ@@<

Yapılır ... while döngüsü ( `) örtük uçlu. İlk yinelemede yineleme endeksini ( @) iter ve Qverimi 22 kat arttırır 23. Döngü koşulu ( @@<) yanlıştır, bu nedenle döngüden çıkılır.

Daha fazla gelişme için bazı fikirler

• snippet 10’daki (boşluk) |
• X>pasajda 20 p, önek serbest bırakılarak değiştirilebilir X.
• Şu anda, kullanılmamış ve potansiyel olarak yararlı: :,A

Windows'ta Vim 8, skor 13, 104 bayt

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}temsil eder <C-{keystroke}>, böylece, ^Xisimli <C-x>dışında için ^@olan <C-j>. Hala bu listeye daha fazla numara eklemeye çalışıyorum ve <CR>bir satır beslemeyi temsil ediyor.

Not: Bu komutları çalıştırmak için vim kullanmaya başlayın -u NONE -U NONE. Bu, yapılandırmalarınızın kodu etkilememesini sağlamak içindir.

1'den 10'a kadar olan snippet'ler ekleme modunda başlar. Parçacıklar 12 ve 13 normal modda başlarken.

açıklamalar

Snippet 8'dir :^R=&ts^@. Bunun için geldiği için @ L3viathan'a, kabadayı ^@yerine yenisini önerdiği için @ nmjcman101'e ve @ ØrjanJohansen'e kısaltmak &tabstopiçin teşekkür etmeliyim &ts. &tsdaha sonra, varsayılan olarak 8 olan sekmenin boyutunu değerlendirir ve bu değer editöre eklenir.

Metin Parçacığı 10 8^O^A^O^A. Bir 8 ekleriz ve sonra 10 elde etmek için iki kez arttırırız.

Metin Parçacığı 11 0^[^X^X^X^X^X^X^X^X^X^X^X0x. 0 yazıp 11'e -11 olsun. O zaman eksi 11'i alırız.

Metin Parçacığı 12 :h<CR>wwwwwwwwwwwy$:q<CR>p. Bu, Vim 8'in aşağıdaki bilgileri içeren yardım menüsünü açar:

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

Ve ws dizisi 12'ye hareket eder, bu noktada sayı y$kopyalanır. Daha sonra kullanarak editöre yapıştırılır p.

Snippet 13, grgKjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjYZZvPWWWllld|llDgeldiği için @ DJJcMayhem'e teşekkür ediyor. Bu sadece Windows'ta çalışır. Metin parçacığı, yardım menüsünden ile başlayan komutları arar g. Sonra jbu çizgiye ulaşmak için kullanarak aşağı hareket eder :

|g?|        g?      2  Rot13 encoding operator

Bundan sonra onu kopyalar ve tamponun içine yapıştırır. Bundan sonra, 13 dışındaki her şey tampondan çıkarılır.

Mathematica, skor 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 , Skor 18, 67 bayt

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

Çevrimiçi deneyin!

PingPong , 127 puan

PingPong'da her karakterin kendine özgü bir sayısal değeri vardır ve bu sayede 127'ye kadar önemsiz bir iş sayılır. Dil, her karakterin değerini okuyarak ve tüm işlemlerin gerçekleştirildiği bir yığının en üstüne iterek çalışır. PingPong teorik olarak 127'yi geçebilir ancak metin editöründe sadece boşluk gibi görünen bir karakter bloğunun geçmesi gerekir, bu yüzden onları çözümümden çıkardım.

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

Oktav, Skor 14, 74 bayt

Oldukça eminim ki şimdi sınıra yakınım.

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

Kaldırmak zorunda kaldı strchrZaten beri csayısının 10. Hala var içinde j, ^, =, !, uzay ve bu mümkün olabilir bu yüzden bir daha sıkmak için, sol yatay sekme (ASCII-9).

Yatay sekme boşluk olarak kullanılabilir, böylece hile ile kullanılabilir strchrve nnzbir kez daha kullanılabilir. Geriye kalan sadece küçük harfler abdfgjkmoquvwxy. Bunlardan yapılabilecek birçok fonksiyon yoktur. modişe yarayabilirdi, ancak string girişi alamıyor.

Kalan karakterleri almak için kullanmak kolaydır 1, ancak başka bir şeyi nasıl alabileceğimi bilmiyorum.

Hepsini sınayın .

Muhtemelen kullanışlı: fun aaynıdır fun('a'), fun a baynı fun('a','b')benzeri ve. Bu birkaç yerde kullanılabilir:

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

Bunu kullanmak mümkün olacak 0, ancak henüz nasıl kullanışlı hale getirileceğini göremiyorum.

e (2.71828...)ve jhala kullanılmamış. Gerçi ceilkullanmak için kaldırmanız gerekir e.

Alternatifler (ilham kaynağı):

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 tam sayı, 137 130 128 bayt

Çektiğim @ETHproductions' cevabını ve bir süre onunla birlikte koştu; o kadar değişti ki, ayrı olarak gönderiyorum. Fikirler açığız. :)

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

Kalan:
$_@#!^&|/?:, ABDEGHIJKLNPQRUVWZcghjklmpqrsuvwyz

Veya 1 için snippet ile değiştirilirse !!/!//!!/!/:
$_@#^&|*?:", ABDEGHIJKLNPQRUVWZcghjklmpqrsuvwyz

JavaScript (ES7), 16 tam sayılar, 127 bayt

Bir bayt daha kısa. : 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

Kalan: $_@#!/^&|?:,ABDFGHIJKLNPQRVWYZcghjklmpqrsuvwyz

Dyalog APL, skor 15, 89 bayt

≡''
≢###
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

_{Daha önce Newlines l:l12 bir parçasıdır.}

_{14'teki boşluklar sekmeleri temsil eder.}

> <> , skor 20, 93 90 74 65 bayt

(Teal Pelican tarafından kaydedilen 3 byte, Jo King tarafından kaydedilen çok sayıda byte!)

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

Balık oyun alanında onları deneyin! Snippet'lerin sonuçlarını n;her birinin sonuna ekleyerek yazdırmasını sağlayabilirsiniz . 9. pasajın yığın değişimi ile yenen bir sekme içerdiğine dikkat edin.

Açıklama:

• İçinde iii((, her biri igirdi almaya çalışır, ancak hiç olmadığından, EOF = -1yerine basarlar . Öyleyse (, talimattan -1daha azdır ve bundan daha az olmadığı için -1, bir yanlışlık yapar 0; ancak ikincisi (, olduğundan -1daha az olup olmadığını sorar 0, bu yüzden bir gerçeği zorlar 1.
• 2ve 3açıktır.
• Çünkü ll{lll{[, ilk önce lyığının 0uzunluğunu iter, ikincisi yeni yığımı iterek yeni uzunluğu iter 0, 1. {Döndüğü yığın pompalanması, sol 1ve 0. Üç tane daha lyığını getir 1, 0, 2, 3, 4. Sonra öne doğru {döner 1ve [yığıntaki ilk 1şeyi sifonlar 4.
• 5, 6, 7Ve 8çok ortada.
• İçinde !\t00=0g( \tbir sekmeyi temsil eder) !içinde sekmeyi atlar, sonra 00=iki sıfırı iter ve eşit olup olmadıklarını kontrol eder - öyleyse bir truthy elde ederiz 1. Başka iterek sonra 0, gbir pozisyonda karakterini alır 1,0karakter kodu ile sekmesi kodu, 9.
• akadar fher itme 10için 15sırasıyla (tahminen onaltılık güzel yapmak için).
• 44*iki 4saniye iter ve bunları birlikte çoğaltır 16.
• 'RA'Rve A(sırasıyla 82 ve 65) karakter kodlarını yığına iter , sonra %hesaplar 82 mod 65 = 17.
• 999-9--olarak değerlendirir 9 - ((9 - 9) - 9) = 18.
• "&F#"karakter kodlarını iter &, Fve #hangi, 38, 70ve 35sırasıyla. O zaman ,bölünmedir, öyleyse alırız 38 / (70 / 35) = 19.
• Sonunda, 1::a'yı iter 1ve iki kez çoğaltır, +almak için iki tanesini bir araya getirir 2; :+çoğaltır 2ve almak için kendisine ekler 4; almak +için kalan ekler ; sonra kopyalar ve iki kez ekleyerek sonuçlanır .15:+:+20

Bu,> <> ile mümkün olan maksimum puandır. Herhangi bir snippet, boş bir yığını boş olmayan bir yığına dönüştüren bir talimat içermelidir ve bunu yapabilen yalnızca 18> <> komut vardır (yani i, lrakamlar 0–9ve rakamlar a–f) ve ayrıca string modu. (Diğer tüm talimatlar ya boş bir yığına hiçbir şey yapmaz ><v^/\|_#x!{}r, ya da bir şeyi ve hataları açmaya çalışır ?.+-*,%=():~$@[]on&gp.) Dize kipine girme ya "da kullanır ', bu nedenle 18 + 2 = 20mümkün olan en fazla parçacık vardır.

Benden daha unprintables ile daha rahat iseniz, bu Jo Kral sayesinde 53 bayt mümkündür: 00=, iii((i-, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f, 2222***, !Xll$g, 11+::+:+:++, 'Y', "Z"nerede X, Yve Zkodları ile karakterleri yerleştirilir 17, 19ve 20sırasıyla.

MathGolf , 48 51 53 tam sayı, 324 bayt

î
ª∞~
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 
♣(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((

@Maxb40 sayesinde +2 puan (ve kullanılan -2 ayrı bayt ) .

Her satır ayrı bir programdır.

Kullanılan bayt (92 farklı bayt): îª∞~c±b+φⁿ_¥-567○¢i♀/d²♂ABCDE☻FGHIJKLMNOPQRST♥UVWXYZ♫¼8]Σ41╔½π░3§2#τ╥└♦⌡!⌠'0$ÿ@£9)►◄╠•╠"h ♣(

Açıklama ve TIO bağlantıları:

MathGolf, matematiksel golf mücadelesinde uzmanlaşmış yeni bir golf dilidir. Sayılar için çok sayıda tek baytlık yerleşik yapısına sahiptir, bu da bunun için mükemmel bir meydan okumadır.

1) î: Döngünün 1 dizinli değerini, varsayılan olarak 1 olan itin: Çevrimiçi deneyin.
2) ª∞~: [1] e basın; iki katına ([2]); pop list ve içeriğini yığına itin: Çevrimiçi deneyin.
3) c±b±+: İtme -2; sonra pop ve mutlak değerini itin; itme -1; sonra pop ve mutlak değerini itin; ve onları bir araya ekleyin Çevrimiçi deneyin.
4) φⁿ_¥-: Altın oranı itin (1.618033988749895); küp küp (4.23606797749979); yığının tepesini çoğaltın; modulo 2 (0.23606797749979) alır; onları birbirlerinden çıkarın: Çevrimiçi deneyin.
5,6,7) Sayıların kendileri: Çevrimiçi deneyin. Çevrimiçi deneyin. 9) : İtme -3; squared: Çevrimiçi deneyin.
8) ○¢i♀/: 2048 itin; onaltılık bir dizgeye (800) dönüştürmek; tamsayıya dökmek; 100 itin; bölmek:
d² 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,36,37,38) Sayıların kendileri için yerleşik yapılara itin ( ♂ABCDE☻FGHIJKLMNOPQRST♥UVWXYZ): Çevrimiçi deneyin.
39) ♫¼¼¼¼: 10000 itin; tamsayı-4, dört kez bölünmüş: Çevrimiçi deneyin.
40) 88888]Σ: 8'e beş kez basın; onları bir listeye sarın; bu listeyi toplayın: Çevrimiçi deneyin.
41) Sayının kendisi: Çevrimiçi deneyin.
42) ╔½½½½½½½½½½½: 86400'ü itin; tamsayı-on iki kez bölünmüş: Çevrimiçi deneyin.
43) π░3§3: PI’ye basma (3.141592653589793); dizeye döküm; pop-up ve üçüncü 0 indeksli karakterini (4) itin; itme 3; birlikte yığılmış tüm yığınının çıktısını alın: Çevrimiçi deneyin.
44) Çevrimiçi deneyin. 48)22#22#: 2'ye iki kez basın; ikisinin gücünü almak (4); Tekrar yap; birlikte yığılmış tüm yığınının çıktısını alın: Çevrimiçi deneyin.
45) τ╥└: Push 2 x PI (6.283185307179586); pop ve 2 en yakın olanın gücünü itmek (4); yığının (1) üst kısmını (5) çarpmadan itin; birlikte yığılmış tüm yığınının çıktısını alın: Çevrimiçi deneyin.
46) ♦⌡⌡⌡⌡⌡⌡⌡⌡⌡: İtme 64; 2 kez 9 azaltma: Çevrimiçi deneyin.
47) !⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠: İtme gama (n + 1) (varsayılan olarak 1); 2 yirmi üç kat artırma::
'0$: '0' karakterinin sıra değerini itin: Çevrimiçi deneyin.
49) ÿ@@@@£9: Basma ipi "@@@@"; popunu ve uzunluğunu (4) itin; itme 9; birlikte yığılmış tüm yığınının çıktısını alın: Çevrimiçi deneyin.
50) )))))))))))))))))))))))))))))))))))))))))))))))))): 1 elli katına kadar artış: Çevrimiçi deneyin.
51) ►◄╠•╠: 1.000.000 itin; 10.000.000 itin; ikisini de patlatın ve tamsayıları birbirleriyle bölün (10); itme 512; her ikisini de aç ve tamsayıları birbirleriyle böl: Çevrimiçi olarak dene.
52) "hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh"h : Basma ipi "hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh"; uzunluğunu itmek (ipi çıkarmadan); son öğe dışındaki her şeyi yığından kaldır: Çevrimiçi deneyin.
53) ♣(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((: 128 itme; 1 yetmiş beş kez azaltıldı: Çevrimiçi deneyin.

Daha sonra biraz daha eklemeye çalışacağım. Hala modulo %ve çoğalmak gibi bazı yararlı şeylerim var *.

Java 8, 11 12 13, 39 bayt

Java sadece sayıların (0-9) için 10 sembolüne sahiptir ve tüm yöntem çağrıları ve sabitleri bir süre gerektirir, bu yüzden 11 çıktının üzerine çıkabileceğimden emin değilim.

Görünüşe göre, işlemler uygulandığında varsayılan olarak tamsayılara karakter gönderme

OlivierGrégoire yardımı ile +1

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

açıklamalar:

i->-~i

giriş almayan ve döndüren 1 tamsayı lambdası 1. Bir parametre giriş almadığında, varsayılan değer, tamsayılar için 0 olan yukarıdaki meta gönderiye göre kullanılır.

2
3
4
5
6
7
8
9

değişmez tam sayılar

'P'^'Z'

10 karakter döndüren iki karakterden oluşan XOR

11

değişmez tam sayı

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

12 karakterli bir dizgenin uzunluğunu döndüren lambda ifadesi

0xD

Onaltılık 13

Doğrulamak istiyorsanız TIO Link .

Gaia , skor 25, 203 bayt

§‼
..⌉+⌉
₵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₈×
ℍḥḥ

Bunu mükemmel bir skor olarak görüyorum, çünkü karakter kısıtlamaları göz önüne alındığında daha fazla nila kullanılamaz.

açıklamalar

1. §‼

§boşluk karakteri, ‼boolean için zorlamadır, dolayısıyla sonuç 1'dir.

2. ..⌉+⌉

.kısayol 0.5, yani bu ceil(0.5+ceil(0.5)).

3. ₵P~~

₵Ppi, ~bitsel olumsuzlamadır. Çifte bitli olumsuzlama sadece kısaltmadır.

4. 4

5. 5

6. 6

7. ∂Ql

∂Qhaftanın günlerinin adlarını içeren bir listedir l, uzunluktur.

8. 8

9. 9

10. ¶c

cSatır kodunun kod noktası ¶.

11. 11

12. '¡ċ⌋u⌋

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

13. --⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻

-için bir kısaltmadır -1, ⁻çıkarma olduğunu. Yani bu -1 - -1 - -1...13 yapmak için yeterli zamandır.

14. 7:,Σ

İtin 7, çoğaltın :, ,iki 7'yi bir listeyle eşleştirin ve toplayın Σ.

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

Øboş bir dizedir, yani Ø!1'dir. Artış )1 14 kez.

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. ⟩‘

Bir dizgiyi kapatmak, ‘250 sayısının temelini oluşturur. ⟩Gaia'nın kod sayfasındaki bayt değer 17'de.

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

Her biri ]yığını listeye sarar. Bunu 19 kez yapın ve nlistenin derinliğini alın .

20. ⇑’e

Bir dizeyi kapatmak ’, kod sayfası kod noktalarının bir listesini yapar. eListeyi yığına atar. ⇑kod sayfasında 20 kod noktası vardır.

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

Azalma (0 21 kez ardından etkisiz hale _.

22. 22

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

“B”Dizeyi, 0-23 arasındaki rakamların bulunduğu taban 24'ten dönüştürün ↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺B. Sonucudur 23.

24. 3₈×

3 × 8.

25. ℍḥḥ

100 ℍyarı yarıya ḥve tekrar yarı yarıya.

C, 13 puan

Bunlar sadece bir sürü tamsayı sabiti.

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==01 olarak değerlendirir
2. Kod satır 2'de olduğunu varsayar. __LINE__= 2
3. Tam sayı sabiti
4. Tam sayı sabiti
5. Tam sayı sabiti
6. Tam sayı sabiti
7. Tam sayı sabiti
8. Tam sayı sabiti
9. Tam sayı sabiti
10. 1+1+1...= 1*10= 10
11. 'o'111, '.'yazdırılamayan ASCII 0x10'u temsil eder. 111/10 = 11
12. (2<<2)= 8, 8*2= 16, 16-2-2= 12
13. dize uzunluğu "strlenstrlens"= 13

Ohm , skor 21 22, toplam bayt

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

Çevrimiçi deneyin!

açıklamalar

1. ╓S@Ri

Geçerli tarih / saatin saniyelerine basın ( ╓S). Kapsayıcı aralığı 1 - saniye ( @) alın, ters çevirin ( R), iher zaman 1 olan son elemanı ( ) alın.

2. ΓΓ-Γ-Γ-

Γ -1 olduğu için, bu (-1) - (-1) - (-1) - (-1), ki bu 2'dir.

3. αê⌠

αêEuler'in numarası (2.71828 ...) ⌠tavandır. Sonuç 3.

4. ¡¡¡¡¼

¡sayacı artırır, sayacı ¼iter.

5. 5

Sadece bir edebi.

6. ▀lll▀l

▀lll▀eşittir bir sıkıştırılmış dize değişmezidir "of >ic". luzunluğu alır, sonuç 6 olur.

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

İlk önce 7 newline chars ( Ñ) ve sonra boş bir string ( ÿ) basarız . Yığın bir diziye ( W) sarılır ve ardından bu dizideki boş dizenin dizini bulunur.

8. ü`½½

üboşluk karakteri. `ASCII değerini (32) zorlar, ardından iki kez yarıya düşer ( ½½).

9. 9

Sadece bir edebi.

10. ..≥°

..değişmez bir .karakter. Artar ( ≥), dizeyi sayı olarak ayrıştırır, geçerli bir sayı olmadığından 0 olarak varsayılandır ve 1 değerine yükseltir. Sonra 10 ¹ ( °) değerini hesaplarız .

11. $$J

$ Yazıcının geçerli değerini, başlangıçta 1 iter. Bu nedenle, 1'e iki kez basın, yığını birleştirin ve yazdırın.

12. 3dd

3 düğmesine basın ve iki kez ikiye katlayın.

13. 7ƒ

7. Fibonacci numarasını iter.

14. 2≡≡≡Σ

2'ye bastırın, üç kez kopyalayın, yığında 7 2 kaldı. Sonra yığının ( Σ) toplamını alın .

15. ║F

║temel 220 sayı değişmezleri için sınırlayıcıdır. Bu bir satırın sonunda olduğu için sonlandırılması gerekmez.

16. 4º

2 ^4'ü hesapla .

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

òbitsel olumsuzdur, ~aritmetik olumsuzdur. Bu operatörleri birleştirerek 0 17 kat artırabiliriz.

18. 6DD++

6'ya basın, iki kez kopyalayın ve 6 + 6 + 6'yı hesaplayın.

19. 8π

8. asal sayıya basın.

20. τ╛hτ*

10 ( τ) düğmesine basıp h, asal çarpanlarının ( ╛) ilk öğesini ( ) alın, bunu 10 ile çarpın.

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

Önceki snippet'lere benzer şekilde, dize "≤"0 olarak ayrıştırılır. Bunu 21 kez azaltır, sonra mutlak değeri alırız.

22. 1111 11v11%L1111 11v11%L

Burada 1111 div 11 mod 11'i hesaplıyoruz, bu sayı 2, sonra baskı 2. Sonra tekrar yapın.

PowerShell, skor 12, 91 bayt. 14, 176 bayt

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

Düzenle:

• Ørjan Johansen'e, onaltılık literal 0xd'yi 13 için önerdiğin ve seçenek olarak 1 + 1 + 1 + 1 .. 'in serbest bırakılması için 5'in yeniden düzenlenmesini önerdiği için teşekkürler.
• Dizgi uzunluğunu dize uzunluğuna değiştirdi, [int] - [byte] ve hashtable'ları değer olarak kullanmak için harmanlanabilir, (),""Pondering 15'i benzer bir şeyle serbest bırakarak "ZZZZZZZZZZZZZZZA".InDeXof("A")ancak nokta veya 'e' yi tekrar kullanamazsınız ..

PowerShell $ olmadan değişken yapamaz, üstelik üsteleme, bit kaydırma, Pi, ceil (), vb. Gibi temel simgeleri kullanamaz ve çoğunlukla zorlayıcıyı bool'dan ve booldan / sayılara kadar zorlayıcı yazar. Düşük sözdizimi sayı üretimi için nispeten az kapsam var.

TI-Basic (83 serisi), skor 21 22 23 24 25 (1003 bayt)

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

Bakın http://tibasicdev.wikidot.com/one-byte-tokensBuradaki zorlukların neler yapıp yapamayacağının listesi .

Bunların tümü bir programın son satırı otomatik olarak yazdırıldığından, tamamlanmış programlar olabilir. Ancak (birden fazla satır uzunluğundaki 17 hariç) ana ekranda pasajlar da olabilir.

Bu noktada, benim hemen başka bir yol bkz herhangi mevcut kalan jeton dışarı sıfırdan farklı bir değer. Yapılması gereken herhangi bir gelişme varsa, önce çözümlerin bir kısmını daha tutucu hale getirmeyi de içermesi gerekir.

açıklamalar

• A=Abir boolean 1'dir, çünkü değişken Akendisine eşittir.
• Bvarsayılan olarak 0'dır tan(tan(cos(cos(cos(B, yaklaşık 2.21'dir ve ardından zemini alıyoruz.
• C!°radyan cinsinden 1 derece, yaklaşık 0.017'dir. Bunun bir miktar pozitif gücü tanh (2), yaklaşık 0,964'tür. İkili olarak bu gücü zımni çarpım kullanarak kodlar √(ve sonratanh⁻¹( .
• 4 basittir
• cosh(sinh⁻¹(X basitleştirir$\sqrt{1+X^2}$
• 6-9 basittir
• ₁₀^( 10, ve 10 ^ 10 ^ 0 = 10 ^ 1 = 10 yetkileri için bir baytlık yerleşiktir.
• 11 11.
• F nPr Fsin(tan⁻¹(X$\frac{1}{\sqrt{1+1/X^2}}$
• G≤G1 [[G≤G]...[G≤G]]olduğu için 13x1 sütun vektörüdür. Transpozisyonunun ürününü kendisiyle birlikte almak [[13]], determinantı 13 olan matrisi verir .
• not(H)1'dir tanh(not(H)). 0 veya 1'e eşit olmayan bir ln(XXX....X)ln(X)^⁻1sayıdır Xve ilk günlüğün içinde X0 olmaması koşuluyla (günlüğün var olması için) ve 1 değil (böylelikle bölmemek için) sayısını basitleştirecektir. 0 ile).
• e^(e^(e^(F yaklaşık 15.15 olarak değerlendirir ve sonra zemine gireriz.
• J≥J1'dir. identity(1x1 özdeşlik matrisi oluşturur, dim(satır ve sütun boyutlarını bulur ve sum(bunları elde etmek için 2 ekler. Sonra bunu tekrar yaparız, 4'e 2x2 matrisin boyutlarını ekler ve tekrar 4x4 matrisin boyutlarını ekleriz 8 almak ve tekrar, 8 almak için 8x8 matrisin boyutları ekleyerek 16.
• K nCr K binom katsayısı 0, 0 veya 1'dir.
• i-i-...-i18i için basitleştirir ve abs(18 alır.
• rand→LL'ye rasgele bir gerçek sayı saklar, fakat ne olduğu umurumda değil. log(L)⁻¹log(L^19)19'a basitleştiren hesaplama yapıyoruz .
• sinh(sinh(cos⁻¹(I4'ten biraz fazla olduğundan , aritmetik ortalaması 20 olan seq(III,I,I,sinh(sinh(cos⁻¹(Ilisteyi verir {0 1 8 27 64}.
• Püf noktasının bir başka örneği 3 almak için kullanılır. Burada, bir güç πvermeli 21; Bu gücü üçlü olarak ima ettiğimiz çarpım ve ³√(.
• 22, 22.
• Püf noktasının bir başka örneği de 3 ve 21 elde etmek için kullanılırdı. Üçlü 3×√(olarak 23'e eşit olan ve küp kökü olarak ve (çarpma için kullanılan 3'ün gücünü kodladık .
• Fix 0ondalıktan sonra 0 basamağı gösterme ayarıdır, tüm değerleri tamsayılara yuvarlamadır. sin⁻¹(ᴇ0π / 2 olarak değerlendirir ve π / 2 7 ile çarpılır ve bu değer 24'e yuvarlanır, yaklaşık 23.59 olur.
• 5*525'tir ( 55 almak için kullanmak daha uygun olur ve orada kullanılan çözümü 25'e uyarlar. Ancak bu şekilde çok fazla alan kazandırır ve *ima edilen çarpımın olması nedeniyle çok kullanışlı bir karakter değildir.)

SOGL , skor 16 18 20, 109 bayt, 47 karakter kullanılmış

=                    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 tam sayı, 86 bayt

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

Çevrimiçi deneyin!(Giriş, hangi programın çalıştırıldığını kontrol eder, 1'den N'ye)

açıklama

                       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

Jöle , skor 22, 177 bayt

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

Tümünü bir kerede deneyin veya Bir seferde bir tane deneyin (bağımsız değişken hangi çıktıyı istediğiniz).

Kullanılmayan karakterler:

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

Reng, skor 40, 149 bayt

Burada dene!

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

Tüm büyük harfler rakamdır, yani bu çok hoş. Bunların ikisi dışında hepsi pasajlardır. İki program:

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

Sağlanan bağlantı, çalışırken yığını görmeye izin verir. Daha sonra bir açıklama yazacağım.

CJam, skor 27, 168 bayt

1-3: X , Y,Z

Değişkenler X, YveZ sırasıyla 1, 2 çalıştırılır ve 3 vardır.

4: ",,,,",

İpi itin ,,,,ve uzunluğu alın.

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

Sayısal değişmezler.

10-20 : A-K

Önceden başlatılmış değişkenler.

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

Değişken U, başlatıldı 0. İtip U22 kez arttırın.

22: 22

Sayısal hazır bilgi.

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

Karakteri itin ve ;almak için 9 kez azaltın 2, ardından ;tekrar itin ve almak için 8 kez azaltın 3.

24: 4m!

4 faktoringini alın.

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

TT=iter 1. Bu kod eşdeğerdir 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-

NYeni satır içeren bir dize iter. :ionu veren karakter kodları listesine dönüştürür [10]. ~paketini açarak, vererek 10. W-eklemeye eşdeğerdir. 10 on altı kez artırmak 26 verir.

27: LLLLLLLLLLLLLLLLLLLLLLLLLLL0]0#

0'ın 27'inci dizinde olduğu listede 0 dizinini bulun.

Karakterler hala mevcut: $%&*./1<>?@MOPQRSV[\^_`abcdefghjklmnopqrstuvwxyz{|}

Potansiyel genişleme için birkaç not:

• Değişkenleri başka bir şey için kullanmak için 10-20'yi değiştirmek zorunda kalabilirim. 1'den daha büyük sayılar *alırsam , kullanabilirim (ve muhtemelen bitsel operatörler, ancak çok yardımcı olacaklarını sanmıyorum).

• Hala S, bana ne yapacak olursa olsun.

• Eğer 26'yı değiştirirsem N{}/iW-W-W-W-W-W-W-W-W-W-W-W-W-W-W-W-, :müsait olur.

• Bazı boş listeleri zorlayabilir ve mevcut değişkenlerle daha fazla sıfır alabilirim. Ayrıca π alabilirim, ancak bir şekilde bir tamsayıya m(ve m[) alıp izaten alınmış olmadıkça, bu pek kullanışlı görünmüyor .

• Dizi manipülasyonu açısından şunları yapabilirim:

  • %Veya ile bir harita kullanınf
  • İle bir kat kullanın *
  • Bazı ayar işlemleri yapın
  • Temel dönüşüm (bu umut verici görünüyor, ancak temel numarayı nasıl alacağımı bilmiyorum)
  • Dizileri kullanarak |şunları yapın:M1|2|3|

Haskell , skor 13, 86 bayt

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

Çevrimiçi deneyin!

On üçüncünün puanını korurken, benim üst üste yazmamı düzeltmek için bir yol bulduğu için Ørjan Johansen'e teşekkür ederim. (Ayrıca bu cevap silinirken beni bu konuda bilgilendirmek için kendi yolumdan gittim.)

pi/piolduğunu 1.0. , için ve için
sum[]değerlendirir . için sadece kendilerini deşifre. dize uzunluğu verir, ki . olduğunu . için onaltılıktır .00^01sum[1,1]239
length"eeeeeeeeee"10
2+2+2+2+2+212
0xD13