Wenn Ihnen das gefällt, können Sie teilnehmen an:

• Das offizielle Dyalog APL 2016 Jahresspiel

• Die monatliche Dyalog APL 2017 Code Golf Challenge

Erstellen Sie 12 Ausschnitte / Ausdrücke in derselben Sprache, die zu den Zahlen 0 bis 10 bzw. 42 führen, ohne jedoch literale Zahlen-, Zeichenketten- oder Zeichendaten zu schreiben.

Eingebaute Daten wie PI()und ALPHABET()sind in Ordnung, ebenso wie die Konstanten U, X, Y, Z und A von CJam und die Konstanten BLEND, CHORD, CENTER, BREAK und LINES von Processing.

Jeder Ausschnitt muss für sich stehen können, dh er darf nicht voneinander abhängig sein. Innerhalb eines einzelnen Snippets können Sie jedoch eine Variable zuweisen und diese frei verwenden, solange Sie sich direkt auf den Namen und nicht auf eine Zeichenfolge mit dem Namen beziehen.

Alle Snippets müssen zum Zeitpunkt der Übermittlung auf dem Computer des Absenders gültig sein (wie von SE gemeldet), dürfen jedoch nicht auf ungewöhnliche lokale Bedingungen wie die Anzahl der Dateien in einem Verzeichnis, das genaue Datum oder die Uhrzeit oder bestimmte Eingaben des Benutzers angewiesen sein .

Beispiele für gültige Snippets

3: INT(LOG10(YEAR(TODAY()))) weil es auf absehbare Zeit wahr bleibt
4: CUBICROOT(LEN(CHARACTERSET())) weil ein 256-Buchstaben-Zeichensatz sehr verbreitet ist
8: SQRT(SYSTEMTYPE()) weil 64-Bit-Systeme sehr verbreitet sind

Beispiele für ungültige Snippets

5: LEN(USERNAME()) weil die meisten Benutzer "Admin" nicht als Login verwenden :-)
9: LOG10(SYSTEMMEMORY()) weil es nur auf Systemen mit genau 1 GB Arbeitsspeicher funktioniert
42: CODE("*") weil es ein Zeichenkettenliteral enthält

Das Ergebnis jedes Snippets muss eine tatsächliche Zahl (value, int, float usw.) ergeben, die für weitere Berechnungen in derselben Sprache wie das Snippet verwendet werden kann, dh keine Textzeichenfolge, die diese Zahl darstellt.

Nur zeichenbasierte Sprachen erlaubt.

Score ist die Gesamtanzahl der Bytes aller 12 Snippets zusammen. Zeilenumbrüche, die die Ausschnitte trennen, werden nicht mitgezählt.

Beachten Sie, dass die oben genannten Regeln möglicherweise die Teilnahme einiger Sprachen verhindern, selbst wenn sie vollständig sind.

FAQ

F Können die Programme Eingaben akzeptieren?
A Ja, aber Sie dürfen nicht nur um Eingabe bitten und die entsprechende Nummer eingeben.

F Sind physikalische Ziffern (keine Daten) zulässig?
A Ja, z LOG10().

F Werden Symbole in Ruby als Literale gezählt?
A Ja.

F Beinhaltet die Punktzahl Zeilenumbrüche zwischen den einzelnen Ausschnitten?
A No.

Q Ist TI-BASIC "zeichenbasiert" genug, um gültig zu sein?
A Ja.

F Zählen falsch und wahr als Zahlenliterale?
A Nein, sie sind akzeptabel.

F Können wir ein Zahlenliteral verwenden, um eine Funktion aufzurufen, wenn dies der einzige Weg ist und die Zahl keinen Einfluss auf die Ausgabe der Funktion hat?
A Ja, wenn dies der normale Weg ist, Code in Ihrer Sprache zu schreiben.

F Meine Sprache geht davon aus, dass am Anfang jedes Programms / Ausdrucks ein [etwas] steht. Muss ich es einschließen, oder sollten meine Ausschnitte nur funktionieren, wenn sie in der Mitte eines Programms / Ausdrucks stehen?
A Sie sollten nur in der Mitte eines Programms / Ausdrucks arbeiten.

F Was ist mit Regex-Literalen?
A Verboten, außer für Sprachen, die nur reguläre Ausdrücke verwenden.

F Ist ein Codeteil akzeptabel, mit dem alle angegebenen Zahlen gedruckt werden können?
A Nein, sie müssen getrennt und voneinander unabhängig sein.

