Herausforderung:

Ihre Aufgabe ist es, so viele Programme / Funktionen / Schnipsel wie möglich zu schreiben, wobei jedes eine ganze Zahl ausgibt / ausgibt / zurückgibt. Das erste Programm muss die Ganzzahl ausgeben 1, das zweite 2und so weiter.

Sie können keine Zeichen zwischen den Programmen wiederverwenden. Wenn das erste Programm also: lautet x==x, dürfen Sie die Zeichen nicht xund =in keinem der anderen Programme erneut verwenden. Hinweis: In einem Programm darf ein Zeichen mehrmals verwendet werden.

Wertung:

Der Gewinner ist die Einsendung, die am höchsten zählt. Bei Stimmengleichheit gewinnt die Einsendung, die insgesamt die geringste Anzahl von Bytes verwendet hat.

Regeln:

• Sie können nur eine Sprache für alle ganzen Zahlen verwenden
• Schnipsel sind erlaubt!
• Damit es fair bleibt, müssen alle Zeichen mit einem einzigen Byte in der von Ihnen gewählten Sprache codiert werden.
• Die Ausgabe muss dezimal sein. Sie können es möglicherweise nicht mit wissenschaftlicher Notation oder einem anderen alternativen Format ausgeben. Die Ausgabe von floats ist in Ordnung, solange alle Ziffern hinter dem Dezimalpunkt angezeigt werden 0. Also 4.000wird angenommen. Ungenauigkeiten aufgrund von FPA werden akzeptiert, sofern sie nicht in der Ausgabe angezeigt werden.
• ans =, führende und nachfolgende Leerzeichen und Zeilenumbrüche usw. sind erlaubt.
• Sie können STDERR ignorieren, solange die korrekte Ausgabe an STDOUT zurückgegeben wird
• Sie können die Ganzzahl in STDERR ausgeben, jedoch nur, wenn STDOUT leer ist.
• Symbolunabhängige Sprachen (z. B. Lenguage ) sind nicht zulässig
• Buchstaben unterscheiden zwischen Groß- und Kleinschreibung a != A.
• Die Programme müssen unabhängig sein
• Leerzeichen können nicht wiederverwendet werden
• Sie müssen in der Ausgabe ASCII-Ziffern verwenden

Erklärungen sind erwünscht!

JavaScript (ES7), Punktzahl 17, 176 Bytes

Sie sagten, es könne nicht gemacht werden, also habe ich es getan: D (dank der großen Hilfe von @FullDecent)

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

Unbenutzte Zeichen:

#&,:?@ABDGHIJKLMOPQRTUVWYZ\_bcdfijkmopqrsuvwyz|

Ich glaube nicht, dass 18 möglich ist, aber ich sagte dasselbe über 17 ...

Erläuterung

JavaScript ist eine sehr schwach typisierte Sprache. Wenn Sie versuchen, eine mathematische Operation mit einem Wert auszuführen, der keine Zahl ist, wird JS sein Bestes tun, um ihn zuerst in eine Zahl umzuwandeln. Dies ermöglicht viele interessante Lösungen. Ich habe versucht, die Ziffern so weit wie möglich zu vermeiden, damit sie später verwendet werden können.

1. **ist der Exponentiationsoperator in ES7. Wird die leere Zeichenkette zu einer Zahl gezwungen 0, so berechnet dies 0 ** 0, was 1laut JavaScript ist.
2. Ein bisschen lächerlich, aber es funktioniert. /~/ist ein Regex-Literal und ~/~/kehrt zurück -1. Dies ist also ~(-1 / -1) / -1= ~(1) / -1= -2 / -1= 2. ( Dank an @ GOTO0 für die Idee)
3. Einfach 3.
4. Jetzt einfach 4.
5. NaNist falsch, also !NaNist truedas äquivalent zu 1. Der Ausdruck wird also 1 - -1 - -1 - -1 - -1= 1 + 1 + 1 + 1 + 1= 5.
6. Einfach 6.
7. Einfach 7.
8. Einfach 8.
9. Einfach 9.
10. Dies nutzt ein wenig JSF *** Magie. +[]is 0gibt also [[]][+[]]das erste Element von [[]](d. h. []) zurück und ++erhöht dieses auf 1. Dann +[+[]]fügt man das Array hinzu [0], das zu einer Zeichenkette gezwungen wird und macht "10".
11. Einfach 11. Ich hatte ursprünglich 11&1111für 3 und 33/3für 11 verwendet, bis mir wieder klar wurde, wie dumm ich bin ...
12. Diese Strategie würde für jede Zahl funktionieren: Erstellen Sie eine Zeichenfolge mit einer bestimmten Länge 12und verwenden Sie sie .length.
13. Ich habe nur eine Weile mit 2s und >s rumgespielt, um dieses zu bekommen. Ich hatte wieder Glück: 222 >> 2ist 55und 55 >> 2ist 13.
14. Dieser ist ziemlich knifflig. Die Grundidee ist, 14in hex ( 0xE) zu erstellen , aber wir brauchen die Ziffer 0woanders. Stattdessen stellen wir das Ergebnis von ``^``der Zeichenfolge voran xE. Die leere Zeichenfolge, die zu einer Zahl gezwungen wird 0, ist 0 ^ 0= 0. Dann wird das Ergebnis mit der leeren Zeichenfolge XOR-verknüpft, wodurch beide Werte in Zahlen umgewandelt werden. "0xE" ^ ""ist 14.
15. Das ist jetzt ganz einfach: 0XFIst ein hexadezimales Literal mit einem Wert von 15.
16. Das schwierigste von allen? Zuerst setzen wir die Variable Cauf CSS == CSS(also true). Dann nehmen wir das Ergebnis und führen es << Cviermal aus, was im Grunde genommen mit multipliziert 1wird 2 ** 4.
17. JavaScript verliert ab 2 ⁵³ an Ganzzahlgenauigkeit , wodurch 555...555%55eine Zahl zurückgegeben werden kann, die nicht 0oder ist 5. Ich hatte sehr viel Glück, als ich hier herumspielte.

Strategien, die mit vielen Zahlen funktionieren würden:

• -!NaNwürde auf jeder Nummer funktionieren (derzeit 5), obwohl es sehr schnell groß wird.
• ~/~/würde auf jeder Nummer funktionieren (derzeit 2), obwohl es sehr schnell sehr groß wird .
• +[]würde auf jeder Nummer funktionieren (derzeit 10), obwohl es auf 10oder bei weitem am einfachsten ist 11.
• .length würde auf einer beliebigen Zahl arbeiten.
• `${-``}xE`-`` würde auf so ziemlich jeder Zahl arbeiten, wenn Sie es richtig machen.
• C<<Cwürde mit jeder Potenz von zwei (derzeit 16) oder mit jeder Int überhaupt funktionieren , wenn Sie sie einschließen |.

Jelly , 47 ganze Zahlen, 519 Bytes

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

Jede Zeile ist ein eigenes, vollständiges Programm.

Probieren Sie es online! (Beinhaltet Testsuite und Kreuzungsprüfer)

Wie es funktioniert

Jedes vollständige Programm ohne Befehlszeilenargumente führt seine Hauptverknüpfung (in der letzten Zeile definiert) niladisch aus, dh ohne Eingabe. Wenn das erste Glied in der Kette ein Nullglied ist, wird es verbraucht und aufgerufen, und sowohl das Argument des Hauptglieds als auch der Rückgabewert werden auf das Ergebnis gesetzt. Wenn das erste Glied in der Kette eine Monade oder eine Dyade ist, wird es nicht verbraucht und stattdessen das implizite Argument und der Rückgabewert 0 verwendet. In beiden Fällen wird der Rest der Kette monadisch ausgeführt.

Gelee zerquetscht seine Ausgabe in mehreren Fällen. Insbesondere wird ein Singleton-Array ohne die umgebenden Klammern gedruckt, sodass 42 und [42] und nach dem Drucken nicht mehr zu unterscheiden sind. Wir werden dies bei mehreren Gelegenheiten verwenden.

1 - 10

e

Das Exists- Atom prüft, ob der Rückgabewert 0 zum Argument 0 gehört . Er tut, so egibt 1 .

BI$⁼#

BI$ist ein Quicklink, insbesondere eine monadische Kette, die durch die schnelle $Gruppierung des binären Atoms Bund des inkrementalen Atoms gebildet wird I. Zusammen konvertieren sie eine Ganzzahl in das Array ihrer Ziffern in Basis 2 und berechnen dann die Vorwärtsdifferenzen der resultierenden Ziffern. Wenn das Array nur ein Element enthält, gibt es keine Vorwärtsunterschiede und es wird Iein leeres Array (falsch) zurückgegeben. Wenn es mindestens zwei Ziffern Igibt, wird ein nicht leeres Array zurückgegeben (truey).

Der Schnellzugriff verwendet #den vorherigen Schnellzugriff und wendet ihn auf 0 , 1, 2, ... an, bis genügend Übereinstimmungen gefunden wurden, und gibt das Array der Übereinstimmungen zurück. Der erforderliche Betrag wird berechnet durch ⁼, der den Rückgabewert / das Argument 0 mit sich selbst vergleicht und 1 ergibt . Somit gibt das gesamte Programm [2] zurück , die erste nicht negative Ganzzahl mit zwei Ziffern in Basis 2.

⁾⁾⁾Ụ^/

⁾⁾⁾ist ein String-Literal, insbesondere der String ⁾⁾ . Das Grade-Up- Atom Ụsortiert seine Indizes nach ihren entsprechenden Werten. da beide Zeichen gleich sind, ergibt sich [1, 2] . Das resultierende Array wird mit bitweisem XOR verkleinert ^/, sodass das gesamte Programm 3 zurückgibt .

ı***ıḞḞ

ıInitialisiert das Argument und gibt den Wert an die imaginäre Einheit i zurück . *ist die Potenzierungs- Dyade, deren rechtes Argument standardmäßig das Argument des Hauptlinks ist. ***ıBerechnet also ((i ⁱ ) ⁱ ) ⁱ ≈ 4.81 + 0i , berechnet das ḞAtom ( Boden für reelle Argumente, Realteil für komplexe) den Realteil ( 4.81 ) Ḟund ergibt dann Etagen 4 .

5
6
7

Diese drei Programme bestehen aus einem einzigen Literal und tun genau das, was Sie erwarten.

.::::

Das Literal .ist eine Abkürzung für 0.5 und initialisiert Argument und Rückgabewert. Das rechte Argument des Ganzzahlteilungs- Dyads ( :) entspricht standardmäßig dem Argument für die Hauptverknüpfung. ::::Berechnet also 0,5 / 0,5 / 0,5 / 0,5 / 0,5 und ergibt 8 .

9

Noch ein wörtliches Wort.

EȮ<

Das Atom all equalE gibt 1 zurück, wenn alle Elemente in seinem Argument gleich sind, und 0, wenn nicht. Ein ganzzahliges Argument z wird zu [z] heraufgestuft , daher Ewird 1 für das implizite Argument 0 zurückgegeben .

Nun werden die Ausgangsatom druckt 1 bis STDOUT. Wir vergleichen dann 1 mit dem impliziten Argument 0 unter Verwendung des Atoms less than . Das Ergebnis ist (1 <0) = 0 und wird implizit gedruckt, wenn das Programm beendet ist.Ȯ<

11 - 20

⁻GṘ

Das Gitteratom versucht , eine optisch ansprechende Tabelle von seinem Argument zu machen. Für ein einfaches ganzzahliges Argument (hier: 0 ) wird es einfach in ein Array eingeschlossen. Das flache ungleiche Atom vergleicht das implizite Argument 0 mit dem Ergebnis rechts ( [0] ) und ergibt 1, da seine Argumente nicht gleich sind. Die Darstellung Atom druckt 1 bis STDOUT und gibt sein Ergebnis. Am Ende des Programms wird der endgültige Rückgabewert implizit gedruckt, sodass wir eine Ausgabe von 11 erhalten .G⁻Ṙ

