Se ti piace, considera di partecipare a:

• The Official Dyalog APL 2016 Year Game

• Il mensile Dyalog APL 2017 Code Golf Challenge

Crea 12 snippet / espressioni , nella stessa lingua, che generano rispettivamente i numeri da 0 a 10 e 42, ma senza scrivere alcun dato letterale numerico, stringa o carattere.

I dati incorporati , come PI()e ALPHABET(), vanno bene, così come le costanti U, X, Y, Z e A di CJam e BLEND, CHORD, CENTER, BREAK e LINES di Processing.

Ogni frammento deve essere in grado di resistere da solo, cioè potrebbe non essere interdipendente. Tuttavia, all'interno di un singolo frammento, è possibile assegnare una variabile e utilizzarla liberamente, purché si faccia riferimento ad essa direttamente per nome e non tramite una stringa contenente il suo nome.

Tutti i frammenti devono essere validi sul computer del mittente al momento dell'invio (come riportato da SE), ma potrebbero non fare affidamento su condizioni locali insolite come il numero di file in una directory, la data o l'ora esatta o l'input specifico dell'utente .

Esempi di frammenti validi

3: INT(LOG10(YEAR(TODAY()))) perché rimane vero nel prossimo futuro
4: CUBICROOT(LEN(CHARACTERSET())) perché un set di caratteri di 256 lettere è molto comune
8: SQRT(SYSTEMTYPE()) perché i sistemi a 64 bit sono molto comuni

Esempi di frammenti non validi

5: LEN(USERNAME()) perché la maggior parte delle persone non usa "Admin" come login :-)
9: LOG10(SYSTEMMEMORY()) perché funziona solo su sistemi con esattamente 1 GB di memoria
42: CODE("*") perché contiene una stringa / carattere letterale

Il risultato di ciascun frammento deve risultare in un numero effettivo (valore, int, float, ecc.) Che può essere utilizzato per ulteriori calcoli utilizzando la stessa lingua dello snippet, ovvero non una stringa di testo che rappresenta quel numero.

Sono ammesse solo le lingue basate sui caratteri.

Il punteggio è il conteggio totale dei byte di tutti i 12 frammenti combinati. Le newline che separano i frammenti non vengono conteggiate.

Si noti che le regole di cui sopra potrebbero impedire la partecipazione di alcune lingue, anche se sono complete.

FAQ

D I programmi possono accettare input?
A Sì, ma potresti non solo chiedere un input e inserire il numero corrispondente.

D Sono consentite cifre fisiche (non dati)?
A Sì, ad es LOG10().

D I simboli in Ruby contano come letterali?
A Sì.

D Il punteggio include nuove righe tra ogni frammento?
Un no

D TI-BASIC è "basato sui caratteri" abbastanza per essere valido?
A Sì.

D Falso e vero contano come letterali numerici?
A No, sono accettabili.

D Possiamo usare un numero letterale per chiamare una funzione se questo è l'unico modo e il numero non influenza l'output della funzione?
A Sì, se questo è il modo normale di scrivere il codice nella tua lingua.

D La mia lingua presuppone che ci sia un [qualcosa] all'inizio di ogni programma / espressione. Devo includerlo o i miei frammenti dovrebbero funzionare solo se inseriti nel mezzo di un programma / espressione?
A Dovrebbero funzionare solo nel mezzo di un programma / espressione.

D Che dire dei letterali regex?
A Proibito, ad eccezione delle lingue che fanno solo regex.

D È accettabile un pezzo di codice in grado di stampare tutti i numeri specificati?
A No, devono essere separati e reciprocamente indipendenti.

D Posso assumere una caldaia simile int main() {}...o equivalente?
A Sì.

D Quali tipi di dati di output sono consentiti?
A Qualsiasi tipo di dati numerico, come int, float, ecc.

D Devo stampare il risultato di ogni frammento?
A No, è sufficiente rendere il risultato disponibile per l'uso successivo.

D Sono consentite le variabili preimpostate?
A Sì, e vengono ripristinati (se modificati) per ogni frammento.

D π ed e sono considerati numeri letterali?
A No, puoi usarli.

D Posso restituire 4 e 2 in celle diverse per 42?
A No, devono essere collegati come un numero.

Q Byte o caratteri?
A Byte, ma è possibile scegliere qualsiasi tabella codici desiderata.

D È possibile utilizzare funzioni costanti e variabili preimpostate come J's 9:, Actually 9e Pretzel 9?
A Sì, se il vocabolario è finito (19 per J, 10 per Actually e Pretzel).

