Si cela vous convient, envisagez de participer à:

• Le jeu officiel Dyalog APL 2016 Year

• Le mensuel Dyalog APL 2017 Code Golf Challenge

Faire 12 extraits / expressions , dans la même langue, qui génèrent les nombres de 0 à 10 et 42 respectivement, mais sans écrire de données littérales numériques, chaînes ou caractères.

Données intégrées, comme PI()etALPHABET() , sont correctes, et le sont, par exemple, les constantes U, X, Y, Z et A de CJam, et les processus BLEND, CHORD, CENTER, BREAK et LINES de Processing.

Chaque extrait doit pouvoir être autonome, c'est-à-dire qu'il peut ne pas être interdépendant. Cependant, dans un seul extrait de code, vous pouvez affecter une variable et l'utiliser librement, tant que vous vous y référez directement par son nom, et non par le biais d'une chaîne contenant son nom.

Tous les extraits doivent être valides sur l'ordinateur de l'émetteur au moment de la soumission (comme indiqué par SE), mais ne peuvent pas dépendre de conditions locales inhabituelles telles que le nombre de fichiers dans un répertoire, la date ou l'heure exacte ou les informations spécifiques de l'utilisateur. .

Exemples d'extraits valides

3: INT(LOG10(YEAR(TODAY()))) parce qu'il reste vrai dans un avenir prévisible
4: CUBICROOT(LEN(CHARACTERSET())) parce qu'un jeu de caractères de 256 lettres est très courant
8: SQRT(SYSTEMTYPE()) parce que les systèmes 64 bits sont très courants

Exemples d'extraits non valides

5: LEN(USERNAME()) parce que la plupart des gens n'utilisent pas «Admin» comme identifiant :-)
9: LOG10(SYSTEMMEMORY()) parce que cela ne fonctionne que sur des systèmes avec exactement 1 Go de mémoire
42: CODE("*") parce qu'il contient un littéral chaîne / caractère

Le résultat de chaque extrait doit donner un nombre réel (value, int, float, etc.) pouvant être utilisé pour des calculs ultérieurs utilisant le même langage que l'extrait, c'est-à-dire pas une chaîne de texte représentant ce nombre.

Seules les langues basées sur les caractères sont autorisées.

Le score est le nombre total d'octets de tous les 12 extraits combinés. Les nouvelles lignes séparant les extraits ne sont pas comptées dans.

Notez que les règles ci-dessus peuvent empêcher certaines langues de participer, même si elles sont complètes.

questions - réponses

Q Les programmes peuvent-ils accepter n'importe quelle entrée?
R Oui, mais vous ne pouvez pas simplement demander une entrée et entrer le numéro correspondant.

Q Les chiffres physiques (autres que les données) sont-ils autorisés?
A oui, par exemple LOG10().

Q Les symboles en Ruby comptent-ils comme des littéraux?
Un oui.

Q Le score inclut-il des nouvelles lignes entre chaque extrait?
Un no

Q TI-BASIC est-il suffisamment "basé sur les caractères" pour être valide?
Un oui.

Q Est-ce que false et true comptent comme des littéraux numériques?
R Non, ils sont acceptables.

Q Pouvons-nous utiliser un littéral numérique pour appeler une fonction si c'est le seul moyen et que le nombre n'influence pas la sortie de la fonction?
R Oui, si c'est la méthode normale pour écrire du code dans votre langue.

Q Ma langue suppose qu'il y a un [quelque chose] au début de chaque programme / expression. Dois-je l'inclure ou mes extraits doivent-ils uniquement fonctionner s'ils sont placés au milieu d'un programme / d'une expression?
A Ils devraient juste travailler au milieu d'un programme / d'une expression.

Q Qu'en est-il des littéraux de regex?
A Interdit, sauf pour les langues qui ne font que des expressions rationnelles.

Q Est-ce qu'un code pouvant imprimer tous les numéros spécifiés est acceptable?
R Non, ils doivent être séparés et mutuellement indépendants.