=`p`VV×`DQV

Das Selbst` verwandelt eine Dyade schnell in eine Monade, indem es sie mit identischen linken und rechten Argumenten aufruft. Zuerst =`vergleicht die implizite Argument 0 mit sich selbst, wodurch man 1 .

Das kartesische Produkt Atom perwartet Listen als Argumente, so fördert die ganze Zahl 1 auf den Bereich [1, ..., 1] = [1] . p`nimmt das kartesische Produkt von [1] und sich selbst und ergibt [[1, 1]] .

Das eval- Atom Vwandelt alle flachen Arrays (die nur Zahlen und Zeichen enthalten) in Strings um und wertet die resultierenden Strings als Niladic Jelly-Programme aus. [[1, 1]] wird zuerst in ["11"] umgewandelt , dann Vwird die Zeichenfolge ausgewertet und ergibt [11] . Noch einmal, Vmacht dieses Array in „11“ , dann evals es ergeben 11 .

Nun ×`multipliziert man 11 mit sich selbst und erhält 121 . Das Dezimalatom verwandelt 121 in [1, 2, 1] , das eindeutige Atom Qverwirft die zweite 1 und Vverwandelt erneut eine Ziffernliste in die Ganzzahl, die sich aus ihrer Verkettung ergibt, und gibt 12 zurück .

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

~ist das bitweise NICHT Atom. Mit der Zweierkomplementarithmetik bildet es ein Argument z auf ~ z = - (z + 1) ab . Aist das Absolutwertatom , es bildet also - (z + 1) = z + 1 ab . Mit dem anfänglichen Rückgabewert 0 , der dreizehn Kopien ~ARückkehr 13 .

⁷ṾṾṾw

Die Konstante ⁷enthält das Newline-Zeichen '\ n' und initialisiert das Argument und den Rückgabewert.

Das unevale Atom Ṿversucht, eine Zeichenfolgendarstellung seines Arguments z zu erstellen, sodass ein Jelly-Programm, das aus diesem Code besteht, z zurückgibt .

Der erste Aufruf gibt pflichtgemäß die Zeichenfolge "" \ n "zurück , die ein Zeichenliteral ist. Der nächste Aufruf gibt "", "\ n" zurück - ein Paar Zeichenliterale. Der dritte und letzte Aufruf gibt "", "", ",," "," \ n "zurück - ein Fünffach der Zeichenliterale.

Schließlich ist der Fensterindex Atom wfördert sein rechtes Argument ‚\ n‘ auf die Zeichenkette „\ n“ und den ersten Index mit einem Teilausgang finden „\ n“ . Dies ergibt 14 .

⁴ḟ€⁴Ṁ

⁴ist die Konstante 16 . Der Quicklink- Filterfalse each ( ḟ€) befördert sein linkes Argument 16 in den Bereich [1,…, 16] und durchläuft dann seine Elemente.

Für jedes Element Z , ḟ⁴ausgeführt wird , zuerst die Förderung z zu [Z] , dann werden alle Entfernen (falls vorhanden) Vorkommen von 16 . Dies ergibt das Array [[1], [2],…, [14], [15], []] , wobei das letzte Array leer ist, weil es 16 enthält .

Schließlich wählt das maximale Atom [15] .Ṁ

mmmmċ

Das modulare Atom, mdas mit den Argumenten x (Array) und y (Integer) aufgerufen wird, nimmt normalerweise alle | y | x- ^tes Element , beginnend mit dem ersten, wenn y> 0 , mit dem letzten, wenn y <0 . Wenn jedoch y = 0 ist , wird x mit seiner Umkehrung verkettet zurückgegeben.

Das linke ganzzahlige Argument 0 wird zuerst zu [0] heraufgestuft . Die erste Kopie von mverkettet [0] mit sich selbst und ergibt [0, 0] . Die verbleibenden Kopien wandeln dieses Ergebnis in [0, 0, 0, 0] , dann [0, 0, 0, 0, 0, 0, 0] und schließlich [0, 0, 0, 0, 0, 0 , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] .

Zuletzt zählt das count- Atom, ċwie oft das implizite Argument 0 im resultierenden Array vorkommt, und gibt 16 zurück .

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

ṭist das Tack- Atom und hängt sein linkes Argument an sein rechtes an. Da ṭund die folgenden ḍdyadisch sind, müssen alle Aufrufe ṭdas implizite Argument 0 als das richtige Argument übergeben ṭ. Der erste Aufruf gibt [0, 0] , der zweite [0, [0, 0] und der achte und letzte [0, [0, [0, [0, [0, [0, [0, [0, 0]]]]]]] .

ḍist das Teilbarkeitsatom ; Für die Argumente x und y wird 1 zurückgegeben. Ist dies nicht der Fall, ist x durch y teilbar und 0 . Ḅist ein No-Op für Ganzzahlen, also ḍḄtestet 0 auf Teilbarkeit durch jede Ganzzahl im konstruierten Array. 0 ist für sich teilbar, daher erhalten wir [1, [1, [1, [1, [1, [1, [1, [1, 1]]]]]] .

Das unbinäre Atom bearbeitet nunḄ flache Arrays. Für ein Paar [a, b] wird einfach 2a + b zurückgegeben . Wie bereits erwähnt, Ḅist ein No-Op für ganze Zahlen: Ein ganzzahliges Argument c wird zu [c] heraufgestuft , und [c] in einer beliebigen Basis ist einfach c .

Der erste Aufruf von Ḅreduziert [1, 1] auf 3 und ergibt so [1, [1, [1, [1, [1, [1, [1, 3]]]]] . Der nächste Aufruf reduziert [1, 3] auf 5 , der nächste [1, 5] auf 7 usw., bis der neunte 17Ḅ zurückgibt .

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

Ṇist das flache logische NICHT- Atom und ordnet das implizite Argument 0 zu 1 zu . +Ist das Additionsatom, so +Ṇerhöht jede der achtzehn Kopien den vorherigen Rückgabewert (anfangs 0 ). Das gesamte Programm gibt also 18 zurück .

CNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNC

Cist das Komplementatom und bildet sein Argument z auf 1-z ab . Nist das Negieren Atom und ordnet ihr Argument z auf -z . Zusammen CNbildet z zu - (1-z) = z-1 , so dass die achtzehn kopiert das implizite Argument dreht 0 in -18 . Eine endgültige Anwendung der CAusbeuten 1 - (-18) = 19.

ĖḌĖḌ

Das Aufzählen Atom Ėaufzählt die Elemente in einem Array - Index-Wert - Paare zu schaffen. Das implizite Argument 0 wird zu [0]Ė heraufgestuft und ergibt dann [[1, 0]] . Das Undezimalatom wandelt ein flaches Array von der Basis 10 in eine Ganzzahl um, was in diesem speziellen Fall [10] ergibt .

Der zweite Aufruf von Ėtransformiert [10] in [[1, 10]] , den der zweite Ḍschließlich in [20] umwandelt .

21 - 30

ṫṣȦJṫȦ⁸ȦJ

Der Schwanz Atom ṫ(a Dyade) Wählen Sie die Postfix seiner linken Argument , das auf dem Index beginnt (1-basiert und modular) in ihrer rechten Argument angegeben, ein linkes Argument ganzzahligen Förderung x zu [x] . Wenn sie mit den beiden Argumenten aufgerufen auf 0 , ṫkehrt [0] .

Das any-all- Atom Ȧgibt 1 zurück, wenn sein Argument wahr ist und in keiner Tiefe Nullen enthält, andernfalls 0 . Hier verwenden wir es einfach als Identitätsfunktion, um das implizite Argument 0 zurückzugeben . Die Aufteilung in Atome unterteilt ṣdas linke Argument [0] in Vorkommen des rechten Arguments 0 , sodass hier [[], []] zurückgegeben wird .

Das Atom IndizesJ verwirft die Elemente des Rückgabewerts und ersetzt sie durch ihre Indizes, was in diesem speziellen Fall den Bereich [1, 2] ergibt . Ȧund ṫbeide funktionieren wie zuvor, so dass sie [1, 2] auf das Postfix reduzieren , das am letzten Index beginnt und [2] ergibt .

In argumentlose Verbindungen, die konstant ⁸hält [] . Dies ist ein nicht zu analysierender Nilad, dh er passt in keiner Weise in die Kette. Infolgedessen wird der vorherige Rückgabewert ( [2] ) an STDOUT ausgegeben und dann durch den Wert des Nullwerts ( [] ) ersetzt.

Da [] falsch ist, wird Ȧes in 0 umgewandelt . Das JAtom befördert 0 auf [0] und gibt dann die Liste seiner Indizes ( [1] ) zurück, die implizit gedruckt wird, wenn das Programm beendet ist.

22

Noch ein wörtliches Wort. Repdigits scheinen der beste Ort zu sein, um sie zu verwenden.

“@ṃ»

Dies nutzt Jellys eingebaute Saitenkomprimierung. Die Indizes von @ und ṃ in Jellys Codepage sind 64 und 220, und Zeichenfolgenliterale können 250 verschiedene Zeichen enthalten . Daher wird zuerst die Ganzzahl 250 × 65 + 220 = 16470 berechnet .

16470 ist teilbar durch 3, daher codiert der Quotient 16470/3 = 5490 ein druckbares ASCII-Zeichen oder einen Zeilenumbruch. Davon gibt es 96 und 5490 = 96 × 57 + 18 , was bedeutet, dass wir das druckbare ASCII-Zeichen am 0-basierten Index 18 dekodiert haben , der '2' ist .

Wir haben 57 übrig , was auch durch 3 teilbar ist , also codiert der Quotient 57/3 = 19 = 96 × 0 + 19 druckbare ASCII-Zeichen am 0-basierten Index 18 , der '3' ist .

Dies lässt 0 ; Der Dekodierungsvorgang wird gestoppt. Die generierten Zeichen werden zu "23" verkettet

!ḤḤ!

Das faktorielle Atom !wandelt das implizite Argument 0 in 1 um . Zwei Aufrufe des nicht- halbierten Atoms Ḥverwandeln 1 in 2 , dann 2 in 4 . Endlich !berechnet 4! = 24 .

³HH

In Abwesenheit von Befehlszeilenargumenten, die konstant ³hält 100 . Zwei Aufrufe der HRunden 100 in 50 , dann 50 in 25 .

ØaM

Die Konstante Øaenthält das Kleinbuchstaben. Das maximale Atom Mliefert alle Indizes maximaler Elemente, und da z der größte Kleinbuchstabe ist, ist das Ergebnis [26] .

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

Sechsundzwanzig Kopien des verketteten Atoms ;verketten den anfänglichen Rückgabewert 0 und sechsundzwanzig Instanzen des Standardarguments 0 und bilden ein Array mit 27 Nullen.

¬ist das logische NICHT- Atom, also ;¬hängt eine 1 an das Array von Nullen an. Das nächste ¬negiert alle Elemente im Array und lässt uns ein Array mit 27 Einsen und 1 Null zurück.

ḅist das Unbase- Atom und konvertiert ein Ziffern-Array von seinem linken Argument von der in seinem rechten Argument angegebenen Basis in eine Ganzzahl. ḅ¬Konvertiert von Unary zu Integer, führt also einfach eine Summe aus. Für ein Array von 27 gibt dies 27 zurück .

irið8c

Der Index des Atoms ibefördert sein linkes Argument 0 auf [0] und ermittelt dann den Index seines rechten Arguments 0 in diesem Array, was 1 ergibt .

Das Range- Atom rkonstruiert einen aufsteigenden oder absteigenden Bereich vom linken zum rechten Argument. Das richtige Argument ist das implizite Argument 0 , dies ergibt also [1, 0] . Ein zweiter Aufruf von ifindet den Index 0 in [1, 0] und ergibt 2 .

ðbeginnt eine neue dyadische Kette. Da die vorhergehende Kette niladisch war, ist sowohl das linke als auch das rechte Argument dieser Kette gleich dem Rückgabewert der ersten Kette ( 2 ). cin den Kombinationen Atom. Mit dem linken Argument 8 und dem rechten Argument 2 werden alle eindeutigen, ungeordneten 2-Kombinationen einer Menge von 8 Elementen gezählt, wobei 8C2 = 8! / (6! 2!) = 28 zurückgegeben wird .

⁶ḲĠṂ°İṂĊ

Die Konstante ⁶enthält ein Leerzeichen und setzt Argument und Rückgabewert auf '' . Das Wort atom Ḳbefördert das Zeichen '' in die Singleton-Zeichenfolge "" und teilt es in Leerzeichen auf, was [[], []] ergibt .

Die Gruppe Atom ĠGruppen alle Indizes von gleichen Elementen. Da beide Elemente des letzten Rückgabewerts gleich sind, wird hier [[1, 2]] zurückgegeben . Das minimale Atom extrahiert ein minimales (einziges) Element dieses Arrays und liefert [1, 2] .

Der Grad Atom °wandelt beiden ganzen Zahlen von Sexagesimalgrad in Bogenmaß, wodurch man 1 ° × 2π / 360 ° = π / 180 und 2 ° × 2π / 360 ° = π / 90 . Das inverse Atom nimmt die multiplikativen Inversen auf und ergibt 180 / π ≈ 57.3 und 90 / π ≈ 28.6 .

Dann nimmt Ṃnoch einmal das Minimum und ergibt 28,6 . Schließlich wird das ceil Atom Ċverwandelt 28.6 in 29 .

œṡ¹ẆẆTUṖṖṖṖP

Die Identität Atom ¹liefert 0 für das implizite Argument 0 . Das um ein Atom aufgeteilteœṡ Argument befördert beide Argumente (beide 0 ) zu [0] und teilt dann [0] um benachbarte Unterfelder auf, die gleich [0] sind . Dies ergibt [[], []] .

Das Schiebefenster- Atom bildet Ẇalle zusammenhängenden Unterfelder seines Arguments. Die erste Instanz transformiert [[], []] in [[[]], [[]], [[], []] , die zweite Instanz transformiert [[[]], [], [] , []]] in
[[[[]]], [[[]]], [[[], []]], [[]], [[]], [[]], [ [], []]], [[]], [[]], [[], []]] .

Die Wahrheit Atom Tlistet alle Indizes der truthy Elemente. Keines der Arrays auf der ersten Ebene ist leer, daher ergibt dies [1, 2, 3, 4, 5, 6] . Das Upend- Atom Ukehrt dieses Array um und ergibt [6, 5, 4, 3, 2, 1] .

Vier Kopien des Pop- Atoms Ṗentfernen die letzten vier Elemente und lassen uns mit [6, 5] zurück . Schließlich wird das Produkt Atom Pwandelt diese Anordnung in 30 .

31 - 40

ȷ½RṪ

ȷist eine Abkürzung für 1 × 10 ³ = 1000 . Die Quadratwurzel Atom ½ergibt 31,6 , was der Bereich Atom Rverwandelt sich in [1, ..., 31] . Schließlich wird der Schwanz Atom Ṫextrahiert das letzte Element, Return 31 .

LµdddddµFL

Die Länge Atom Lfördert das implizite Argument 0 zu [0] , nimmt dann die Länge ergeben 1 . µstartet eine neue, monadische Kette und das Ergebnis 1 wird zum Argument.

Für die Argumente x und y ergibt das Divmod- Atom [x / y, x% y] . Jeder Aufruf hat y = 1 , das Ergebnis ist also immer [x, 0] .d

Der erste Aufruf beginnt mit x = 1 und ergibt [1, 0] . dFunktioniert nur mit ganzen Zahlen, wird also in nachfolgenden Aufrufen vektorisiert. Der zweite Aufruf ergibt [[1, 0], [0, 0]] , der dritte [[[1, 0], [0, 0]], [[0, 0], [0, 0]] , und die fünfte und letzte ein Array der Tiefe 5, das eine einzelne Eins und 31 Nullen enthält.

µstartet erneut eine neue, monadische Kette, und das Array von zuvor wird zu seinem Argument. Das flache Atom Fentzweit dieses Array und ergibt ein flaches Array aus einer einzelnen Eins und 31 Nullen. Nimmt schließlich Ldie Länge des resultierenden, zurückgegebenen 32 .

33

Noch ein Neudigit, noch ein Literal.

WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWŒḊ

Jede Instanz des Wrap- Atoms transformiert sein Argument z in [z] . Mit dem anfänglichen Rückgabewert 0 ergeben alle 34 Instanzen zusammen [[[[[[[[[[[[[[[[[[[]]]] ]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]] . Schließlich ist die Tiefen Atom ŒḊberechnet die maximale Tiefe der resultierenden Anordnung, Return 34 .

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

Das Fenster existiert Atom ẇbefördert beide Argumente (beide standardmäßig auf 0 ) auf [0] und testet dann, ob ** [0] ** als zusammenhängendes Subarray von [0] auftritt . Er tut, so ẇgibt 1 .

ɓbeginnt eine neue dyadische Kette. Da die vorhergehende Kette niladisch war, ist sowohl das linke als auch das rechte Argument dieser Kette gleich dem Rückgabewert der ersten Kette ( 1 ). Die Kette verwendet zwei verschiedene dyadische Atome: Bitverschiebung nach links ( æ«) und bitweises ODER ( |).

Eine dyadische Kette, die mit drei oder mehr Dyaden beginnt, nennt zunächst die erste Dyade mit den Argumenten der Kette. Hier ergibt sich 1 << 1 = 2 . Die sechs nachfolgenden Dyaden werden in Paare (sogenannte Gabeln ) gruppiert , wobei die Dyade ganz rechts zuerst mit den Argumenten der Kette und die ganz linke mit den vorherigen Rückgabewerten zu beiden Seiten aufgerufen wird.

Für erhalten æ«æ«wir 2 << (1 << 1) = 2 << 2 = 8 . Dann æ«æ«berechnet 8 << (1 << 1) = 8 << 2 = 32 . Jetzt |æ«bekommt uns 32 | (1 << 1) = 32 | 2 = 34 .

Schließlich verhält sich der Trailing |wie ein Hook und wird mit dem vorherigen Rückgabewert als linkem und dem rechten Argument der Kette als rechtem Argument aufgerufen. Dies ergibt 34 | 1 = 35 .

⁹ṚḢ²

In Abwesenheit eines zweiten Arguments, die konstant ⁹hält 256 . Das umgekehrte Atom fördert 256 auf das Array [2, 5, 6] und kehrt es zu ergeben [6, 5, 2] . Dann wird das Kopfatom extrahiert das erste Element und die quadratischen Atome kehren ** 6² = 36 *.Ḣ²

‘‘‘0‘‘‘‘‘‘‘

Das Inkrement- Atom ‘inkrementiert sein Argument um 1 , also setzen Sie ‘‘‘den anfänglichen Rückgabewert 0 auf 3 . Die folgende 0 ist eine nicht analysierbare Null, dh sie passt in keiner Weise in die Kette. Infolgedessen wird der vorherige Rückgabewert ( 3 ) an STDOUT ausgegeben und dann durch den Wert ( 0 ) des Nulladers ersetzt .

Die folgenden 7 Kopien von ‘wandeln diese 0 in 7 um , die implizit gedruckt werden, wenn das Programm beendet ist.

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

Das Dekrement- Atom ’dekrementiert sein Argument um 1 , sodass 38 Kopien den anfänglichen Rückgabewert 0 in -38 umwandeln . Die absolute Differenz Atome ạberechnet die unsigned Differenz zwischen -38 und dem impliziten Argumente 0 , Return 38 .

-____---__________

-ist eine Abkürzung für -1 und setzt das Argument und den Rückgabewert des Links auf -1 . Jedes _ist eine Instanz des dyadischen Subtraktionsatoms , dessen rechtes Argument bei Fehlen standardmäßig -1 ist.

Zuerst -____-berechnet (-1) - (-1) - (-1) - (-1) - (-1) = 3 . Das folgende -1 ist ein nicht analysierbarer Nullwert, daher wird der vorherige Rückgabewert ( 3 ) an STDOUT ausgegeben und dann durch den Nullwert ( -1 ) ersetzt.

Als nächstes wird (-1) - (-1) = 0-_ berechnet , wobei das Literal das linke Argument von setzt und den Rückgabewert als das rechte verwendet. Die folgenden neun Kopien von subtrahieren das Standardargument -1 vom Rückgabewert und ergeben 9 , was implizit gedruckt wird, wenn das Programm beendet ist.-__

”(O

”(ist ein Zeichenliteral und das Ordnungsatom sieht seinen Unicode - Codepunkt, wodurch man bis 40 .O

41 - 47

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

In Abwesenheit eines dritten Befehlszeilenarguments hat die Konstante den ⁵Wert 10 . Das unlange Atom Ḷerzeugt einen 0-basierten Bereich, speziell [0,…, 9] für Argument 10 , zu beiden Seiten des Repeat-in-Place- Atoms x. Letzterer vergleicht Elemente seines linken Arguments mit Wiederholungen seines rechten Arguments und wiederholt jedes der Elemente entsprechend oft. Mit [0,…, 9] als linkes und rechtes Argument erhalten wir somit null Nullen, eine Eins, zwei Zweien usw.

Der Index in atom ịruft das Element seines rechten Arguments an dem in seinem linken angegebenen Index ab. Mit dem linken Argument 10 ( ⁵links davon) und dem rechten Argument [1, 2, 2, 3, 3, 4, 4, 4, 4,…, 9] (vorheriges Ergebnis) ergibt sich 4 .

Auf die Kette bis zu diesem Punkt folgt ein nicht analysierbarer Nullwert ⁵, sodass der vorherige Rückgabewert ( 4 ) auf STDOUT gedruckt wird, der Rückgabewert auf 10 gesetzt wird und der Rest der Kette wie gewohnt analysiert wird.

Wie zuvor ⁵ḶxḶergibt sich das Array [1, 2, 2, 3, 3, 3, 4, 4, 4, 4,…, 9] . Dieses Mal nennen wir das sortierte Atom Ṣfür das Argument 10 , das 10 zu [1, 0] befördert , und sortieren es dann, um [0, 1] zu ergeben . Das dyadische Kopfatom ruft nun die Präfixe der Längen 0 und 1 aus dem Ergebnis auf der linken Seite ab und lässt uns [[], [1]] zurück . Beim Drucken bleibt nur 1 sichtbar.

⁽{ʂ%⁽{}

⁽und die beiden folgenden Zeichen bilden ein numerisches Literal. Wenn j und k ihre Codepunkte in Jellys Codepage und (j, k) <(124, 250) sind , erhalten wir die Ganzzahl 1001 + 250j + k . Die Codepunkte von '{' , '}' und 'ʂ' sind 123 , 125 und 167 , sodass das linke Literal 1001 + 250 × 123 + 167 (= 31918) ergibt , während das rechte 1001 + ergibt 250 × 123 + 125 (= 31876) .

Da die linke Ganzzahl weniger als doppelt so groß ist wie die rechte, ist das Ergebnis (… + 167)% (… + 125) = (… + 167) - (… + 125) = 167–125 = 42 .

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

Das Shuffle- Atom Ẋordnet die Elemente seines Arguments zufällig an. Ein numerisches Argument z wird zuvor in den Bereich [1,…, z] befördert . Für das implizite Argument 0 ist dieser Bereich leer und Ẋergibt [] . Das all- Atom Ạgibt 1 zurück, wenn alle Elemente seines Arguments wahr sind, andernfalls 0 . Da ein leeres Array nicht falsy Elemente enthält, Ạgibt 1 hier.

Der Zip mit Atom ż(eine Dyade) nimmt die Argumente x und y und transponiert das Paar [x, y] . Für Ganzzahlen x und y ergibt dies einfach [[x, y]] , und dieses spezielle żArgument, das mit den Argumenten 1 und 0 (dem impliziten Argument) aufgerufen wird , gibt [[1, 0]] zurück . Das dyadische Eval- Atom vwandelt alle flachen Arrays (die nur Zahlen und Zeichen enthalten) im linken Argument in Zeichenfolgen um und wertet die resultierenden Zeichenfolgen als monadische Jelly-Programme aus, wobei das rechte Argument als Argument der Programme gilt. Seit ["10"]Besteht nur aus Literalen, ignoriert dies das richtige Argument vund führt einfach zu [10] .

Die Kopie schnell ©Attaches an vund kopiert das Ergebnis in das Register. Später Vorkommen des Rückruf - Atom ®(a nilad) werden fetch [10] aus dem Register.

Die nächsten drei Kopien der żvArbeit wie zuvor, Zuordnung von [10] zu [10, 0] zu [100] zu… zu [10000] . Die Reihenfolge Atom ọTests wie oft sein linkes Argument durch seine rechten teilbar ist, so ist hier, berechnet sie die Reihenfolge von 10 (mit geholten ®) in 10000 = 10 ⁴ , wodurch man [4] .

Das Folgende ®ist ein nicht analysierbarer Nullwert, daher wird der vorherige Rückgabewert ( [4] ) an STDOUT ausgegeben und dann durch den Nullwert ( 10 ) ersetzt. Wir bewerben uns als Ạnächstes und ergeben 1 . (Dies ist erforderlich, da an dieser Stelle eine Null gefolgt von einer Dyade analysiert werden kann.)

żvżvżvHängt wie zuvor drei Nullen an den aktuellen Rückgabewert an und verwandelt 1 in [1000] . Schließlich ọ®berechnet die Größenordnung von 10 in 1000 = 10 ³ , und 3 ist an stdout ausgegeben , wenn das Programm beendet ist .

44

Noch ein Neudigit, noch ein Literal.

111111l11&K1111111Kl11&

In erster Linie setzt das Literal 111111das Argument und den anfänglichen Rückgabewert auf 111111 . Die anderen Läufe von 1sind ebenfalls Literale.

list das Logarithmusatom , das den Logarithmus seines linken Arguments mit der in der rechten angegebenen Basis berechnet. Wenn 111111 mit dem rechten Argument 11 aufgerufen wird , erhalten wir log ₁₁ 111111 ≈ 4.85 .

Das Wort atom Kwird nach dem Heraufstufen einer Ziffer / eines Zeichens z zu [z] an Leerzeichen mit einem Listenargument verbunden . Hier verwenden wir es einfach, um das Argument 111111 des Links in [111111] umzuwandeln . (Hier ist kein Array erforderlich, aber es sind keine Identitätsatome mehr vorhanden.) Das bitweise UND- Atom &nimmt die Rückgabewerte auf beide Seiten, wandelt sie bei Bedarf in eine Ganzzahl um und berechnet ihr bitweises UND. In diesem speziellen Fall wird [4.85 & 111111] = [4 & 111111] = [4] zurückgegeben .

Das Folgende 1111111ist ein nicht analysierbarer Nullwert, daher wird der vorherige Rückgabewert ( [4] ) an STDOUT ausgegeben und dann durch den Wert des Nullwerts ( 1111111 ) ersetzt. Kverwandelt diese ganze Zahl dann in [1111111] . (Dies ist wiederum nicht wirklich erforderlich, aber eine Null gefolgt von einer Dyade wäre an dieser Stelle analysierbar.)

Wie zuvor l11berechnet log ₁₁ 1111111 ≈ 5.81 , dann &kehrt [5,81 & 111111] = [5 & 111111] = [5] .

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

Dies ist das einzige Programm, das aus mehreren benutzerdefinierten Links besteht. Der letzte Link ist der Hauptlink und wird beim Start des Programms ausgeführt, die restlichen Links sind Hilfslinks. Das Quick Çverweist immer auf den Link über dem aktuellen und führt ihn monadisch aus. Ebenso Ñbezieht sich der Quick immer auf den Link unter dem aktuellen (Wrapping Around) und führt ihn auch monadisch aus.

Der Oberlenker besteht aus dem Paar Atom ,- eine Dyade , die Argumente schaltet sich x und y in [x, y] - und die Summe Atom S- ein monadisch, der ein Integer - Argument fördert z zu [z] und reduziert ein Array Argument durch Zusatz. Wenn der Link ,SSmit einem ganzzahligen Argument n aufgerufen wird , berechnet er Σ [n, Σn] = Σ [n, n] = 2n .

Das mittlere Glied besteht aus den oben genannten Atomen, dem oben genannten schnellen Çund dem unbedeutenden Atom Ị- eine Monade, die 1 für numerische Argumente z mit -1 ≤ z ≤ 1 , aber 0 für alle anderen ergibt . Wenn Sie Ịein ganzzahliges Argument n zweimal anwenden, wird es im Wesentlichen durch 1 ersetzt , da die Ausgabe des ersten Ị(die Eingabe des zweiten) immer unbedeutend ist. Dieses Ergebnis wird dann mit dem Rückgabewert von Ç(mit dem Argument n aufgerufen ) gepaart und das resultierende Paar wird um reduziert S. Insgesamt berechnen wirΣ [(| n | ≤ 1) ≤ 1, 2n] = Σ [1, 2n] = 2n + 1 .

Mit diesen beiden Hilfsverknüpfungen kann die Hauptverknüpfung jetzt eine beliebige nicht negative Ganzzahl erstellen, indem sie ihre Binärziffern betrachtet. Bei einem anfänglichen Rückgabewert von 0ÇÑÇÇÇÑ berechnet die Kette das Endergebnis (((((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

Das nächste Primatom findet die kleinste positive Primzahl, die strikt größer als sein Argument ist. Mit dem anfänglichen Rückgabewert 0Æn berechnen fünfzehn Aufrufe die fünfzehnte Primzahl, also 47 .

Brainfuck , Score 2, 255 144 10 Bytes

... Ja, nicht die beste Idee, da ich nur 8 Charaktere (Tarpits gonna tarpit) zum Arbeiten habe, aber mal sehen, wie viel möglich ist. Ich denke das ist alles was möglich ist. : P Diese Antwort demonstriert sechs der acht Zeichen, die Brainfuck verwendet. Die anderen beiden sind ,Eingaben und .Ausgaben.

+
>--[<->-]

Visualisiere es online!

Erläuterung

Jede Nummer wird erstellt und in der Startzelle auf dem Band gespeichert. Hängt stark von den umhüllenden Zellen ab, die nicht in wenigen Interpreten implementiert sind.

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 , Score 38, 327 Bytes

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

Erläuterung:

• Für 1 verwenden wir das Token 'Prüfung auf Gleichheit'. Dabei wird ausgenutzt, dass Neim, wenn er versucht, leere Eingaben zu platzieren, 0 erhält. Da 0 und 0 äquivalent sind, wird 1 gedrückt, was implizit gedruckt wird
• Von 2 bis 9 verwenden wir nur numerische Literale.
• Von 10 bis 32 hat Neim tatsächlich eine Byte-Konstante für alle (ja, es ist verrückt).
• Für 33 verwenden wir nur den Befehl increment. Beim ersten Byte versucht Neim, etwas einzufügen, damit es inkrementiert werden kann. Da die Eingabe jedoch leer ist, wird standardmäßig ein Einfügen durchgeführt 0.
• Für 34 verwenden wir denselben Ansatz, dekrementieren ihn jedoch und nehmen den absoluten Wert.
• Für 35 nutzen wir die Tatsache, dass null Fakultät eins ist, und verwenden sie, indem wir die Eins duplizieren und wiederholt addieren
• Für 36 verwenden wir ℂ, um 0 und 0 auf Ko-Primalität zu prüfen, was sie sind. Dies drückt 1. Dann erhalten wir die erste Primzahl mit 𝐋, was zu einer Singleton-Liste mit nur 2 führt. Dann erhalten wir das größte Element ( 𝐠), das 2 als Zahl drückt. Dann wiederholen wir diesen Vorgang, bis wir die Liste erhalten [2 3 5 7 11]. Danach 𝐝berechnen wir die Deltas und erhalten die Liste [1 2 2 4]. Als nächstes 𝐬berechnen wir die Summe - das ist 9 - und berechnen dann den Exklusivbereich von 0 bis 9, woraus sich ergibt [0 1 2 3 4 5 6 7 8]. Schließlich 𝐬wird erneut verwendet, um 37 zu erhalten.
• Für 37 αist eine Konstante, die eine negative darstellt, und wir drücken sie wiederholt und subtrahieren sie (wiederum unter Ausnutzung der Tatsache, dass beim Versuch, auf eine leere Eingabe zu poppen, eine 0 gedrückt wird).
• Für 38 wird erneut die Standardeinstellung 0 für leere Eingaben verwendet. Es wird weiterhin eine 0 an sich selbst angehängt, eine lange Liste erstellt und dann die Länge berechnet.

Kann hier probiert werden

Python 2, 15

Hier ist ein Anfang, auf der Suche nach mehr

Danke an Leo, dessen Tipp mir geholfen hat, auf 15 zu kommen

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

---

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 Bytes, 42 Punkte

Eine große Zusammenarbeit zwischen Shaggy , ETHproductions und Oliver .

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

Diese (nützlichen) Zeichen bleiben übrig:

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

---

Erklärungen

Ein paar Dinge, die ich über Japt wissen muss, bevor wir anfangen, die ich häufig benutzt habe. Erstens hat Japt 6 Variablen für die Eingabe reserviert, die Großbuchstaben sind U-Z. Wenn über diese Variablen keine Eingabe erfolgt, werden sie standardmäßig alle auf "" gesetzt 0. Die zweite Sache wird in diesem Tipp behandelt .

Klicken Sie auf ein Snippet, um es im Online-Interpreter zu testen .

---

v

Wenn auf eine Zahl aufgebracht, die vdauert Methode eine ganze Zahl n als Argument und gibt 1 , wenn die Zahl von teilbaren n , 0 , wenn nicht. Wenn n nicht angegeben wird, wird standardmäßig 2 verwendet . 0 (der Standardwert für U) ist durch 2 teilbar , daher erhalten wir unsere 1 .

---

y

Sehr ähnlich dem ersten. Wenn die yMethode auf eine Zahl angewendet wird, verwendet sie eine Ganzzahl n als Argument und gibt die GCD der beiden Zahlen zurück. Wenn n nicht angegeben wird, wird standardmäßig 2 verwendet . Da 0 durch teilbar ist 2 , GCD (0, 2) gibt uns unser 2 .

---

Íà

Íist die Abkürzung für n(2)oder 2- this. Weil wir keinen Eingang haben, fallen wir thisauf 0, was dazu führt 2-0 = 2.

àgibt die Anzahl der Kombinationen von zurück [1...this], die 3 zurückgibt

---

Qiiii)iiii)âQ

QStandardmäßig wird ein einfaches Anführungszeichen verwendet. ian einer Zeichenkette fügt eine andere Zeichenkette am Anfang ein; Wie in Nr. 3 erläutert , entspricht jeder iiii)Wert dem .i("i".i("i"))in JS, wodurch iam Anfang der Zeichenfolge zwei Kopien von eingefügt werden. Tun Sie dies zweimal und Sie haben die Zeichenfolge iiii". âQsimuliert dann .search(Q)und gibt den Index des ersten "in der Zeichenkette an, der 4 ist .

---

ÂHq

Hist die Konstante für 32 . Bei Anwendung auf eine Zahl gibt die qMethode, die die Ganzzahl n als Argument verwendet, den n- ^ten Stamm dieser Zahl zurück. Wenn n nicht angegeben wird, ist der Standardwert 2 , Hqwas uns die Quadratwurzel von 32 ergibt, die ungefähr 5,6568 beträgt . Âist die Abkürzung für ~~, welches Stockwerk das Ergebnis ergibt und uns 5 gibt .

---

LÁL

List auf 100 voreingestellt und Ádie Abkürzung für >>>(bitweise Verschiebung nach rechts auf Null). 100>>>100ist dasselbe wie 100>>>4(der rechte Operand umschließt Mod 32), also 6 .

---

´Vn´VnVnVn

Wie bereits erwähnt, ist der VStandardwert 0 . ´ist die Abkürzung für den --Operator, daher entspricht der Code dem folgenden JS:

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

X.n(Y)ist äquivalent zu Y - X oder -X + Y ; Der erste --VWert gibt -1 und der zweite -2 zurück . Dies entspricht ungefähr - (- 1) + (- (- 2) + (- (- 2) + - (- 2)) . Vereinfacht ausgedrückt erhalten wir 1 + 2 + 2 + 2 = 7 .

---

8
9

Wörtlich 8 und 9 .

---

A
B
C
D
E
F
G

Dies sind die Konstanten für 10 bis einschließlich 16 .

---

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

Jist auf -1 voreingestellt . Der Japt-Interpreter schafft es irgendwie, dies korrekt zu parsen (J--) - (--J) - (--J) - (--J) - (--J). Wenn wir mehr rechnen, stellen wir fest, dass dies (-1) - (-3) - (-4) - (-5) - (-6) oder -1 + 3 + 4 + 5 + 6 = 17 entspricht .

---

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

¾ist, wie Sie sich vorstellen können, eine Abkürzung für .75. Wir haben 24 Kopien von 0,75 in einem Array, dann mit summieren x, was 0,75 * 24 = 18 .

---

;Iìw

Ich denke, das ist mein Favorit. ;zu Beginn des Programms werden die Werte einiger Japt-Konstanten geändert; ohne es Iist 64 , aber mit ihm Iist 91 . ìwkonvertiert es in eine Liste von Ziffern und läuft wauf der Liste, kehrt das Array um und konvertiert dann zurück in eine Zahl, um uns 19 zu erhalten .

---

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

½ist eine Abkürzung für .5. eAuf einer Zahl nimmt x ein Argument y auf und gibt x * 10 ^{y zurück} . Die Kette der Berechnungen lautet also:

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

Und das Finale ~~dient dazu, dies auf eine ganze Zahl zu begrenzen, was unser Ergebnis von 20 ergibt .

---

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

Tist auf 0 voreingestellt . ++ist der Inkrementoperator in JS und auch in Japt; T+++Twird analysiert als (T++) + T, wird aber ++T+++Tanalysiert als (++T) + (++T), dies entspricht also dem JS-Code

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

Das Ergebnis ist 1 + 2 + 3 + 4 + 5 + 6 , was 21 ergibt .

---

22

Ein wörtliches 22 .

---

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

Äist eine Abkürzung für +1, also summiert sich diese einfach auf 23 1 s.

---

4á

Dies [1, 2, 3, 4]ergibt die Anzahl der Permutationen von , die 4 ist! = 24 .

---

5²

²ist eine Abkürzung für p2, die eine Zahl hoch zwei setzt. 5 ** 2 ist 25 .

---

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

°ist eine Abkürzung für den ++Operator oder kann sie nicht als solche analysiert werden + +. Wie bereits erwähnt, ist der UStandardwert 0 , wenn keine Eingabe erfolgt . Der Code ist also äquivalent zu (++U), (U++) + + (++U) + + (++U) + + (++U) + + (++U) + + (++U), was # 17 sehr ähnlich Uist : wird zuerst inkrementiert 1, dann wiederholt inkrementiert und so addiert, dass das Endergebnis 1 + 3 + 4 + 5 + 6 + 7 = 26 ist .

---

»³³

³ist die Abkürzung für die pMethode mit einem Argument von 3 . Wenn jedoch ein Kleinbuchstabe direkt nach einer linken Klammer angezeigt wird ( »ist die Abkürzung für ((), wird er zu einer Zeichenfolge. Auf diese Weise wird es an eine Methode übergeben und als Funktion aufgerufen (dh m³es wird eine Zuordnung von vorgenommen .p(3)). In diesem Fall gibt jedoch ("p",3)unser zurück 3, dann erhöhen wir es auf die Potenz von 3( pist die Potenzmethode, wenn sie auf eine Zahl angewendet wird), was uns unsere 27 ergibt .

---

7/¼

¼Wie Sie wahrscheinlich inzwischen wissen, ist dies eine Abkürzung für .25, daher berechnet sich daraus 7 / 0,25 = 28 .

---

$'_____________________________b'$bb

Alles, was in $Symbole eingeschlossen ist, wird als reines JavaScript behandelt. Wir haben also eine Folge von 29 Unterstrichen gefolgt von einem b. (Ohne $, 'wäre dies eine Zeichenfolge mit nur einem Zeichen.) Die bauf eine Zeichenfolge angewendete Methode gibt den ersten Index ihres Arguments in dieser Zeichenfolge zurück. Wie in # 3 erläutert , wird der letzte bin einen String konvertiert, sodass wir den ersten Index von bin unserem String abrufen, nämlich 29 .

---

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

µist eine Abkürzung für -=und Éfür -1. Der Effekt subtrahiert 30 Kopien von -1 von 0 , was 30 ergibt .

---

"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"aa

Sehr ähnlich wie # 29. Das aVerfahren kann , wenn auf eine Zeichenfolge aufgebracht ist , kehrt den letzten Index seines Arguments in dieser Zeichenkette. Bei Verwendung der 0-Indizierung ist der letzte Index ain einer Zeichenfolge von 32 as 31 .

---

Sc

Sist für ein einzelnes Leerzeichen vordefiniert und gibt cfür eine einzelne Zeichenfolge ihren Zeichencode mit 32 zurück .

---

33

Literal 33 .

---

Mg011

MgNgibt die N-te Fibonacci-Zahl zurück. 011ist 9 im Oktal; die 9. Fibonacci-Zahl ist 34 .

---

##

#Gibt den Zeichencode des nächsten Zeichens zurück. Der Zeichencode für #sich ist 35 , was unsere Arbeit hier besonders einfach macht.

---

6p

pist die Potenzierung und ohne ein zweites Argument standardmäßig 2 ; Dies ergibt also 6 ** 2 = 36 .

---

Rí í í í í è.

Dieser ist ziemlich knifflig. RDer Standardwert ist ein einzelnes Zeilenumbruchzeichen (das ist ein Zeilenumbruch, der später wichtig wird). íEin String ohne Argumente nimmt jedes Zeichen und hängt seinen Index an: eine ziemlich nutzlose Transformation, aber das Ergebnis durch 5 Iterationen ist: (Verwenden Ranstelle einer wörtlichen Newline)

R
R0
R001
R0010213
R001021304251637
R0010213042516370849210511112613314715

Interessant, wie jeder Eintrag einfach ein Präfix des nächsten ist ... Der letzte Teil è.zählt jedoch, wie viele Übereinstimmungen /./gim Ergebnis gefunden wurden. Die Zeichenfolge enthält 38 Zeichen. Da jedoch /./gnur Zeichen ohne Zeilenumbruch verwendet werden, ist das Ergebnis 37 .

---

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

Backticks markieren einen komprimierten String und ¥dekomprimieren ihn auf ll. lfür eine Zeichenfolge ergibt sich eine lLänge, nach der Dekomprimierung ergibt sich also eine Länge von 38 .

---

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

Oh Junge, das ist ein Trottel. Zuerst generieren wir truemit ¨N( ¨steht für >=und Nohne Eingaben ist das leere Array), dann konvertieren wir das in 1mit |N. Von da an wird es ziemlich verrückt:

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

(Das ¹s ist nur ein Ersatz für close-parens und wurde weggelassen.) Das Finale erscheint ound gibt das finale Element im Array zurück, wobei 39 erhalten werden .

---

º¤¤*º¤

Meist der gleiche Trick wie bei # 3 . ¤ist die Abkürzung für die sMethode mit dem Argument 2 . In diesem Fall ist der transpilierte Code jedoch (("s", 2).s(2) * (("s", 2) * (("s", 2))))vereinfacht (2).s(2) * (2 * 2). .s(2)gibt die Zahl als Basis-2-String zurück, was ergibt "10"; * (2 * 2)Wandelt dies implizit in eine Zahl um und multipliziert es mit 4 , was 40 ergibt .

---

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

Ähnlich wie beim Vorgänger. Åist die Abkürzung für die sMethode mit dem Argument 1 . In diesem Fall wird jedoch jede (Åtranspiliert ("s", 1), die nur 1 zurückgibt . 1<<1<<1<<1<<1<<1ist 32 und 1<<1<<1<<1ist 8 ; Diese werden zusammen mit XOR-verknüpft 1, um 41 zu erhalten .

---

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

±ist eine Abkürzung für +=und ¶für ===. Dies bedeutet, dass der Code tatsächlich ist

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

Y===Y ist immer wahr, also können wir dies vereinfachen:

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, Punktzahl 17, 130 Bytes

Zeichen verwendet 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 Boolesche Konstante Z (nicht gesetzt) ​​gleich Konstante Z

2 FTP_MOREDATA ist eine Konstante in PHP mit dem Wert 2

3 bitweise und Zeichen; und W

4 bitweise Nach links schieben und logisch nicht leeres Array auf booleschen Wert true umwandeln mit wird durch den Operator nach links schieben in Ganzzahl 1 umgewandelt

7 bitweise Oder Zeichen # und $ und 1

9 SIGKILL ist eine Konstante in PHP mit dem Wert 9

10 Bitweise Verschiebung nach rechts bei jedem Schritt ist eine Ganzzahldivision mit 8, daher haben wir die Schritte 333333, 41666, 5208, 651, 81, 10

13 zähle char X in der Zeichenkette X ... von Anfang an

15 Hexadezimalwert f = 15

17 bitweises Xor mit den Strings ha und YV

Alle Snippets sind Elemente in einem Array

Probieren Sie es online!

PHP, Score 16, 94 Bytes

Zeichen verwendet 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 Boolesche Konstante Z (nicht gesetzt) ​​gleich Konstante Z

2 bitweise und Zeichen: und w

3 Pi wird durch ein leeres Array, das auf Null gesetzt wurde, auf einen ganzzahligen Wert gesetzt

7 bitweise xor Zeichen A und v

10 Variable $ s nicht gesetzt! $ S = ein Concat mit Stringlänge von Variable $ s

13 111/2 = 55/2 = 27/2 = 13 Bitweise Ganzzahldivision

15 Hexadezimalwert f = 15

Alle Snippets sind Elemente in einem Array

Probieren Sie es online!

PHP, Punktzahl 14, 84 Bytes

Zeichen verwendet $!_^[]()%/+~-=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 Boolesche Konstante Z (nicht gesetzt) ​​gleich Konstante Z

3 Pi wird durch ein leeres Array, das auf Null gesetzt wurde, auf einen ganzzahligen Wert gesetzt

7 ERA ist eine Konstante mit dem Wert 131116 mod 11 = 7

10 Variable $ s nicht gesetzt! $ S = ein Concat mit Stringlänge von Variable $ s ist Null

13 hexadezimaler Wert d = 13 14 bitweise nicht und Minuszeichen erhöhen NULL auf 14

Alle Snippets sind Elemente in einem Array

Probieren Sie es online!

R, Punktzahl 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

Dank user2390246 gibt es eine extra.

Zeichen verwendet:

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

MATL , 21 22 23 Zahlen (273 Bytes)

Vielen Dank an J Doe für die Erweiterung von 22 auf 23 Nummern!

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

Probieren Sie es online! Jedes Snippet in der Verknüpfung wird entweder mitD(Anzeige) oder]D(Endlosschleife explizit und Anzeige) beendet, um den Stapel zu löschen und somit vom nächsten Snippet zu isolieren.

Erläuterung

0~

Drücken 0. Negieren. Gibt true, was angezeigt wird als 1.

'bd'd

String schieben 'bd'. Aufeinanderfolgender Unterschied zwischen den Codepunkten der Zeichen.

{P}gk

Drücken Sie auf das Zellenarray, das die Nummer enthält pi. In ein numerisches Array konvertieren (dh in eine einzelne Zahl). Abrunden.

HH^

2Zweimal drücken . Leistung.

5

Numerisches Literal.

6

Numerisches Literal.

7

Numerisches Literal.

8

Numerisches Literal.

9

Numerisches Literal.

3 3.333333333333333*

Drücken 3. Drücken 3.333333333333333. Multiplizieren. Aufgrund der Fließkommagenauigkeit ergibt sich 10.

11

Numerisches Literal.

IEE

Drücken 3. Mit 2zweimal multiplizieren .

[B]Yq

Drücken Sie [6](das ist das Gleiche wie 6). Berechne n- te Primzahl.

llllllllllllllNwxwxwxwxwxwxwxwxwxwxwxwxwxwx

114 mal drücken . Anzahl der Elemente im Stapel. Räumen Sie den Rest des Stapels ab.

KUKUa-

Drücken 4. Quadrat. Das Gleiche tun. Beliebig: gibt 1. Subtrahieren.

4W

Drücken 4. 2dazu erhoben.

FFFFFFFFFFFFFFFFFn

Array drücken [false false ... false](17 mal). Anzahl der Elemente im Array.

TTTTTTTTTTTTTTTTTTs

Array drücken [true true ... true](18 mal). Summe des Arrays.

rrrrrrrrrrrrrrrrrrrhhhhhhhhhhhhhhhhhhz

Drücken Sie 19 Zufallszahlen aus dem Intervall (0,1). 18 Mal horizontal verketten. Anzahl der Nicht-Null-Elemente im Array.

OOOOOOOOOOOOOOOOOOOOvZyX>

020 mal drücken . Stapelinhalte vertikal verketten (ergibt einen Spaltenvektor). Größe: gibt das Array an [20 1]. Maximales Array.

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

1j21 mal drücken (imaginäre Einheit). 20 mal addieren. Teilen Sie durch 1j.

22

Numerisches Literal

`@QQQQQQQQQQQQQQQQQQQQQQ@@<