Esagonia , 13 byte

1
2
3
4
5
6
7
8
9
10
42

Provalo online!

In Hexagony, 0through 9sono funzioni che moltiplicano la memoria corrente per 10 e quindi aggiungono il numero rappresentato dal nome della funzione. Pertanto, il primo frammento è vuoto quando i ricordi iniziano come 0.

Ad esempio, se la memoria corrente è 65, l'esecuzione della funzione 3renderà la memoria corrente 653.

(Ai votanti: vota tutto ciò che vuoi; sono pronto.)

Funciton , 1222 byte

Oltre ai letterali numerici, ci sono due modi in cui posso produrre un valore (qualsiasi valore) in Funciton: espressioni stdin e lambda. Stdin è una casella singola mentre un'espressione lambda completa richiede più sintassi, quindi vado con stdin. Tuttavia, sebbene stdin possa essere qualsiasi cosa, tutte le seguenti operazioni funzionano indipendentemente dall'input fornito.

Tutte le funzioni di libreria utilizzate qui esistevano prima della pubblicazione della sfida.

0 (40 byte in UTF-16)

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

Questo utilizza la sintassi non elaborata per minore di. Un valore non è mai inferiore a se stesso, quindi il risultato è 0.

1 (52 byte in UTF-16)

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

⌑restituisce una sequenza pigra contenente un singolo elemento e ɕconta il numero di elementi. (La sequenza pigra è abbastanza pigra che questo frammento in realtà non valuta affatto lo stdin!)

2 (70 byte in UTF-16)

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

= 2¹. ʂgenera tutte le sottosequenze di una sequenza e quindi trasforma una sequenza di n elementi in uno con 2ⁿ.

3 (88 byte in UTF-16)

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

= 2 + 1. ♯incrementa un valore di 1.

4 (88 byte in UTF-16)

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

= 2².

5 (106 byte in UTF-16)

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

= 4 + 1.

6 (106 byte in UTF-16)

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

= 3 fattoriale.

7 (110 byte in UTF-16)

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

= A (2, 2) (funzione di Ackermann).

8 (118 byte in UTF-16)

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

= 2 << 2 (maiusc-sinistra).

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 byte

Con l'aiuto di @ edc65 , @Sjoerd Job Postmus , @DocMax , @usandfriends , @Charlie Wynn e @ 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 byte

I primi frammenti spingono 0-10, e ZR+spinge 25quindi 17ed 25 17 + 42 =è 1.

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

CJam, 27 24 byte

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

Grazie a @ MartinBüttner per -1 byte!

Provalo online!

Brainfuck, 70 byte

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

Ogni riga deve essere eseguita singolarmente.

I primi 10 sono autoesplicativi: incrementiamo il valore della cella tramite ogni plus.

Il 42 è molto più complesso. Si basa sul fatto che l'interprete più brainfuck usa celle a 8 bit, il che significa che tutte le operazioni su di esso sono eseguite modulo 256. Il --set di celle da 0 a 254. Quindi entriamo in un ciclo che funziona fino a quando la cella # 0 è 0. Ogni iterazione aggiunge 1 alla cella # 1 e aggiunge 6 alla cella # 0. Questo loop viene eseguito 43 volte, quindi la cella n. 1 è 43. Infine, sottraggiamo 1 dalla cella n. 1 per renderlo 42.

Ho ottenuto i 42 più efficienti mai trovati da http://esolangs.org/wiki/Brainfuck_constants

Oscurità , 339 303 byte

Qui è dove l'oscurità brilla davvero . Prendilo? : ~)!

Senza stampa (sostituito lo spazio con \snella prima riga poiché non mostrerà diversamente):

\s

█ 

██ 

███ 

████ 

█████ 

██████ 

███████ 

████████ 

█████████ 

██████████ 

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

Con la stampa:

■ 

█■ 

██■ 

███■ 

████■ 

█████■ 

██████■ 

███████■ 

████████■ 

█████████■ 

██████████■ 

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

Ogni riga deve essere eseguita singolarmente in questo caso poiché il programma termina alla luce (uno spazio). Tuttavia, è possibile scrivere questo su una o più righe nello stesso programma.

L'oscurità regolare (█) incrementa un registro di 1 e l'istruzione ■ (una sorta di mini-oscurità) genera il contenuto del registro.

Perl 5, 86 75 71 66 byte

Tutti gli ^Fs sono caratteri di controllo letterali (0x06 in ASCII) e quindi un singolo 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