F Darf ich von einem Kesselschild wie int main() {}...oder einem gleichwertigen ausgehen?
A Ja.

F Welche Ausgabedatentypen sind zulässig?
A Beliebiger numerischer Datentyp wie int, float usw.

F Muss ich das Ergebnis jedes Snippets ausdrucken?
A Nein, es reicht aus, das Ergebnis für eine spätere Verwendung zur Verfügung zu stellen.

F Sind voreingestellte Variablen zulässig?
A Ja, und sie werden für jedes Snippet zurückgesetzt (falls geändert).

F Werden π und e als Zahlenliterale betrachtet?
A Nein, Sie dürfen sie verwenden.

F Kann ich 4 und 2 für 42 in verschiedenen Zellen zurückgeben?
A Nein, sie müssen als eine Nummer verbunden sein.

Q Bytes oder Zeichen?
A Bytes, aber Sie können eine beliebige Codepage auswählen.

F Können konstante Funktionen und voreingestellte Variablen wie J's 9:, Actually's 9und Pretzel's 9verwendet werden?
A Ja, wenn der Wortschatz endlich ist (19 für J, 10 für Actually und Pretzel).

Hexagony , 13 Bytes

1
2
3
4
5
6
7
8
9
10
42

Probieren Sie es online!

In Hexagony, 0durch 9sind Funktionen , die die aktuellen Speicher mit 10 multiplizieren, und dann die Zahl durch die Funktionsnamen dargestellt hinzuzufügen. Daher ist das erste Snippet leer, da die Erinnerungen mit beginnen 0.

Wenn zum Beispiel der aktuelle Speicher ist 65, wird durch Ausführen der Funktion 3der aktuelle Speicher erstellt 653.

(Zu den Downvotern: stimmen Sie alles ab, was Sie wollen; ich bin bereit.)

Funktion , 1222 Bytes

Abgesehen von numerischen Literalen gibt es zwei Möglichkeiten, wie ich in Funciton einen (beliebigen) Wert erzeugen kann: stdin- und lambda-Ausdrücke. Stdin ist eine einzelne Box, während ein vollständiger Lambda-Ausdruck mehr Syntax erfordert, also gehe ich mit stdin. Obwohl stdin alles sein kann, funktionieren alle folgenden Funktionen unabhängig davon, welche Eingabe bereitgestellt wird.

Alle hier verwendeten Bibliotheksfunktionen existierten, bevor die Herausforderung veröffentlicht wurde.

0 (40 Byte in UTF-16)

╔╗┌┐
║╟┤└┼┬┐
╚╝└─┘└┘

Hierbei wird die Raw-Syntax für Kleiner als verwendet. Ein Wert ist niemals kleiner als er selbst, daher ist das Ergebnis 0.

1 (52 Byte in UTF-16)

╔╗┌─╖┌─╖
║╟┤⌑╟┤ɕ╟
╚╝╘═╝╘═╝

⌑Gibt eine Lazy-Sequenz zurück, die ein einzelnes Element enthält, und ɕzählt die Anzahl der Elemente. (Die Lazy-Sequenz ist so faul, dass dieses Snippet überhaupt nicht stdin auswertet!)

2 (70 Byte in UTF-16)

╔╗┌─╖┌─╖┌─╖
║╟┤⌑╟┤ʂ╟┤ɕ╟
╚╝╘═╝╘═╝╘═╝

= 2¹. ʂgeneriert alle Teilfolgen einer Folge und wandelt somit eine Folge von n Elementen mit 2ⁿ in eins um.

3 (88 Bytes in UTF-16)

╔╗┌─╖┌─╖┌─╖┌─╖
║╟┤⌑╟┤ʂ╟┤ɕ╟┤♯╟
╚╝╘═╝╘═╝╘═╝╘═╝

= 2 + 1. ♯erhöht einen Wert um 1.

4 (88 Bytes in UTF-16)

╔╗┌─╖┌─╖┌─╖┌─╖
║╟┤⌑╟┤ʂ╟┤ʂ╟┤ɕ╟
╚╝╘═╝╘═╝╘═╝╘═╝

= 2².

5 (106 Bytes in UTF-16)

╔╗┌─╖┌─╖┌─╖┌─╖┌─╖
║╟┤⌑╟┤ʂ╟┤ʂ╟┤ɕ╟┤♯╟
╚╝╘═╝╘═╝╘═╝╘═╝╘═╝

= 4 + 1.

6 (106 Bytes in UTF-16)