Do ... while loop ( `) mit implizitem Ende. In der ersten Iteration wird der Iterationsindex @( Q) verschoben und 22-mal inkrementiert , was ergibt 23. Die Schleifenbedingung ( @@<) ist falsch, daher wird die Schleife verlassen.

Einige Ideen zur weiteren Verbesserung

• (Leerzeichen) in Snippet 10 könnte durch ersetzt werden |
• X>in Snippet 20 könnte durch ersetzt werden p, wodurch Präfix frei wird X.
• Momentan nicht verwendet und potentiell nützlich: :,A

Vim 8 unter Windows, Punktzahl 13, 104 Bytes

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

^{keystroke}repräsentiert <C-{keystroke}>, so ^Xist es <C-x>, außer ^@was ist <C-j>. Ich versuche immer noch, dieser Liste weitere Nummern hinzuzufügen und <CR>stelle einen Zeilenvorschub dar.

Hinweis: Um diese Befehle auszuführen, starten Sie vim mit -u NONE -U NONE. Dies soll sicherstellen, dass Ihre Configs den Code nicht stören.

Die Snippets 1 bis 10 starten im Einfügemodus. Während Snippets 12 und 13 im normalen Modus gestartet werden.

Erklärungen

Snippet 8 ist :^R=&ts^@. Ich muss mich bei @ L3viathan für die Erstellung bedanken und bei @ nmjcman101 für den Vorschlag, ^@den Zeilenvorschub zu ersetzen, und bei @ ØrjanJohansen für die Verkürzung &tabstopauf &ts. &tsAnschließend wird die Größe der Registerkarte ermittelt (standardmäßig 8), und dieser Wert wird in den Editor eingefügt.

Snippet 10 ist 8^O^A^O^A. Wir fügen eine 8 ein und erhöhen sie dann zweimal, um 10 zu erhalten.

Snippet 11 ist 0^[^X^X^X^X^X^X^X^X^X^X^X0x. Wir schreiben eine 0 auf und dekrementieren sie 11 Mal, um -11 zu erhalten. Dann entfernen wir das Minus, um 11 zu erhalten.

Snippet 12 ist :h<CR>wwwwwwwwwwwy$:q<CR>p. Daraufhin wird das Hilfemenü von Vim 8 geöffnet, das die folgenden Informationen enthält:

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

Und die Folge von ws wechselt zu 12, an welcher Stelle y$die Zahl kopiert wird. Dann wird es mit in den Editor eingefügt p.

Snippet 13 grgKjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjYZZvPWWWllld|llDbedankt sich bei @DJMcMayhem für die Entwicklung. Dies funktioniert nur unter Windows. Das Snippet durchsucht das Hilfemenü nach Befehlen, die mit beginnen g. Dann bewegt es sich mit jnach unten , um zu dieser Zeile zu gelangen:

|g?|        g?      2  Rot13 encoding operator

Danach wird es kopiert und in den Puffer eingefügt. Danach wird alles außer der 13 aus dem Puffer entfernt.

Mathematica, Punktzahl 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 , Score 18, 67 Bytes

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

Probieren Sie es online!

PingPong , Ergebnis 127

In PingPong hat jedes Zeichen einen eigenen numerischen Wert, was das Zählen bis zu 127 zu einer trivialen Aufgabe macht. Die Sprache liest den Wert jedes Zeichens ein und schiebt es an die Spitze eines Stapels, wo alle Operationen ausgeführt werden. PingPong kann theoretisch 127 überschreiten, erfordert jedoch die Übergabe eines Zeichenblocks, der einfach als Leerzeichen in einem Texteditor angezeigt wird, sodass ich sie aus meiner Lösung herausgelassen habe.

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

Oktave, Punktzahl 14, 74 Bytes

Ich bin mir ziemlich sicher, dass ich jetzt am Limit bin.

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

Hat zu entfernen , strchrda ich bereits cin Nummer 10. Ich habe noch j, ^, =, !, Raum und horizontale Registerkarte (ASCII-9) nach links, so dass es möglich sein könnte , einen weiteren zu quetschen.

Die horizontale Registerkarte kann als Leerzeichen verwendet werden, sodass der mit strchrund nnzverwendete Trick ein weiteres Mal verwendet werden kann. Die einzigen verbleibenden Kleinbuchstaben sind abdfgjkmoquvwxy. Es gibt nicht viele Funktionen, die daraus gemacht werden können. modkönnte funktionieren, aber es kann keine Zeichenketteneingabe annehmen.

Es ist einfach, die verbleibenden Zeichen zu verwenden 1, aber ich weiß nicht, wie ich an etwas anderes kommen kann.

Testen Sie alle .

Möglicherweise nützlich: fun aist dasselbe wie fun('a'), fun a bist dasselbe wie fun('a','b')und so weiter. Dies kann an mehreren Stellen verwendet werden:

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

Wenn Sie dies verwenden, wird es 0verfügbar, aber ich kann noch nicht sehen, wie ich es nützlich machen kann.

e (2.71828...)und jsind noch unbenutzt. Muss aber entfernen ceil, um zu verwenden e.

Alternativen (Inspiration):

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 Ganzzahlen, 137 130 128 Bytes

Ich nahm die Antwort von @ETHproductions und rannte eine Weile damit. es hat sich so sehr verändert, dass ich es separat poste. Ideen sind willkommen. :)

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

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

Oder wenn das Snippet für 1 ersetzt wird durch !!/!//!!/!/:
$_@#^&|*?:", ABDEGHIJKLNPQRUVWZcghjklmpqrsuvwyz

---

JavaScript (ES7), 16 Ganzzahlen, 127 Byte

Ein Byte kürzer. : 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

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

Dyalog APL, Punktzahl 15, 89 Bytes

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

_{Die vorherigen Zeilenumbrüche l:lsind Teil von 12.}

_{Die Leerzeichen in 14 stehen für Tabulatoren.}

> <> , Punktzahl 20, 93, 90 74 65 Bytes

(3 Bytes von Teal Pelican gespeichert, viele Bytes von Jo King gespeichert!)

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

Probieren Sie sie auf dem Fischspielplatz! Sie können die Snippets dazu bringen, ihre Ergebnisse auszudrucken, indem Sie jeweils n;am Ende hinzufügen . Beachten Sie, dass das 9. Snippet einen Tab enthält, der durch Stapelaustausch gegessen wird.

Erläuterung:

• In versucht iii((jeder i, Eingaben zu erhalten, aber da es keine gibt, drücken sie -1stattdessen EOF = . Dann (ist die Anweisung weniger als, und da -1nicht weniger als ist -1, schiebt es einen Falsey 0; aber die zweite (fragt ob -1kleiner ist als 0, was es ist, also drängt es eine wahrheit 1.
• 2und 3sind offensichtlich.
• Denn ll{lll{[der erste ldrückt die Länge des Stapels, 0der zweite drückt die neue Länge und bringt den Stapel auf 0, 1. Der {dreht den Stapel nach links und vertauscht das 1und 0. Drei weitere ls bringen den Stapel auf 1, 0, 2, 3, 4. Dann {dreht sich der 1nach vorne und [saugt als erstes 1den Stapel ab, der ist 4.
• 5, 6, 7Und 8sind zu offensichtlich.
• Überspringt in !\t00=0g(wobei \tein Tabulator darstellt) !den Tabulator, 00=drückt dann zwei Nullen und prüft, ob sie gleich sind - sie sind es, sodass wir eine Wahrheit erhalten 1. Nachdem Sie einen anderen gedrückt haben 0, gwird das Zeichen an die Position 1,0des Codes verschoben 9. Dies ist die Registerkarte mit dem Zeichencode .
• abis zu fjedem push 10um 15jeweils (vermutlich um hexadezimal schön zu machen).
• 44*drückt zwei 4s und multipliziert sie miteinander, z 16.
• 'RA'schiebt die Zeichencodes von Rund A(82 bzw. 65) auf den Stapel und %berechnet dann 82 mod 65 = 17.
• 999-9--bewertet zu 9 - ((9 - 9) - 9) = 18.
• "&F#"drückt die Zeichencodes &, Fund #, die sind 38, 70und 35jeweils. Dann ,ist die Teilung, also bekommen wir 38 / (70 / 35) = 19.
• Zum Schluss 1::drückt man a 1und dupliziert es zweimal, +addiert zwei der beiden, um zu erhalten 2; :+dupliziert das 2und fügt es sich hinzu, um es zu bekommen 4; +fügt den Rest hinzu 1, um zu erhalten 5; dann :+:+dupliziert und zweimal fügt hinzu, in resultierend 20.

Dies ist die mit> <> maximal mögliche Punktzahl. Jeder Schnipsel muss eine Anweisung irgendwo enthält , die einen leeren Stapel in einen nicht leeren Stapel dreht, und es gibt nur 18> <> Anweisungen , die das tun können (nämlich i, lund die Ziffern 0–9und a–f) plus String - Modus. (Jede andere Anweisung bewirkt entweder nichts an einem leeren Stapel ><v^/\|_#x!{}roder versucht, etwas und Fehler ?.+-*,%=():~$@[]on&gpherauszufiltern.) Beim Aufrufen des Zeichenfolgenmodus wird entweder "oder verwendet ', sodass höchstens 18 + 2 = 20Ausschnitte möglich sind.

---

Wenn Sie mit unprintables bequemer sind als ich, ist dies möglich , in 53 Bytes, dank Jo King: 00=, iii((i-, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f, 2222***, !Xll$g, 11+::+:+:++, 'Y', "Z", wo die X, Yund Zwird durch Zeichen mit Codes ersetzt 17, 19und 20jeweils.

MathGolf , 48 51 53 Ganzzahlen, 324 Bytes

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

40Dank @maxb +2 Punkte (und -2 verschiedene Bytes ) .

Jede Zeile ist ein separates Programm.

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

Erklärung und TIO-Links:

MathGolf ist eine neue Golfsprache, die sich auf mathematische Golfherausforderungen spezialisiert hat. Es hat eine Menge Single-Byte-Buildins für Zahlen, was es zu einer perfekten Herausforderung macht.

1) î: Schieben Sie den 1-indizierten Wert der Schleife, der standardmäßig 1 ist: Probieren Sie es online aus.
2) ª∞~: [1] drücken; verdopple es ([2]); Pop-Liste und schieben Sie den Inhalt auf den Stapel: Probieren Sie es online.
3) c±b±+: -2 drücken; dann Pop und Push seinen absoluten Wert; -1 drücken; dann Pop und Push seinen absoluten Wert; und addieren Probieren Sie es online aus.
4) φⁿ_¥-: Schieben Sie den goldenen Schnitt (1.618033988749895); cube it (4.23606797749979); Dupliziere die Oberseite des Stapels. nimm Modulo 2 (0,23606797749979); subtrahieren sie voneinander: Probieren Sie es online.
5,6,7) Die Zahlen selbst: Probieren Sie es online. Probieren Sie es online aus. 9) : -3 drücken; Im Quadrat: Probieren Sie es online aus.
8) ○¢i♀/: 2048 drücken; konvertiere in eine hexadezimale Zeichenkette (800); umgewandelt in eine ganze Zahl; Drücke 100; Teilen:
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) Push Builtins für die Zahlen selbst ( ♂ABCDE☻FGHIJKLMNOPQRST♥UVWXYZ): Probieren Sie es online.
39) ♫¼¼¼¼: Drücken Sie 10000; viermal ganzzahlig geteilt durch 4: Probieren Sie es online aus.
40) 88888]Σ: 8 fünfmal drücken; wickle sie in eine Liste ein; Fassen Sie diese Liste zusammen: Probieren Sie es online aus.
41) Die Nummer selbst: Probieren Sie es online.
42) ╔½½½½½½½½½½½: 86400 drücken; ganzzahlig durch 2 elf mal geteilt: Probieren Sie es online aus.
43) π░3§3: PI drücken (3.141592653589793); Besetzung der Saite; Pop und Push sein drittes 0-indiziertes Zeichen (4); drücke 3; Den gesamten zusammengefügten Stack implizit ausgeben: Probieren Sie es online aus.
44) 22#22#: 2 mal drücken; Nimm die Kraft der beiden (4). mach es nochmal; Den gesamten zusammengefügten Stack implizit ausgeben: Probieren Sie es online aus.
45) τ╥└: Push 2 * PI (6.283185307179586); Pop und drücke die Potenz von 2 darunter, die am nächsten ist (4); Drücke auf die Oberseite des Stapels + 1, ohne zu platzen (5). Den gesamten zusammengefügten Stack implizit ausgeben: Probieren Sie es online aus.
46) ♦⌡⌡⌡⌡⌡⌡⌡⌡⌡: 64 drücken; 9-mal um 2 verringern: Probieren Sie es online aus.
47) !⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠: Gamma (n + 1) drücken (standardmäßig 1); dreiundzwanzig Mal inkrementieren: Probieren Sie es online aus.
48)'0$: Geben Sie den Ordnungswert des Zeichens '0' ein: Probieren Sie es online aus.
49) ÿ@@@@£9: Schnur drücken "@@@@"; Pop und schieben Sie seine Länge (4); 9 drücken; Den gesamten zusammengefügten Stack implizit ausgeben: Probieren Sie es online aus.
50) )))))))))))))))))))))))))))))))))))))))))))))))))): Inkrementiere um 1 mal 50: Probiere es online aus.
51) ►◄╠•╠: Drücken Sie 1.000.000; Push 10.000.000; Pop beide und Integer-Divide sie miteinander (10); Drücken Sie 512; Pop beide und Integer-Divide sie miteinander: Probieren Sie es online.
52) "hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh"h : Schubschnur "hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh"; schieben Sie die Länge (ohne die Schnur zu knallen); entferne alles vom Stapel bis auf den letzten Gegenstand: Probiere es online aus.
53) ♣(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((: 128 drücken; Fünfundsiebzig Mal um eins verringert: Probieren Sie es online aus.

Ich werde versuchen, später noch etwas hinzuzufügen. Ich habe noch einige nützliche Dinge übrig, einschließlich Modulo %und Multiplizieren *.

Java 8, 11 12 13, 39 Bytes

Java hat nur 10 Symbole für Zahlen (0-9) und alle Methodenaufrufe und Konstanten erfordern einen Punkt, daher bin ich mir nicht sicher, ob ich über 11 Ausgaben kommen kann

Offensichtlich werden Zeichen standardmäßig in Ganzzahlen umgewandelt, wenn Operationen angewendet werden

+1 mit Hilfe von @ OlivierGrégoire

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

Erklärungen:

i->-~i

Ganzzahliges Lambda, das keine Eingabe annimmt und 1 zurückgibt. Wenn ein Parameter keine Eingabe annimmt, wird der Standardwert gemäß dem obigen Meta-Post verwendet, der für Ganzzahlen 0 ist

2
3
4
5
6
7
8
9

wörtliche ganze Zahlen

'P'^'Z'

XOR aus zwei Zeichen, um 10 zurückzugeben

11

Literal Integer

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

Lambda-Ausdruck, der die Länge einer 12-stelligen Zeichenfolge zurückgibt

0xD

Hexadezimalzahl 13

TIO Link, wenn Sie dies überprüfen möchten.

Gaia , Punktzahl 25, 203 Bytes

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

Ich halte dies für eine perfekte Punktzahl, da aufgrund der Charakterbeschränkungen keine Niladen mehr verwendet werden können.

Erklärungen

1. §‼

§ist ein Leerzeichen, ‼ist zwingend boolesch, das Ergebnis ist also 1.

2. ..⌉+⌉

.ist eine Abkürzung für 0.5, so ist dies ceil(0.5+ceil(0.5)).

3. ₵P~~

₵Pist pi, ~ist bitweise Negation. Doppelte bitweise Negation ist einfach Kürzung.

4. 4

5. 5

6. 6

7. ∂Ql

∂Qist eine Liste mit den Namen der Wochentage, list Länge.

8. 8

9. 9

10. ¶c

Codepunkt cdes Zeilenvorschubs ¶.

11. 11

12. '¡ċ⌋u⌋

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

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

-ist eine Abkürzung für -1, ⁻ist Subtraktion. Das ist also -1 - -1 - -1...genug, um 13 zu machen.

14. 7:,Σ

Drücken Sie 7, duplizieren Sie :, verbinden Sie ,die beiden Siebenen zu einer Liste und addieren Sie Σ.

fünfzehn. Ø!))))))))))))))

Øist eine leere Zeichenfolge, also Ø!1. Inkrementiere )1 14-mal.

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

Wenn Sie eine Zeichenfolge mit schließen, ‘wird sie zu einem Basis-250-Zahlenliteral. ⟩hat in Gaias Codepage den Byte-Wert 17.

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

Jeder ]umschließt den Stapel mit einer Liste. Tun Sie dies 19 Mal und erhalten Sie die Tiefe nder Liste.

20. ⇑’e

Wenn Sie eine Zeichenfolge mit schließen, ’wird eine Liste mit Codepage-Codepunkten erstellt. elegt die Liste auf dem Stapel ab. ⇑hat einen Codepunkt von 20 in der Codepage.

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

Dekrementiere (21 Mal um 0 und negiere dann _.

22. 22

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

Konvertieren Sie die Zeichenfolge “B”von Basis 24, wobei die Ziffern von 0 bis 23 sind ↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺B. Das Ergebnis ist 23.

24. 3₈×

3 × 8.

25. ℍḥḥ

100 ℍhalbiert ḥund nochmals halbiert.

C, Punktzahl 13

Dies sind nur ein paar ganzzahlige Konstanten.

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==0ergibt 1
2. Angenommen, der Code befindet sich in Zeile 2. __LINE__= 2
3. Ganzzahlige Konstante
4. Ganzzahlige Konstante
5. Ganzzahlige Konstante
6. Ganzzahlige Konstante
7. Ganzzahlige Konstante
8. Ganzzahlige Konstante
9. Ganzzahlige Konstante
10. 1+1+1...= 1*10= 10
11. 'o'ist 111, '.'repräsentiert das nicht druckbare ASCII 0x10. 111/10 = 11
12. (2<<2)= 8 8*2= 16 16-2-2= 12
13. Stringlänge von "strlenstrlens"= 13

Ohm , Punktzahl 21 22, 160 Gesamtbytes

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

Probieren Sie es online!

Erklärungen

1. ╓S@Ri

Drücken Sie die Sekunden des aktuellen Datums / der aktuellen Uhrzeit ( ╓S). Ermitteln Sie den Inklusionsbereich von 1 bis Sekunden ( @), kehren Sie ihn um ( R) und ermitteln Sie das letzte Element ( i), das immer 1 ist.

2. ΓΓ-Γ-Γ-

Γ ist -1, also ist dies (-1) - (-1) - (-1) - (-1), was 2 ist.

3. αê⌠

αêist Eulers Nummer (2.71828 ...), ⌠ist Decke. 3 ist das Ergebnis.

4. ¡¡¡¡¼

¡erhöht den Zähler, ¼drückt den Zähler.

5. 5

Nur eine wörtliche.

6. ▀lll▀l

▀lll▀ist ein komprimiertes String-Literal, das äquivalent zu ist "of >ic". lNimmt die Länge, so ist das Ergebnis 6.

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

Zuerst drücken wir 7 Zeilenumbrüche ( Ñ) und dann eine leere Zeichenkette ( ÿ). Der Stapel wird in ein Array ( W) eingeschlossen, und dann wird der Index der leeren Zeichenfolge in diesem Array gefunden.

8. ü`½½

üist ein Leerzeichen. `drückt seinen ASCII-Wert (32), dann wird er zweimal halbiert ( ½½).

9. 9

Nur eine wörtliche.

10. ..≥°

..ist ein buchstäblicher .Buchstabe. Es wird inkrementiert ( ≥), wodurch die Zeichenfolge als Zahl analysiert wird. Der Standardwert ist 0, da es sich nicht um eine gültige Zahl handelt, und es wird auf 1 inkrementiert. Dann berechnen wir 10 ¹ ( °).

11. $$J

$ schiebt den aktuellen Wert des Registers, anfangs 1. Also, schiebe 1 zweimal, füge den Stapel zusammen und drucke.

12. 3dd

3 drücken und zweimal verdoppeln.

13. 7ƒ

Drückt die 7. Fibonacci-Nummer.

14. 2≡≡≡Σ

Drücken Sie 2, verdreifachen Sie es dreimal und lassen Sie 7 2 auf dem Stapel. Dann nimm die Summe des Stapels ( Σ).

fünfzehn. ║F

║ist das Trennzeichen für Literale mit Basis-220-Zahlen. Da dies am Ende einer Zeile steht, muss sie nicht beendet werden.

16. 4º

Berechnen Sie 2 ⁴ .

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

òist bitweises Negieren, ~ist arithmetisches Negieren. Durch die Kombination dieser Operatoren können wir 0 bis 17 Mal inkrementieren.

18. 6DD++

Drücken Sie 6, duplizieren Sie es zweimal und berechnen Sie 6 + 6 + 6.

19. 8π

Drücken Sie die 8. Primzahl.

20. τ╛hτ*

Drücken Sie 10 ( τ), erhalten Sie das erste Element ( h) seiner Primfaktoren ( ╛), multiplizieren Sie das mit 10.

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

Ähnlich wie bei vorherigen Snippets wird der String "≤"mit 0 analysiert. Wir dekrementieren ihn 21 Mal und nehmen dann den absoluten Wert an.

22. 1111 11v11%L1111 11v11%L

Hier berechnen wir 1111 div 11 mod 11, das ist 2, dann drucken Sie 2. Dann wiederholen Sie es.

PowerShell, Punktzahl 12, 91 Bytes. 14, 176 Bytes

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

Bearbeiten:

• Vielen Dank an Ørjan Johansen, der das Hex-Literal 0xd für 13 und die Neuanordnung von 5 vorgeschlagen hat, um 1 + 1 + 1 + 1 .. als Option freizugeben.
• Array-Länge wurde in String-Länge geändert, [int] in [byte] und Hash-Tabelle, um Hash-Tabellen als Werte zu verwenden. Auf diese Weise wird (),""Pondering 15 mit so etwas wie freigegeben, "ZZZZZZZZZZZZZZZA".InDeXof("A")aber Punkt oder 'e' können nicht wiederverwendet werden.

PowerShell kann keine Variablen ohne $ ausführen, kann keine Exponentiation, Bitverschiebung, Pi, ceil () usw. mit Grundsymbolen ausführen und gibt meistens einen Coercian von / nach bool und von / nach numbers-as-strings ein Es gibt relativ wenig Spielraum für die Generierung von Zahlen mit niedriger Syntax.

TI-Basic (Serie 83), Ergebnis 21 22 23 24 25 (1003 Bytes)

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

Unter http://tibasicdev.wikidot.com/one-byte-tokens finden Sie eine Liste der Dinge, die die Herausforderung hier zulässt und nicht zulässt.

All dies können vollständige Programme sein, da die letzte Zeile eines Programms automatisch gedruckt wird. Aber (mit Ausnahme von 17, die mehrere Zeilen lang ist), können sie auch Schnipsel auf dem Startbildschirm sein.

Zum jetzigen Zeitpunkt sehe ich keine andere Möglichkeit, einen Wert ungleich Null aus den verbleibenden verfügbaren Token zu ziehen. Wenn Verbesserungen vorgenommen werden müssen, müssen zunächst einige der oben genannten Lösungen konservativer gestaltet werden.

Erklärungen

• A=Aist eine boolesche 1, da die Variable Asich selbst entspricht.
• Bist standardmäßig 0, tan(tan(cos(cos(cos(Bist ungefähr 2,21, und dann ergreifen wir das Wort.
• C!°beträgt 1 Grad im Bogenmaß, ungefähr 0,017. Eine positive Potenz davon ist tanh (2), ungefähr 0,964. Wir kodieren diese Potenz in Binärform mit impliziter Multiplikation und √(und nehmen dann tanh⁻¹(.
• 4 ist einfach
• cosh(sinh⁻¹(X$\sqrt{1+X^2}$
• 6-9 sind unkompliziert
• ₁₀^( ist ein für Potenzen von 10 integriertes Ein-Byte-Format und 10 ^ 10 ^ 0 = 10 ^ 1 = 10.
• 11 ist 11.
• Eine weitere Instanz des in 5. verwendeten Tricks F nPr Fist 1. sin(tan⁻¹(Xsimplify to$\frac{1}{\sqrt{1+1/X^2}}$ und 143-mal verwendet, beginnend mit 1, erhalten wir 1/12. Teilen Sie 1 durch diese Zahl ist 12.
• G≤Gist 1, so [[G≤G]...[G≤G]]ist ein 13x1 Spaltenvektor. Nimmt man das Produkt seiner Transponierung mit sich, so erhält man die Matrix [[13]], deren Determinante 13 ist.
• not(H) ist 1. tanh(not(H)) ist nur eine Zahl ungleich 0 oder 1 und ln(XXX....X)ln(X)^⁻1vereinfacht die Anzahl der Xin dem ersten Protokoll enthaltenen Werte, vorausgesetzt, sie Xist nicht 0 (damit das Protokoll existiert) und nicht 1 (damit wir nicht teilen) um 0).
• e^(e^(e^(F wertet gegen 15.15 aus, und dann ergreifen wir das Wort.
• J≥Jist 1. identity(konstruiert eine 1x1 Identitätsmatrix,dim( findet ihre Zeilen- und Spaltendimensionen und sum(fügt sie hinzu, um 2 zu erhalten. Dann machen wir das noch einmal und addieren die Dimensionen einer 2x2-Matrix, um 4 zu erhalten, und addieren erneut die Dimensionen einer 4x4-Matrix um 8 zu erhalten, und addieren Sie die Dimensionen einer 8x8-Matrix, um 16 zu erhalten.
• K nCr K ist der Binomialkoeffizient 0, wählen Sie 0 oder 1. Addieren von 17 Einsen ergibt 17.
• i-i-...-i vereinfacht auf 18i und nehmen abs( ergibt 18.
• rand→Lspeichert eine zufällige reelle Zahl nach L, aber es ist uns egal, was es ist. Wir rechnenlog(L)⁻¹log(L^19) , was sich auf 19 vereinfacht.
• sinh(sinh(cos⁻¹(Iist etwas mehr als 4, seq(III,I,I,sinh(sinh(cos⁻¹(Igibt also die Liste an, {0 1 8 27 64}deren arithmetisches Mittel 20 ist.
• Eine weitere Instanz des Tricks, der verwendet wurde, um 3 zu erhalten. Hier sollte eine Potenz von π21 ergeben; Wir kodieren diese Potenz ternär mit impliziter Multiplikation und ³√(.
• 22 ist 22.
• Eine weitere Instanz des Tricks, der verwendet wurde, um 3 und 21 zu erhalten. Wir codieren die Potenz von 3, die 23 im Ternär entspricht, und verwenden sie 3×√(als Kubikwurzel und (zur Multiplikation.
• Fix 0ist die Einstellung für die Anzeige von 0 Stellen nach dem Komma, wobei alle Werte auf ganze Zahlen gerundet werden. sin⁻¹(ᴇ0ergibt π / 2 und π / 2 multipliziert mit sich selbst ergibt 7 mal 23,59, was auf 24 rundet.
• 5*5ist 25. (Es wäre konservativer 5, 5 zu verwenden und die dort verwendete Lösung für 25 anzupassen. Auf diese Weise wird jedoch viel Platz gespart, und es *ist kein sehr nützliches Zeichen, da implizite Multiplikation vorhanden ist.)

SOGL , Score 16 18 20, 109 Bytes, 47 Zeichen verwendet

=                    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 Ganzzahlen, 86 Bytes

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

Probieren Sie es online! (Die Eingabe steuert, welches Programm ausgeführt wird, von 1 bis N)

Erläuterung

                       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

Jelly , Punktzahl 22, 177 Bytes

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

Probieren Sie alles auf einmal oder versuchen Sie es nacheinander (Argument ist die gewünschte Ausgabe).

Unbenutzte Zeichen:

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

Reng, Score 40, 149 Bytes

Probieren Sie es hier aus!

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

Alle Großbuchstaben sind Zahlen, das ist schön. Alle bis auf zwei sind Schnipsel. Die zwei, die Programme sind:

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

Über den angegebenen Link kann der Stack während der Ausführung angezeigt werden. Ich werde später eine Erklärung schreiben.

CJam, Punktzahl 27, 168 Bytes

1-3: X , Y,Z

Die Variablen X, YundZ werden jeweils mit 1, 2 und 3 initialisiert.

4: ",,,,",

Schieben Sie die Schnur ,,,,und nehmen Sie die Länge.

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

Numerische Literale.

10-20 : A-K

Vorinitialisierte Variablen.

21 U)))))))))))))))))))))

Die Variable Uwird mit initialisiert 0. Drücken Sie Uund erhöhen Sie es 22 Mal.

22 22

Numerisches Literal.

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

Drücke den Charakter ;und dekrementiere ihn 9 Mal, um zu gelangen . Drücke 2dann ;erneut und dekrementiere ihn 8 Mal, um zu gelangen 3.

24: 4m!

Nehmen Sie die Fakultät von 4.

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

TT=drückt 1. Dieser Code entspricht 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-

Ndrückt eine Zeichenkette mit einem Zeilenumbruch. :iwandelt es in eine Liste von Zeichencodes um und ergibt [10]. ~packt es aus und gibt 10.W-ist das Äquivalent zum Hinzufügen von eins. Durch 16-maliges Inkrementieren von 10 erhält man 26.

27: LLLLLLLLLLLLLLLLLLLLLLLLLLL0]0#

Suchen Sie den Index 0 in einer Liste, in der sich 0 am 27. Index befindet.

Charaktere noch verfügbar: $%&*./1<>?@MOPQRSV[\^_`abcdefghjklmnopqrstuvwxyz{|}

Einige Hinweise zur möglichen Erweiterung:

• Möglicherweise muss ich 10-20 ändern, um die Variablen für etwas anderes zu verwenden. Wenn ich Zahlen über 1 erhalte, kann ich *(und möglicherweise bitweise Operatoren) verwenden, aber ich glaube nicht, dass sie viel helfen werden.

• Ich habe immer noch S, was immer gut ist, das wird mir helfen.

• Wenn ich 26 auf ändere N{}/iW-W-W-W-W-W-W-W-W-W-W-W-W-W-W-W-, dann :wird verfügbar sein.

• Ich kann einige leere Listen verschieben und mit vorhandenen Variablen mehr Nullen erhalten. Ich kann auch π bekommen, aber das scheint nicht sehr nützlich zu sein, es sei denn, ich kann es irgendwie in eine ganze Zahl umwandeln, und m(für m[) und isind bereits vergeben.

• In Bezug auf die Array-Manipulation kann ich:

  • Verwenden Sie eine Karte mit %oderf
  • Verwenden Sie eine Falte mit *
  • Führen Sie einige Setwise-Operationen durch
  • Basiskonvertierung (dies scheint vielversprechend, aber ich weiß nicht, wie ich die Basisnummer erhalten würde)
  • Erstellen Sie Arrays mit |:M1|2|3|

Haskell , Punktzahl 13, 86 Bytes

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

Probieren Sie es online!

Vielen Dank an Ørjan Johansen, der einen Weg gefunden hat, meine Briefüberschneidung zu korrigieren und dabei die Punktzahl von 13 beizubehalten. (Auch, weil sie sich Mühe gaben, mich darüber zu benachrichtigen, während diese Antwort gelöscht wurde.)

pi/piist 1.0.
sum[]wertet zu 0, 0^0zu 1und sum[1,1]zu aus 2. 3sich 9einfach selbst dekodieren.
length"eeeeeeeeee"ergibt die Länge der Zeichenkette, die ist 10.
2+2+2+2+2+2ist 12.
0xDist hexadezimal für 13.