Grazie a msh210 per il salvataggio di 11 byte e Dom Hastings per 9 byte!

MATL, 30 byte

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

H, Ie Ksono costanti predefinite per 2, 3 e 4 (come pi). Oe lsono funzioni che restituiscono una matrice di zeri ( O) o uni ( l), la dimensione predefinita è 1x1. :crea un vettore e lo ssomma, quindi K:screa un vettore da 1 a 4 e lo somma per ottenere 10. Yqè la funzione n-esima per primo, così KYqcome la quarta perfezione, 7.

Prolog, 113 99 byte

Frammenti:

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

Combina le costanti matematiche e e pi in diversi modi convertiti in int.

Modifica: salvato 14 byte utilizzando float per 0-2.

PHP, 157 145 91 byte

Pubblicando per la prima volta su Code Golf, ho pensato di provarci. Alla fine migliorerò: P Se vedi dei punti (per te) ovvi in ​​cui potrei salvare i personaggi, fammi sapere.

EDIT: realizzato che non avevo bisogno dei punti e virgola, poiché questi sono solo frammenti.

EDIT2: Grazie a Blackhole per molti suggerimenti!

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 byte

La mia prima presentazione in assoluto, spero di aver fatto tutto bene! Sulla base del tempo che ho trascorso su questo, credo che ce ne sia sicuramente uno migliore per alcuni di loro.

# 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

Mille grazie a FryAmTheEggman!

C #, nessun utilizzo, 234 byte

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

Questo è molto più noioso di quanto pensassi inizialmente. Ho avuto le idee abbastanza diverse, come ad esempio new[]{true}.Lengthe true.GetHashCode()ed typeof(int).Name.Lengthe uint.MinValuecosì via, ma new int()batterli tutti.

PowerShell, 147 byte

Usano +implicitamente il cast di cose in numeri interi. I numeri successivi usano Enum dalle dissociazioni .Net Framework di PowerShell che hanno i valori giusti.

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

• -~-~-~usato nelle risposte JavaScript, C # e PHP sarebbe - -bnot - -bnot - -bnotin PowerShell.

• x^yesponenziale usato nelle risposte Perl, o x**yin Python o JavaScript ES7, sarebbe[Math]::Pow($x,$y)

• costanti e e Pi sono il carattere pesante [Math]::Ee[Math]::PI

DC , 35 byte

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

Per testare gli snippet aggiungi a fper stampare lo stack e passare quella stringa a dc:

$ echo 'EdE++f' | dc
42

TI-BASIC, 41 byte

0 ~ 10:

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

42:

int(π²/ecosh(π

In TI-BASIC, tutte le variabili non inizializzate a lettera singola iniziano da 0 e Xmax (il limite della finestra destra della schermata del grafico) inizia da 10.

La costante matematica πè un byte , ma eè due byte.

Python 2, 306 275 274 byte

Ho usato il fatto che per ogni x (intero e non 0) l'espressione è x/xuguale a 1 e ho giocato con alcune operazioni bit per bit.

Ho modificato gli snippet in modo che soddisfino ancora i requisiti (grazie a @nimi questo mi ha salvato 24 byte), ma devi testarli manualmente. Ecco il codice e i conteggi dei singoli byte:

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 ++, 92 byte in totale

0 (1 byte): a

1 (2 byte):!a

2 (3 byte):_$e

3 (4 byte): _$pi

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

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

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

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

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

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

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

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

Javascript (Browser Env), 155 136 130 byte

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

Grazie a:
@Ismael Miguel : 155 -> 136 -> 130 byte

Scherzi a parte, 39 33 byte

Le cose tra parentesi sono le spiegazioni:

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

Hexdump di programmi:

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

Grazie a quintopia per 6 byte!

dc, 42 byte

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

risultati

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

Non ci sono molti modi per generare nuovi numeri con dc. Uso O: base di output, inizialmente 10; K: precisione, inizialmente 0; zprofondità dello stack, inizialmente 0; Zcifre significative dell'operando. Li combiniamo con i soliti operatori aritmetici.

Programma di test

#!/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 byte

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

Sono abbastanza sicuro che alcuni di questi non siano ottimali. Quelle staffe di arrotondamento sono davvero costose.

Per coerenza, anche i primi due potrebbero essere E-Ee E/E, ovviamente, ma ho pensato che fosse abbastanza ingegnoso ottenere 0e 1da un calcolo con variabili indefinite.

Japt , 34 33 30 byte

1 byte salvato grazie a @ThomasKwa

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

Ecco cosa significa ciascuno dei diversi caratteri:

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 byte

Non terribilmente eccitante, si basa sui ?ndispositivi che trasformano qualsiasi marmo in un valore casuale nell'intervallo 0..n (incluso) un effetto collaterale di questo che ?0trasforma qualsiasi marmo in uno 0 indipendentemente dall'input. Penso che l'uso dei letterali sia permesso perché il valore non influenza il risultato e non c'è altro modo di chiamare una funzione una volta in Marbelous.

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 byte

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

Si affida alle dimensioni dello stack per ottenere i suoi valori letterali.

Formule MS Excel, 163 151 150 143 byte

Non esattamente un linguaggio di programmazione, ma qui va ...

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()viene utilizzato nella maggior parte dei casi in quanto è il modo più breve (di cui sono a conoscenza) di introdurre un valore numerico senza utilizzare un numero o una stringa letterale. Nconverte varie cose (compresi i booleani) in numeri e Tconverte varie cose in testo. TYPErestituisce 2 per un argomento di testo e 4 per un argomento booleano. TRUNCscarta la parte frazionaria (ovvero arrotonda i numeri positivi verso il basso), EVENarrotonda per eccesso al prossimo numero pari e ODDarrotonda per eccesso al prossimo numero dispari. CODE(-PI())è il codice ASCII del primo carattere della conversione in testo di -π, ovvero 45 (per "-").

EDIT: Rimossi segni uguali dal conteggio dei byte (-12!) - come sottolineato da Nᴮᶻ nei commenti, non dovrebbero essere inclusi.

EDIT 2: Supponendo che il resto del foglio di lavoro sia vuoto, è possibile utilizzare un riferimento a una cella vuota come zero (di nuovo, suggerito da Nᴮᶻ) a condizione che includiamo un segno meno (o usarlo in un'altra espressione numerica) per risolvere digitare ambiguità.

DUP , 68 byte

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

Try it here.

Ci sono MOLTI modi per farlo, ma sto abusando dello stack di ritorno per questo.

Spiegazione

Per capirlo appieno, è necessario comprendere il comportamento di DUP nei confronti dei lambda. Invece di spingere lo lambda stesso nello stack, in realtà spinge l'IP corrente nello stack quando viene rilevato lo lambda. Questo può spiegare i primi 3 frammenti, che coinvolgono lambda.

I frammenti successivi usano lo stack di ritorno. Quando !viene eseguito, l'IP corrente viene inviato allo stack di ritorno e la parte superiore dello stack viene impostata come nuovo IP per avviare l'esecuzione lambda. )fa apparire un numero dallo stack di ritorno nello stack di dati.

È abbastanza per spiegare il resto dei frammenti. Se ancora non lo capisci, tieni presente che il Steppulsante è abbastanza utile!

05AB1E, 40 38 24 byte

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

• Push counter_variable
• Premere 1
• Premere 2
• Premere 1 + 2
• Premere 2 * 2
• Premere 10/2
• Premere (10/2) +1
• Premere (10/2) +2
• Spingere 10-2
• Spingere 10-1
• Premere 10
• Premere 32, 10, aggiungere

D1ffe7e45e , 112

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

Ogni riga è un frammento diverso.

I numeri nel programma non contano come numeri letterali poiché sono usati solo come comandi.

L'ultimo può sicuramente essere giocato a golf di più.

EDIT: ho fatto funzionare l'interprete e tutti gli snippet funzionano. Se desideri testare te stesso, aggiungi 0f0falla fine dello snippet in modo che il programma termini.

Pyth, 35 34 33 byte

-1 byte di @Mimarik

Esistono numerose possibilità per alcuni programmi.

0, 1 byte

Z

1, 2 byte

hZ
!Z

2, 3 byte

hhZ
eCG
eCd
lyd
lyb
lyN

3, 3 byte

l`d

4, 3 byte

l`b
eCN

5, 4 byte

hl`b
telG

6, 3 byte

elG

7, 4 byte

tttT
helG

8, 3 byte

ttT

9, 2 byte

tT

10, 1 byte

T

42, 4 byte

yhyT

Tutti questi coinvolgono comandi double ( y), +1 ( h) e -1 ( t) di base o l(lunghezza di una stringa). La variabile Z viene inizializzata su zero.

Per 5, bviene inizializzato su un carattere di nuova riga. Backtick dà"\n" (comprese le virgolette e la lunghezza di quella stringa è 4.

Provali qui !