Q Puis-je supposer un passe-partout similaire int main() {}...ou équivalent?
Un oui.

Q Quels types de données de sortie sont autorisés?
Un type de données numérique quelconque, comme int, float, etc.

Q Dois-je imprimer le résultat de chaque extrait?
R Non, il suffit de rendre le résultat disponible pour une utilisation ultérieure.

Q Les variables prédéfinies sont-elles autorisées?
A Oui, et ils sont réinitialisés (si modifiés) pour chaque extrait.

Q Est-ce que π et e sont considérés comme des littéraux numériques?
R Non, vous pouvez les utiliser.

Q Puis-je retourner 4 et 2 dans des cellules différentes pour 42?
R Non, ils doivent être connectés en un seul numéro.

Q octets ou caractères?
Un octet, mais vous pouvez choisir la page de code souhaitée.

Q Peut - on utiliser des fonctions constantes et des variables prédéfinies telles que J 9:, Actually 9et Pretzel 9?
R Oui, si le vocabulaire est fini (19 pour J, 10 pour Actually et Bretzel).

Hexagonie , 13 octets

1
2
3
4
5
6
sept
8
9
dix
42

Essayez-le en ligne!

En hexagone, les fonctions0 traversantes multiplient la mémoire actuelle par 10, puis ajoutent le nombre représenté par le nom de la fonction. Par conséquent, le premier extrait est vide car les souvenirs commencent par .90

Par exemple, si la mémoire actuelle est 65, l'exécution de la fonction 3créera la mémoire actuelle 653.

(Aux votants descendants: votez tous ce que vous voulez, je suis prêt.)

Fonction , 1222 octets

Outre les littéraux numériques, il existe deux façons de produire une valeur (n'importe quelle valeur) dans Funciton: les expressions stdin et lambda. Stdin est une boîte simple alors qu'une expression lambda complète nécessite plus de syntaxe, alors j'utilise stdin. Cependant, bien que stdin puisse être n'importe quoi, tous les travaux suivants fonctionnent, quel que soit le type d'entrée fourni.

Toutes les fonctions de bibliothèque utilisées ici existaient avant la publication du défi.

0 (40 octets en UTF-16)

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

Ceci utilise la syntaxe brute pour moins que. Une valeur n'est jamais inférieure à elle-même, le résultat est donc 0.

1 (52 octets en UTF-16)

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

⌑renvoie une séquence lente contenant un seul élément et ɕcompte le nombre d'éléments. (La séquence paresseuse est suffisamment paresseuse pour que cet extrait de code n'évalue pas stdin du tout!)

2 (70 octets en UTF-16)

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

= 2¹. ʂgénère toutes les sous-séquences d'une séquence et transforme ainsi une séquence de n éléments en un avec 2ⁿ.

3 (88 octets en UTF-16)

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

= 2 + 1. ♯incrémente une valeur de 1.

4 (88 octets en UTF-16)

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

= 2².

5 (106 octets en UTF-16)

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

= 4 + 1.

6 (106 octets en UTF-16)

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

= 3 factorielle.

7 (110 octets en UTF-16)

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

= A (2, 2) (fonction Ackermann).

8 (118 octets en UTF-16)

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

= 2 << 2 (décalage gauche).

9 (128 octets en UTF-16)

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

= 3 × 3.

10 (146 octets en UTF-16)

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

= 5 + 5.

42 (170 octets en UTF-16)

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

= 6 × (6 + 1).

JavaScript, 144 141 140 138 132 125 123 octets

Avec l'aide de @ edc65 , @Sjoerd Job Postmus , @DocMax , @usandfriends , @Charlie Wynn et @ 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

Les premiers extraits poussent 0-10, et ZR+ pousse 25ensuite 17et 25 17 + 42 =est 1.

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

CJam, 27 24 octets

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

Merci à @ MartinBüttner pour -1 octet!