╔╗┌─╖┌─╖┌─╖┌─╖┌─╖
║╟┤⌑╟┤ʂ╟┤ɕ╟┤♯╟┤!╟
╚╝╘═╝╘═╝╘═╝╘═╝╘═╝

= 3 Fakultät.

7 (110 Byte in UTF-16)

┌───┐┌─╖┌─╖┌─╖╔╗
│┌─╖├┤ɕ╟┤ʂ╟┤⌑╟╢║
└┤A╟┘╘═╝╘═╝╘═╝╚╝
 ╘╤╝

= A (2, 2) (Ackermann-Funktion).

8 (118 Byte in UTF-16)

┌────┐┌─╖┌─╖┌─╖╔╗
│┌──╖├┤ɕ╟┤ʂ╟┤⌑╟╢║
└┤<<╟┘╘═╝╘═╝╘═╝╚╝
 ╘╤═╝

= 2 << 2 (Verschiebung nach links).

9 (128 Byte in UTF-16)

┌───┐┌─╖┌─╖┌─╖┌─╖╔╗
│┌─╖├┤♯╟┤ɕ╟┤ʂ╟┤⌑╟╢║
└┤×╟┘╘═╝╘═╝╘═╝╘═╝╚╝
 ╘╤╝

= 3 × 3.

10 (146 Byte in UTF-16)

┌───┐┌─╖┌─╖┌─╖┌─╖┌─╖╔╗
│┌─╖├┤♯╟┤ɕ╟┤ʂ╟┤ʂ╟┤⌑╟╢║
└┤+╟┘╘═╝╘═╝╘═╝╘═╝╘═╝╚╝
 ╘╤╝

= 5 + 5.

42 (170 Byte in UTF-16)

┌──────┐┌─╖┌─╖┌─╖┌─╖┌─╖╔╗
│┌─╖┌─╖├┤!╟┤♯╟┤ɕ╟┤ʂ╟┤⌑╟╢║
└┤♯╟┤×╟┘╘═╝╘═╝╘═╝╘═╝╘═╝╚╝
 ╘═╝╘╤╝

= 6 × (6 + 1).

JavaScript, 144 141 140 138 132 125 123 Bytes

Mit Hilfe von @ edc65 , @Sjoerd Job Postmus , @DocMax , @usandfriends , @Charlie Wynn und @ Mwr247 !

result.textContent = [

+[]                          ,// 0  (3 bytes)
-~[]                         ,// 1  (4 bytes)
-~-~[]                       ,// 2  (6 bytes)
-~-~-~[]                     ,// 3  (8 bytes)
-~Math.PI                    ,// 4  (9 bytes)
-~-~Math.PI                  ,// 5  (11 bytes)
-~-~-~Math.PI                ,// 6  (13 bytes)
Date.length                  ,// 7  (11 bytes)
(a=-~-~[])<<a                ,// 8  (13 bytes) = (2 << 2)
(a=~Math.E)*a                ,// 9  (13 bytes) = (-3 * -3)
(a=-~-~[])<<a|a              ,// 10 (15 bytes) = ((2 << 2) | 2)
(a=Date.length)*--a           // 42 (19 bytes) = (7 * 6)

];

<pre id="result"></pre>

Mouse-2002 , 27 26 17 14 Bytes

Die ersten Schnipsel drücken 0-10, und ZR+schiebt 25dann 17und 25 17 + 42 =ist 1.

A
B
C
D
E
F
G
H
I
J
K
ZR+

CJam, 27 24 Bytes

U    e# 0
X    e# 1
Y    e# 2
Z    e# 3
Z)   e# 3 + 1
YZ+  e# 2 + 3
ZZ+  e# 3 + 3
AZ-  e# 10 - 3
YZ#  e# 2³
A(   e# 10 - 1
A    e# 10
EZ*  e# 14 × 3

Danke an @ MartinBüttner für -1 Byte!

Probieren Sie es online!

Brainfuck, 70 Bytes

+
++
+++
++++
+++++
++++++
+++++++
++++++++
+++++++++
++++++++++
--[>+<++++++]>-

Jede Linie muss einzeln verlaufen.

Die ersten 10 sind selbsterklärend: Mit jedem Plus erhöhen wir den Wert der Zelle.

Die 42 ist viel komplexer. Es basiert auf der Tatsache, dass die meisten Brainfuck-Interpreter 8-Bit-Zellen verwenden, was bedeutet, dass alle Operationen auf ihr modulo 256 ausgeführt werden. Die --Zellen # 0 bis 254 werden gesetzt. Dann geben wir eine Schleife ein, die ausgeführt wird, bis Zelle # 0 0 ist. Jede Iteration Fügt 1 zu Zelle 1 und 6 zu Zelle 0 hinzu. Diese Schleife wird 43-mal ausgeführt, also ist Zelle 1 43. Schließlich subtrahieren wir 1 von Zelle 1, um sie zu 42 zu machen.

Unter http://esolangs.org/wiki/Brainfuck_constants habe ich die effizienteste 42 gefunden

Dunkelheit , 339 303 Bytes

Hier scheint die Dunkelheit wirklich . Kapiert? : ~)!