Essayez-le en ligne!

Brainfuck, 70 octets

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

Chaque ligne doit être exécutée individuellement.

Les 10 premiers sont explicites: nous incrémentons la valeur de la cellule via chaque plus.

Le 42 est beaucoup plus complexe. Il repose sur le fait que l'interprète le plus brainfuck utilise des cellules de 8 bits, ce qui signifie que toutes les opérations qui s'y rapportent sont effectuées modulo 256. Les --cellules des cellules n ° 0 à 254. Ensuite, nous entrons dans une boucle qui s'exécute jusqu'à ce que la cellule n ° 0 soit égale à 0. Chaque itération ajoute 1 à la cellule n ° 1 et 6 à la cellule n ° 0. Cette boucle est exécutée 43 fois, la cellule 1 est donc 43. Enfin, nous soustrayons 1 à la cellule 1 pour la transformer en 42.

J'ai obtenu le 42 le plus efficace jamais trouvé sur http://esolangs.org/wiki/Brainfuck_constants

Ténèbres , 339 303 octets

C'est là que les ténèbres brillent vraiment . Tu piges? : ~)!

Sans impression (remplace l'espace par \sdans la première ligne car il ne sera pas affiché autrement):

\s

█ 

██ 

███ 

████ 

█████ 

██████ 

███████ 

████████ 

█████████ 

██████████ 

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

Avec impression:

■ 

█■ 

██■ 

███■ 

████■ 

█████■ 

██████■ 

███████■ 

████████■ 

█████████■ 

██████████■ 

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

Dans ce cas, chaque ligne doit être exécutée individuellement car le programme se termine à la lumière (un espace). Cependant, il est possible d'écrire cela sur une ou plusieurs lignes du même programme.

L'obscurité normale () incrémente un registre de 1, et l'instruction ■ (une sorte de mini-obscurité) génère le contenu du registre.

Perl 5, 86 75 71 66 octets

Tout ^F s sont des caractères de contrôle littéraux (0x06 en ASCII) et, par conséquent, un seul octet.

$[          # 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

Merci à msh210 d’ avoir économisé 11 octets et à Dom Hastings de 9 octets!

MATL, 30 octets

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

H, Iet Ksont des constantes prédéfinies pour 2, 3 et 4 (comme pi). Oet lsont des fonctions qui retournent une matrice de zéros ( O) ou de ones ( l), la taille par défaut est 1x1. :crée un vecteur, et le srésume, K:scrée donc un vecteur de 1 à 4 et le calcule pour obtenir 10. Yqest la n-ième fonction principale, de même que KYqle 4ème nombre premier, 7.

Prolog, 113 à 99 octets

Snippets:

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

Combine les constantes mathématiques e et pi de différentes manières converties en int.

Edit: 14 octets enregistrés en utilisant des flottants pour 0-2.

PHP, 157 145 91 octets

Première publication sur Code Golf, a décidé de tenter le coup. Je finirai par aller mieux: P Si tu vois des endroits évidents (pour toi) où je pourrais sauvegarder des personnages, fais-le-moi savoir.

EDIT: J'ai réalisé que je n'avais pas besoin des points-virgules, car ce ne sont que des extraits.

EDIT2: Merci à Blackhole pour ses nombreuses suggestions!

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 157 156 149 146 octets

Ma première soumission, j'espère avoir tout bien compris! D'après le temps que j'ai passé sur ce sujet, je suppose qu'il y en a sûrement un meilleur pour certains d'entre eux.

# 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

Merci beaucoup à FryAmTheEggman!

C #, aucune utilisation, 234 octets

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

C'est beaucoup plus ennuyeux que ce que je pensais au départ. J'avais des idées assez variées, telles que new[]{true}.Lengthet true.GetHashCode()et typeof(int).Name.Lengthet uint.MinValueetc., mais je les ai new int()toutes battues.

PowerShell, 147 octets

Ceux-ci utilisent +implicitement les choses en éléments entiers. Les derniers numéros utilisent Enums des unerpinnings .Net Framework de PowerShell qui ont les bonnes valeurs.

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

• -~-~-~utilisé dans JavaScript, C # et les réponses PHP seraient - -bnot - -bnot - -bnotdans PowerShell.

• x^yl’exponentiation utilisée dans les réponses Perl, ou x**ydans Python ou JavaScript ES7, serait[Math]::Pow($x,$y)

• les constantes e et Pi sont lourdes en caractères [Math]::Eet[Math]::PI

DC , 35 octets

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

Pour tester les extraits, ajoutez a fpour imprimer la pile et transmettez cette chaîne à dc:

$ echo 'EdE++f' | dc
42

TI-BASIC, 41 octets

0 ~ 10:

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

42:

int(π²/ecosh(π

Dans TI-BASIC, toutes les variables à lettre unique non initialisées commencent à 0 et Xmax (la limite de la fenêtre de droite de l'écran du graphique) commence à 10.

La constante mathématique πest un octet , mais edeux octets.

Python 2, 306 275 274 octets

J'ai utilisé le fait que pour tout x (entier et non 0) l'expressionx/x est égale à 1 et joué avec quelques opérations au niveau des bits.

J'ai ajusté les extraits de telle sorte qu'ils répondent toujours aux exigences (merci @nimi, cela m'a sauvé 24 octets), mais vous devez les tester manuellement. Voici le code et le nombre individuel d'octets:

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 ++, total de 92 octets

0 (1 octet): a

1 (2 octets):!a

2 (3 octets):_$e

3 (4 octets): _$pi

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

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

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

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

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

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

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

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

Javascript (Browser Env), 155 136 130 octets

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

Merci à:
@Ismael Miguel : 155 -> 136 -> 130 octets

Sérieusement, 39 33 octets

La substance entre parenthèses est explications:

 (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 de programmes:

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

Merci à Quintopia pour 6 octets!

dc, 42 octets

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

Résultats

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

Il n'y a pas beaucoup de façons de générer de nouveaux nombres avec dc. J'utilise O: base de sortie, initialement 10; K: précision, initialement 0; zprofondeur de la pile, initialement 0; Zchiffres significatifs d'opérande. Nous les combinons avec les opérateurs arithmétiques habituels.

Programme de 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 octets

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

Je suis sûr que certaines d'entre elles sont sous-optimales. Ces crochets sont vraiment chers.

Par souci de cohérence, les deux premiers pourraient aussi être E-Eet E/Ebien sûr, mais je pensais que c'est assez astucieux pour obtenir 0et à 1partir d' un calcul avec des variables non définies.

Japt , 34 33 30 octets

1 octet enregistré grâce à @ThomasKwa

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

Voici ce que chacun des différents caractères signifie:

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 octets

Pas très excitant, il repose sur les ?ndispositifs qui transforment n'importe quelle bille en une valeur aléatoire de l'ordre de 0..n (inclus), ce qui a pour effet secondaire?0 transformer toute bille en 0 quelle que soit l'entrée. Je pense que l'utilisation de littéraux est autorisée car la valeur n'affecte pas le résultat et il n'y a pas d'autre moyen d'appeler une fonction une fois dans 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

dix:

00
?0
+A  # increment by 10

42:

00
?0
+L  # increment by 21
+L

> <> , 86 octets

• 0: ln;
• 1: lln;
• 2: llln;
• 3: lll+n;
• 4: lll:+n;
• 5: llll+n;
• 6: llll++n;oullll:+n;
• sept: lllll+n;
• 8: lllll:+n;
• 9: lllll++n;oullllll+n;
• 10: llll+:+n;oulll:l+*n;
• 42: llll*ll+*n;

S'appuie sur la taille de la pile pour obtenir ses littéraux.

Formules MS Excel, 163 151 150 143 octets

Ce n'est pas vraiment un langage de programmation, mais ça y est ...

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()est utilisé dans la plupart des cas car il s'agit du moyen le plus court (à ma connaissance) d'introduire une valeur numérique sans utiliser un nombre ou une chaîne de caractères. Nconvertit diverses choses (y compris les booléens) en nombres et Tconvertit diverses choses en texte. TYPErenvoie 2 pour un argument texte et 4 pour un argument booléen. TRUNCélimine la partie décimale (arrondit les nombres positifs vers le bas), EVENarrondit au nombre pair ODDsupérieur et au nombre impair suivant. CODE(-PI())est le code ASCII du premier caractère de la conversion en texte de -π, soit 45 (pour "-").

EDIT: Suppression des signes égaux du nombre d'octets (-12!) - comme l'a souligné Nᴮᶻ dans les commentaires, ils ne sont pas censés être inclus.

EDIT 2: En supposant que le reste de la feuille de calcul soit vide, il est possible d’utiliser une référence à une cellule vide égale à zéro (à nouveau, suggérée par Nᴮᶻ) à condition d’inclure un signe moins (ou de l’utiliser dans une autre expression numérique) pour résoudre tapez l'ambiguïté.

DUP , 68 octets

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

Try it here.

Il y a beaucoup de façons de faire cela, mais j'abuse de la pile de retour pour celle-ci.

Explication

Pour bien comprendre cela, vous devez comprendre le comportement de DUP concernant les lambdas. Au lieu de pousser le lambda lui-même sur la pile, il pousse en réalité l'adresse IP actuelle vers la pile lorsque le lambda est détecté. Cela peut expliquer les 3 premiers extraits, qui impliquent lambdas.

Les extraits suivants utilisent la pile de retour. Quand !est exécuté, l'adresse IP actuelle est poussée dans la pile de retour et le haut de la pile est défini comme nouvelle adresse IP pour démarrer l'exécution lambda. )insère un numéro de la pile de retour dans la pile de données.

C'est à peu près suffisant pour expliquer le reste des extraits. Si vous ne l'obtenez toujours pas, gardez à l'esprit que le Stepbouton est très pratique!

05AB1E, 40 38 24 octets

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

• Push counter_variable
• Poussez 1
• Poussez 2
• Poussez 1 + 2
• Poussez 2 * 2
• Poussez 10/2
• Poussez (10/2) +1
• Poussez (10/2) +2
• Poussez 10-2
• Poussez 10-1
• Poussez 10
• Poussez 32, 10, ajoutez

D1ffe7e45e , 112

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

Chaque ligne est un extrait différent.

Les nombres dans le programme ne comptent pas comme des littéraux numériques, car ils ne sont utilisés que comme des commandes.

Le dernier peut certainement être joué au golf plus.

EDIT: Je travaille avec l'interprète et tous les extraits fonctionnent. Si vous souhaitez tester si vous-même, ajoutez 0f0fà la fin de l'extrait de code afin que le programme se termine.

Pyth, 35 34 33 octets

-1 octet par @Mimarik

Il existe un certain nombre de possibilités pour certains programmes.

0, 1 octet

Z

1, 2 octets

hZ
!Z

2, 3 octets

hhZ
eCG
eCd
lyd
lyb
lyN

3, 3 octets

l`d

4, 3 octets

l`b
eCN

5, 4 octets

hl`b
telG

6, 3 octets

elG

7, 4 octets

tttT
helG

8, 3 octets

ttT

9, 2 octets

tT

10, 1 octet

T

42, 4 octets

yhyT

Tous ces éléments impliquent soit des commandes de base double ( y), +1 ( h) et -1 ( t), soit l(longueur d'une chaîne). La variable Z est initialisée à zéro.

Pour 5, best initialisé à un caractère de nouvelle ligne. Backtick donne "\n"(y compris les guillemets, et la longueur de cette chaîne est 4.

Essayez-les ici !