Ohne Drucken (ersetzt das Leerzeichen \sin der ersten Zeile durch, da es sonst nicht angezeigt wird):

\s

█ 

██ 

███ 

████ 

█████ 

██████ 

███████ 

████████ 

█████████ 

██████████ 

██████████████████████████████████████████ 

Mit druck:

■ 

█■ 

██■ 

███■ 

████■ 

█████■ 

██████■ 

███████■ 

████████■ 

█████████■ 

██████████■ 

██████████████████████████████████████████■ 

Jede Zeile muss in diesem Fall einzeln ausgeführt werden, da das Programm im Licht (ein Leerzeichen) endet. Es ist jedoch möglich, dies im selben Programm in eine oder mehrere Zeilen zu schreiben.

Die reguläre Dunkelheit (█) erhöht ein Register um 1, und der Befehl (eine Art Minidunkelheit) gibt den Inhalt des Registers aus.

Perl 5, 86 75 71 66 Bytes

Alle ^Fs sind literale Steuerzeichen (0x06 in ASCII) und daher ein einzelnes Byte.

$[          # array start index, defaults to 0                                  2
!$[         # !0 is 1                                                           3
$^F         # max sys file descriptor number, 2 on all sane systems             2
++$^F       # 2 + 1                                                             4
~-$]        # 5 - 1                                                             4
int$]       # $] is Perl version, int truncates                                 5
length$~    # 1 + 5                                                             8
~~exp$^F    # floor(e^2)                                                        7
$^F<<$^F    # 2 bitshift-right 2                                                6
-!$[+ord$/  # -1 + 10                                                          10
ord$/       # input record separator, newline by default, ord gets ASCII val    5
ord($"^$/)  # 32 + 10                                                          10

Danke an msh210 für das Speichern von 11 Bytes und Dom Hastings für 9 Bytes!

MATL, 30 Bytes

O
l
H
I
K
Kl+
HI*
KYq
HK*
IH^
K:s
IH^:sI-

H, IUnd Ksind vordefinierte Konstanten für 2, 3, und 4 (wie pi). Ound lsind Funktionen, die eine Matrix aus Nullen ( O) oder Einsen ( l) zurückgeben. Die Standardgröße ist 1x1. :macht einen Vektor und ssummiert ihn, K:smacht also einen Vektor von 1 bis 4 und summiert ihn, um 10 zu erhalten. Ist Yqdie n-te Primzahlfunktion, so KYqist die 4. Primzahl, 7.

Prolog, 113 99 Bytes

Schnipsel:

e-e              % 0.0
e/e              % 1.0
e/e+e/e          % 2.0
ceil(e)          % 3
ceil(pi)         % 4
ceil(e*e-e)      % 5
ceil(e+e)        % 6
floor(e*e)       % 7
ceil(e*e)        % 8
ceil(pi*e)       % 9
ceil(pi*pi)      % 10
ceil(e^e*e)      % 42

Kombiniert die mathematischen Konstanten e und pi auf unterschiedliche Weise in int.

Bearbeiten: Speichert 14 Bytes, indem Floats für 0-2 verwendet werden.

PHP, 157 145 91 Bytes

Beim ersten Posting auf Code Golf dachte ich, ich würde es versuchen. Ich werde mich irgendwann verbessern: P Wenn Sie offensichtliche (für Sie) Stellen sehen, an denen ich Zeichen speichern könnte, lassen Sie es mich wissen.

EDIT: Es wurde mir klar, dass ich die Semikolons nicht brauchte, da dies nur Schnipsel sind.

EDIT2: Danke an Blackhole für viele Vorschläge!

LC_ALL
DNS_A
~~M_E
~~M_PI
LOCK_NB 
LC_TIME
LOG_INFO
INI_ALL
IMG_WBMP
SQL_DATE
SQL_TIME
LOG_INFO*INI_ALL

Python 2, 191 159 158 157 156 149 146 Bytes

Bei meiner allerersten Einsendung hoffe ich, dass ich alles richtig gemacht habe! Aufgrund der Zeit, die ich damit verbracht habe, gibt es für einige sicherlich eine bessere.

# 0 | Bytes : 5
int()

# 1 | Bytes : 5
+True

# 2 | Bytes : 6
-~True

# 3 | Bytes : 8
-~-~True

# 4 | Bytes : 10
-~-~-~True

# 5 | Bytes : 12
-~-~-~-~True

# 6 | Bytes : 14
-~-~-~-~-~True

# 7 | Bytes : 16
-~-~-~-~-~-~True

# 8 | Bytes : 15
a=True;a<<a+a+a

# 9 | Bytes : 19
a=True;(a<<a+a+a)+a

# 10 | Bytes : 20
int(`+True`+`int()`)

# 42 | Bytes : 16
~-len(`license`)
# Especially proud of this one !

Total byte count: 146

Vielen Dank an FryAmTheEggman!

C #, keine Verwendung, 234 Bytes

new int()                       // 0
-~new int()                     // 1
-~-~new int()                   // 2
-~-~-~new int()                 // 3
-~-~-~-~new int()               // 4
-~-~-~-~-~new int()             // 5
-~-~-~-~-~-~new int()           // 6
-~-~-~-~-~-~-~new int()         // 7
-~-~-~-~-~-~-~-~new int()       // 8
(int)System.ConsoleKey.Tab      // 9
(int)System.TypeCode.UInt32     // 10
(int)System.ConsoleKey.Print    // 42

Das ist viel langweiliger, als ich ursprünglich gedacht hatte. Ich hatte ziemlich abwechslungsreich Ideen, wie new[]{true}.Lengthund true.GetHashCode()und typeof(int).Name.Lengthund uint.MinValueetc., aber new int()schlagen sie alle.

PowerShell, 147 Byte

Diese werden verwendet +, um Dinge implizit in ganze Zahlen umzuwandeln. Die späteren Zahlen verwenden Enums aus den .Net Framework-Nicht-Fixierungen von PowerShell, die zufällig die richtigen Werte haben.

+$a                          #0, 3 bytes (unset vars are $null, +$null == 0)
+$?                          #1, 3 bytes (bool previous result, default $true, +$true == 1)
$?+$?                        #2, 5 bytes (same as #1, twice)
$?+$?+$?                     #3, 8 bytes (beats [Int][Math]::E)
$?+$?-shl$?                  #4, 11 bytes (-shl is shift-left)
$?+$?+$?+$?+$?               #5, 14 bytes
$?+$?+$?-shl$?               #6, 14 bytes (enum value, + casts to integer)
+[TypeCode]::Int16           #7, 18 bytes
$?+$?-shl$?+$?               #8, 14 bytes
+[consolekey]::tab           #9, 18 bytes
+[TypeCode]::UInt32          #10, 19 bytes
+[consolekey]::Print         #42, 20 bytes

#Total:                      147 bytes

• -~-~-~In JavaScript werden C # - und PHP-Antworten - -bnot - -bnot - -bnotin PowerShell verwendet.

• x^yDie in Perl-Antworten oder x**yin Python oder JavaScript ES7 verwendete Potenzierung wäre[Math]::Pow($x,$y)

• Konstanten e und Pi sind die zeichenlastigen [Math]::Eund[Math]::PI

DC , 35 Bytes

K
KZ
IZ
Iv
EI-
FI-
IZd*
IIZ/
Ivd+
IIv-
IIZ-
IKZ-
I
EdE++

Um die Snippets zu testen, fügen Sie ein hinzu f, um den Stapel zu drucken und übergeben Sie diese Zeichenfolge an dc:

$ echo 'EdE++f' | dc
42

TI-BASIC, 41 Bytes

0 ~ 10:

X
cosh(X
int(e
int(π
-int(-π
int(√(π³
int(π+π
int(e²
int(eπ
int(π²
Xmax

42

int(π²/ecosh(π

In TI-BASIC beginnen alle nicht initialisierten Variablen mit einem Buchstaben bei 0 und Xmax(die rechte Fenstergrenze des Grafikbildschirms) bei 10.

Die mathematische Konstante πist ein Byte , aber ezwei Bytes.

Python 2, 306 275 274 Bytes

Ich benutzte die Tatsache, dass für jedes x (ganze Zahl und nicht 0) der Ausdruck x/x1 ist und spielte mit einigen bitweisen Operationen herum.

Ich habe die Snippets so angepasst, dass sie immer noch den Anforderungen entsprechen (danke @nimi, das hat mir 24 Bytes erspart), aber Sie müssen sie manuell testen. Hier ist der Code und die Anzahl der einzelnen Bytes:

zero.py Bytes: 7
len({})
--------------------------
one.py  Bytes: 12
r=id(id)
r/r
--------------------------
two.py  Bytes: 17
r=id(id)
-(~r/r)
--------------------------
three.py    Bytes: 20
r=id(id)
-(~r/r)|r/r
--------------------------
four.py Bytes: 20
r=~id(id)/id(id)
r*r
--------------------------
five.py Bytes: 26
r=~id(id)/id(id)
(r*r)|r/r
--------------------------
six.py  Bytes: 25
r=~id(id)/id(id)
(r*r)|-r
--------------------------
seven.py    Bytes: 27
r=~id(id)/id(id)
-~(r*r|-r)
--------------------------
eight.py    Bytes: 24
r=-(~id(id)/id(id))
r<<r
--------------------------
nine.py Bytes: 29
r=-(~id(id)/id(id))
r-~(r<<r)
--------------------------
ten.py  Bytes: 31
r=~id(id)/id(id)
-r*((r*r)|r/r)
--------------------------
answer.py   Bytes: 37
r=-(~id(id)/id(id))
(r<<r*r)|(r<<r)|r
--------------------------
Total byte count: 274

Math ++, insgesamt 92 Bytes

0 (1 Byte): a

1 (2 Bytes):!a

2 (3 Bytes):_$e

3 (4 Bytes): _$pi

4 (7 Bytes): _$e+_$e

5 (8 Bytes): _($e+$e)

6 (9 Bytes): _$pi+_$pi

7 (8 Bytes): _($e*$e)

8 (9 Bytes): _($e*$pi)

9 (10 Bytes): _($pi*$pi)

10 (12 Bytes): _$e*_($e+$e)

42 (19 Bytes): _($pi+$pi)*_($e*$e)

Javascript (Browser Env), 155 136 130 Bytes

+[]
-~[]
-~-~[]
-~-~-~[]
-~-~-~-~[]
-~-~-~-~-~[]
-~-~-~[]<<-~[]
-~-~-~-~-~-~-~[]
-~[]<<-~-~-~[]
~(~[]+[]+-[])
-~[]+[]+-[]
-~(top+top.s).length // Requires browser environment

Dank an:
@Ismael Miguel : 155 -> 136 -> 130 Bytes

Im Ernst, 39 33 Bytes

Sachen in Klammern sind Erklärungen:

 (single space, pushes size of stack, which is 0 at program start)
 u (space pushes 0, u adds 1 (1))
 ⌐ (space pushes 0, ⌐ adds 2 (2))
 u⌐ (space pushes 0, u adds 1 (1), ⌐ adds 2 (3))
 ⌐⌐ (space pushes 0, ⌐⌐ adds 2 twice (4))
 ⌐P (space pushes 0, ⌐ adds 2 (2), P pushes the 2nd prime (5))
Hl▓ (H pushes "Hello, World!", l pushes length (13), ▓ pushes pi(13) (6))
QlP (Q pushes "QlP", l pushes length (3), P pushes the 3rd prime (7))
Ql╙ (Q pushes "QlP", l pushes length (3), ╙ pushes 2**3 (8))
úl▓ (ú pushes the lowercase English alphabet, l pushes length (26), ▓ pushes pi(26) (9))
 u╤ (space pushes 0, u adds 1 (1), ╤ pushes 10**1 (10))
HlPD (H pushes "Hello, World!", l pushes length (13), P pushes the 13th prime (43), D subtracts 1 (42))

Hexdumps von Programmen:

20
2075
20a9
2075a9
20a9a9
20a950
486cb2
516c50
516cd3
a36cb2
2075d1
486c5044

Danke an quintopia für 6 Bytes!

Gleichstrom, 42 Bytes

K
zz
OZ
zzz+
OZd*
OdZ/
zzzz*
Ozz+-
OdZ-
Oz-
O
Od+dz++

Ergebnisse

0
1
2
3
4
5
6
7
8
9
10
42

Es gibt nicht viele Möglichkeiten, mit dc neue Zahlen zu generieren. Ich benutze O: Ausgangsbasis, anfänglich 10; K: Präzision, anfänglich 0; zStapeltiefe, anfänglich 0; Zsignifikante Ziffern des Operanden. Wir kombinieren diese mit den üblichen arithmetischen Operatoren.

Testprogramm

#!/bin/bash

progs=(                                         \
    "K"                                         \
    "zz"                                        \
    "OZ"                                        \
    "zzz+"                                      \
    "OZd*"                                      \
    "OdZ/"                                      \
    "zzzz*"                                     \
    "Ozz+-"                                     \
    "OdZ-"                                      \
    "Oz-"                                       \
    "O"                                         \
    "Od+dz++"                                   \
)

a=0
results=()
for i in "${progs[@]}"
do
    results+=($(dc -e "${i}p"))
    (( a+=${#i} ))
done

echo "#dc, $a bytes"
echo
printf '    %s\n' "${progs[@]}"
echo
echo '##Results'
echo
printf '    %s\n' "${results[@]}"

Mathematica, 101 Bytes

a-a
a/a
⌊E⌋
⌈E⌉
⌈π⌉
⌊E+E⌋
⌈E+E⌉
⌊E*E⌋
⌈E*E⌉
⌈E*π⌉
⌈π*π⌉
⌊π*π^π/E⌋

Ich bin mir ziemlich sicher, dass einige davon nicht optimal sind. Diese runden Klammern sind sehr teuer.

Aus Gründen der Einheitlichkeit könnten die ersten beide auch sein E-Eund E/Enatürlich, aber ich dachte , es recht geschicktes ist zu bekommen 0und 1aus einer Berechnung mit undefinierten Variablen.

Japt , 34 33 30 Bytes

Dank @ThomasKwa 1 Byte gespart

T
°T
C-A
D-A
E-A
F-A
G-A
°G-A
Iq
´A
A
H+A

Die verschiedenen Zeichen bedeuten Folgendes:

T    0
A    10
B    11
C    12
D    13
E    14
F    15
G    16
H    32
I    64
q    sqrt on numbers
°    ++
´    --

Marbelous , 98 Bytes

Es ist nicht sonderlich aufregend, sondern basiert auf den ?nGeräten, die jede Kugel in einen zufälligen Wert im Bereich von 0..n (einschließlich) ?0verwandeln. Ein Nebeneffekt davon ist, dass jede Kugel unabhängig von der Eingabe in eine 0 verwandelt wird. Ich denke, die Verwendung von Literalen ist zulässig, da der Wert das Ergebnis nicht beeinflusst und es in Marbelous keine andere Möglichkeit gibt, eine Funktion einmal aufzurufen.

0:

00  # A hexadicemal literal: value 0
?0  # Turn any marble into a random value from the range 0..0 (inclusive)

1:

00
?0
+1  # increment by one

...

9:

00
?0
+9

10:

00
?0
+A  # increment by 10

42

00
?0
+L  # increment by 21
+L

> <> 86 Bytes

• 0: ln;
• 1: lln;
• 2: llln;
• 3: lll+n;
• 4: lll:+n;
• 5: llll+n;
• 6: llll++n;oderllll:+n;
• 7: lllll+n;
• 8: lllll:+n;
• 9: lllll++n;oderllllll+n;
• 10: llll+:+n;oderlll:l+*n;
• 42 llll*ll+*n;

Verlässt sich auf die Stapelgröße, um die Literale zu erhalten.

MS Excel-Formeln, 163 151 150 143 Bytes

Nicht gerade eine Programmiersprache, aber hier geht es ...

0:  -Z9                         (03 bytes)
1:  N(TRUE)                     (07 bytes)
2:  TYPE(T(Z9))                 (11 bytes)
3:  TRUNC(PI())                 (11 bytes)
4:  TYPE(TRUE)                  (10 bytes)
5:  ODD(PI())                   (09 bytes)
6:  FACT(PI())                  (10 bytes)
7:  ODD(PI()+PI())              (14 bytes)
8:  EVEN(PI()+PI())             (15 bytes)
9:  TRUNC(PI()*PI())            (16 bytes)
10: EVEN(PI()*PI())             (15 bytes)
42: EVEN(CODE(-PI())-PI())      (22 bytes)

PI()wird in den meisten Fällen verwendet, da dies der kürzere (mir bekannte) Weg ist, einen numerischen Wert einzuführen, ohne ein Zahlen- oder Zeichenfolgenliteral zu verwenden. Nkonvertiert verschiedene Dinge (einschließlich Boolescher Werte) in Zahlen und Tkonvertiert verschiedene Dinge in Text. TYPEgibt 2 für ein Textargument und 4 für ein Boolesches Argument zurück. TRUNCverwirft gebrochene Teile (dh rundet positive Zahlen ab), EVENrundet auf die nächste gerade Zahl und ODDrundet auf die nächste ungerade Zahl auf. CODE(-PI())ist der ASCII-Code des ersten Zeichens der Umwandlung in Text von -π, dh 45 (für "-").

BEARBEITEN: Gleichheitszeichen aus der Byteanzahl (-12!) Entfernt - wie von N comments in den Kommentaren hervorgehoben, sollten sie nicht enthalten sein.

BEARBEITEN 2: Angenommen, der Rest des Arbeitsblatts ist leer, ist es möglich, einen Verweis auf eine leere Zelle als Null zu verwenden (ebenfalls vorgeschlagen von Nᴮᶻ), vorausgesetzt, wir schließen ein Minuszeichen ein (oder verwenden es in einem anderen numerischen Ausdruck), um das Problem zu lösen Mehrdeutigkeit eingeben.

DUP , 68 Bytes

[
 [
  [
[)]!
[ )]!
[  )]!
[)~_]!
[ )~_]!
[  )~_]!
[   )~_]!
[)$+]!
[ )$+~_$+]!

Try it here.

Es gibt viele Möglichkeiten, dies zu tun, aber ich missbrauche den Rückgabestapel für diesen.

Erläuterung

Um dies vollständig herauszufinden, müssen Sie das Verhalten von DUP in Bezug auf Lambdas verstehen. Anstatt das Lambda selbst auf den Stapel zu legen, legt es die aktuelle IP tatsächlich auf den Stapel, wenn das Lambda erkannt wird. Das kann die ersten 3 Schnipsel erklären, bei denen es sich um Lambdas handelt.

Die nächsten Snippets verwenden den Rückgabestapel. Wenn !ausgeführt wird, wird die aktuelle IP auf den Rückgabestapel verschoben, und der obere Rand des Stapels wird als neue IP festgelegt, um die Lambda-Ausführung zu starten. )Fügt eine Zahl aus dem Rückgabestapel in den Datenstapel ein.

Das ist so ziemlich genug, um den Rest der Schnipsel zu erklären. Wenn Sie es immer noch nicht bekommen, denken Sie daran, dass der StepKnopf ziemlich praktisch ist!

05AB1E, 40 38 24 Bytes

¾
X
Y
XÌ
Y·
T;
T;>
T;Ì
TÍ
T<
T
žwT+

• Drücken Sie counter_variable
• Drücken Sie 1
• Drücken Sie 2
• Drücken Sie 1 + 2
• Drücken Sie 2 * 2
• Drücken Sie 10/2
• Drücken Sie (10/2) +1
• Drücken Sie (10/2) +2
• Drücken Sie 10-2
• Drücken Sie 10-1
• Drücken Sie 10
• Drücken Sie 32, 10 und addieren Sie

D1ffe7e45e , 112

0
02
020
0202
02020
020202
0202020
02020202
020202020
0202020202
02020202020
202020202020202020202020202020202020202020

Jede Zeile ist ein anderes Snippet.

Die Zahlen im Programm zählen nicht als Zahlenliterale, da sie nur als Befehle verwendet werden.

Das letzte kann definitiv mehr golfen werden.

EDIT: Ich habe den Interpreter zum Laufen gebracht und alle Schnipsel funktionieren. Wenn Sie selbst testen möchten, fügen Sie 0f0fam Ende des Snippets hinzu, damit das Programm beendet wird.

Pyth, 35 34 33 Bytes

-1 Byte von @Mimarik

Für einige Programme gibt es eine Reihe von Möglichkeiten.

0, 1 Byte

Z

1, 2 Bytes

hZ
!Z

2, 3 Bytes

hhZ
eCG
eCd
lyd
lyb
lyN

3, 3 Bytes

l`d

4, 3 Bytes

l`b
eCN

5, 4 Bytes

hl`b
telG

6, 3 Bytes

elG

7, 4 Bytes

tttT
helG

8, 3 Bytes

ttT

9, 2 Bytes

tT

10, 1 Byte

T

42, 4 Bytes

yhyT

All dies beinhaltet entweder grundlegende double ( y) -, +1 ( h) - und -1 ( t) -Befehle oder l(Länge eines Strings). Die Z-Variable wird auf Null initialisiert.

Für 5 bwird ein Zeilenumbruchzeichen initialisiert. Backtick ergibt "\n"(einschließlich der Anführungszeichen, und die Länge dieser Zeichenfolge beträgt 4.

Probieren Sie sie hier aus !