Défi:

Votre tâche consiste à écrire autant de programmes / fonctions / extraits que vous le pouvez, chacun produisant / imprimant / renvoyant un entier. Le premier programme doit générer le nombre entier 1, le second 2, etc.

Vous ne pouvez pas réutiliser les caractères entre les programmes. Donc, si le premier programme est x==x:, vous ne pouvez pas utiliser les caractères xet à =nouveau dans les autres programmes. Remarque: Il est permis d'utiliser le même caractère plusieurs fois dans un programme.

Notation:

Le gagnant sera la soumission qui compte le plus haut. En cas d’égalité, le gagnant sera la soumission ayant utilisé le moins d’octets au total.

Règles:

• Vous ne pouvez utiliser qu'une seule langue pour tous les nombres entiers
• Les extraits sont autorisés!
• Pour rester honnête, tous les caractères doivent être codés en utilisant un seul octet dans la langue de votre choix.
• La sortie doit être en décimal. Vous ne pouvez pas le sortir avec une notation scientifique ou un autre format alternatif. La sortie de nombres flottants est correcte, à condition que tous les chiffres affichés derrière le point décimal le soient 0. Alors, 4.000est accepté. Les inexactitudes dues aux FPA sont acceptées, tant qu'elles ne sont pas affichées dans la sortie.
• ans =, les espaces de début et de fin, les nouvelles lignes, etc. sont autorisés.
• Vous pouvez ignorer STDERR tant que la sortie correcte est renvoyée à STDOUT
• Vous pouvez choisir d’envoyer le nombre entier à STDERR, mais uniquement si STDOUT est vide.
• Les langues indépendantes des symboles (comme Lenguage ) ne sont pas autorisées
• Les lettres sont sensibles à la casse a != A.
• Les programmes doivent être indépendants
• Les espaces ne peuvent pas être réutilisés
• Vous devez utiliser des chiffres ASCII dans la sortie

Les explications sont encouragées!

JavaScript (ES7), score 17, 176 octets

Ils ont dit que cela ne pouvait pas être fait, alors je l'ai fait: D (grâce à l'aide de @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

Caractères inutilisés:

#&,:?@ABDGHIJKLMOPQRTUVWYZ\_bcdfijkmopqrsuvwyz|

Je ne pense pas que 18 est possible, mais j'ai dit la même chose à propos de 17 ...

Explication

JavaScript est un langage très faiblement typé. Si vous essayez d'effectuer une opération mathématique sur une valeur autre qu'un nombre, JS fera de son mieux pour la convertir en nombre. Cela permet beaucoup de solutions intéressantes. J'ai essayé d'éviter autant que possible d'utiliser les chiffres pour qu'ils puissent être utilisés plus tard.

1. **est l'opérateur d'exponentiation dans ES7. La chaîne vide, lorsqu'elle est contrainte à un nombre, devient 0alors calculée 0 ** 0, ce qui 1correspond à JavaScript.
2. Un peu ridicule, mais ça marche. /~/est un littéral de regex, et ~/~/retourne -1, donc this ~(-1 / -1) / -1= ~(1) / -1= -2 / -1= 2. (crédits à @ GOTO0 pour l'idée)
3. Simplement 3.
4. Maintenant simplement 4.
5. NaNest falsy, donc !NaNest -à true, qui est équivalent à 1. L'expression devient ainsi 1 - -1 - -1 - -1 - -1= 1 + 1 + 1 + 1 + 1= 5.
6. Simplement 6.
7. Simplement 7.
8. Simplement 8.
9. Simplement 9.
10. Cela utilise un peu de magie JSF *** . +[]est 0, [[]][+[]]retourne donc le premier élément de [[]](c'est-à-dire []) et l' ++incrémente 1. Puis +[+[]]ajoute le tableau [0], qui est contraint à une chaîne et rend "10".
11. Simplement 11. Au départ, j'avais utilisé 11&1111pour 3 et 33/311 ans jusqu'à ce que je réalise à nouveau à quel point je suis stupide ...
12. Cette stratégie fonctionnerait sur n'importe quel nombre: créez une chaîne de longueur 12et utilisez-la .length.
13. Je viens de déconner avec 2s et >s pendant un moment pour obtenir celui-ci. J'ai eu de la chance à nouveau: 222 >> 2est 55, et 55 >> 2est 13.
14. Celui-ci est plutôt délicat. L'idée de base est de créer 14en hex ( 0xE), mais nous avons besoin du chiffre 0ailleurs. Donc, au lieu de cela, nous ajoutons le résultat de ``^``à la chaîne xE; la chaîne vide contrainte à un nombre est 0, donc cela retourne 0 ^ 0= 0. Ensuite, le résultat est XORed avec la chaîne vide, qui convertit les deux valeurs en nombres; "0xE" ^ ""est 14.
15. Ceci est maintenant assez facile: 0XFest un littéral hexadécimal avec une valeur de 15.
16. Le plus délicat de tous? Nous définissons d'abord la variable Csur CSS == CSS(c'est-à-dire true). Ensuite, nous prenons le résultat et performons << Cquatre fois, ce qui multiplie fondamentalement 1par 2 ** 4.
17. JavaScript commence à perdre la précision des nombres entiers à 2 ⁵³ , ce qui permet 555...555%55de renvoyer un nombre qui n'est pas 0ou 5. J'ai eu beaucoup de chance en jouant ici.

Des stratégies qui fonctionneraient sur plusieurs nombres:

• -!NaNfonctionnerait sur n’importe quel nombre (actuellement 5), bien qu’il devienne grand très vite.
• ~/~/fonctionnerait sur n’importe quel nombre (actuellement 2), bien que cela devienne très grand très vite.
• +[]fonctionnerait sur n’importe quel nombre (actuellement 10), bien que ce soit de loin le plus facile sur 10ou 11.
• .length travaillerait sur n'importe quel nombre.
• `${-``}xE`-`` travaillerait à peu près n'importe quel nombre si vous le faites correctement.
• C<<Cfonctionnerait sur tout pouvoir de deux (actuellement 16), ou tout int si vous avez inclus |.

Gelée , 47 nombres entiers, 519 octets

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

Chaque ligne est un programme complet et séparé.

Essayez-le en ligne! (comprend la suite de tests et le vérificateur d'intersection)

Comment ça fonctionne

Chaque programme complet sans argument de ligne de commande exécute son lien principal (défini sur la dernière ligne) de manière niladique, c'est-à-dire sans entrée. Si le premier lien de la chaîne est un nilad, il est consommé, appelé, et l'argument et la valeur de retour du lien principal sont définis avec le résultat; si le premier lien de la chaîne est une monade ou une dyade, il n'est pas consommé et l'argument implicite et la valeur de retour 0 sont utilisés à la place. Dans les deux cas, le reste de la chaîne est exécuté monadiquement.

La gelée modifie sa production dans plusieurs cas. Notamment, un tableau singleton est imprimé sans ses crochets, donc 42 et [42], et impossible à distinguer après l'impression. Nous allons l'utiliser à plusieurs reprises.

1 - 10

e

L' atome existant teste si la valeur de retour 0 appartient à l'argument 0 . C'est le cas, donc erenvoie 1 .

BI$⁼#

BI$est un lien rapide, en particulier une chaîne monadique formée par le $regroupement rapide de l' atome binaireB et de l' atome d' incrémentationI . Combinés, ils convertissent un entier en un tableau de chiffres en base 2, puis calculent les différences en aval des chiffres résultants. Si le tableau n'a qu'un seul élément, il n'y a pas de différences en Iaval et renvoie un tableau vide (falsy); s'il y a au moins deux chiffres, Iretourne un tableau non vide (vérité).

Le #composant rapide utilise le lien rapide précédent et l’applique à 0 , 1, 2,… jusqu’à ce qu’il y ait suffisamment de correspondances et retourne le tableau des correspondances. Le montant requis est calculé par ⁼, qui compare la valeur de retour / argument 0 à lui-même, ce qui donne 1 . Ainsi, le programme entier renvoie [2] , le premier entier non négatif à deux chiffres en base 2.

⁾⁾⁾Ụ^/

⁾⁾⁾est une chaîne littérale, en particulier la chaîne ⁾⁾ . L' atome Grade UpỤ trie ses indices en fonction de leurs valeurs correspondantes. puisque les deux caractères sont égaux, cela donne [1, 2] . Le tableau résultant est réduit avec XOR au niveau du bit ^/, ainsi le programme entier renvoie 3 .

ı***ıḞḞ

ıinitialise l'argument et renvoie la valeur à l'unité imaginaire i . *est la dyade d' exponentiation , dont l'argument correct est par défaut l'argument du lien principal. Ainsi, ***ıcalcule ((i ⁱ ) ⁱ ) ⁱ ≈ 4,81 + 0i , l' Ḟatome ( plancher pour les arguments réels, partie réelle pour les arguments complexes) calcule la partie réelle ( 4,81 ), puis les Ḟétages, donnant 4 .

5
6
7

Ces trois programmes se composent d'un seul littéral et font exactement ce que vous attendez.

.::::

Le littéral .est un raccourci pour 0.5 et initialise l'argument et la valeur de retour. L' argument droit de la division entière ( :) de dyad ( ) correspond par défaut à l'argument des liens principaux. Il ::::calcule donc 0.5 / 0.5 / 0.5 / 0.5 / 0.5 , ce qui donne 8 .

9

Un autre littéral.

EȮ<

L' atome tout égalE renvoie 1 si tous les éléments de son argument sont égaux et 0 sinon. Un argument entier z est promu à [z] , donc Erenvoie 1 pour l'argument implicite 0 .

Maintenant, l' atome de sortieȮ imprime 1 dans STDOUT. Nous comparons ensuite 1 avec l'argument implicite 0 en utilisant l' atome inférieur à< . Le résultat est (1 <0) = 0 et il est imprimé implicitement à la fin du programme.

11 - 20

⁻GṘ

L' atome de la grilleG tente de créer une table visuellement agréable à partir de son argument. Pour un argument entier simple (ici: 0 ), il l'enroule simplement dans un tableau. L' atome plat non égal⁻ compare l'argument implicite 0 avec le résultat à droite ( [0] ), ce qui donne 1 car ses arguments ne sont pas égaux. L' atome de représentationṘ imprime 1 sur STDOUT et renvoie le résultat. A la fin du programme, la valeur de retour finale est imprimée de manière implicite, nous obtenons donc une sortie de 11 .

=`p`VV×`DQV

Le self quick `transforme une dyade en une monade en l'appelant avec des arguments identiques de gauche et de droite. Premièrement, =`compare l’argument implicite 0 avec lui-même, ce qui donne 1 .

L' atome du produit cartésienp attend des listes en tant qu'arguments, il promeut donc l'entier 1 dans l'intervalle [1,…, 1] = [1] . p`prend le produit cartésien de [1] et lui-même, donnant [[1, 1]] .

Le eval atome Vtransforme toutes les matrices plates (contenant uniquement des chiffres et des caractères en chaînes de caractères), évalue ensuite les chaînes résultantes comme niladiques programmes de gelée. [[1, 1]] est d'abord transformé en [“11”] , puis Vévalue la chaîne, donnant [11] . Une fois de plus, Vtransforme ce tableau en "11" , puis l’évalue pour en obtenir 11 .

Maintenant, ×`multiplie 11 avec lui-même, donnant 121 . L' atome décimal transforme 121 en [1, 2, 1] , l' unique atome Qignore le second 1 et Vtransforme une fois de plus une liste de chiffres en un entier résultant de leur concaténation, renvoyant 12 .

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

~est le bitwise PAS l' atome. Avec l'arithmétique du complément à deux, il mappe un argument z à ~ z = - (z + 1) . Aest l' atome de valeur absolue , de sorte qu'il mappe - (z + 1) = z + 1 . Avec la valeur de retour initiale 0 , les treize copies de ~Areturn 13 .

⁷ṾṾṾw

La constante ⁷contient le caractère de nouvelle ligne '\ n' et initialise l'argument et la valeur renvoyée.

L' atome non valideṾ tente de créer une représentation sous forme de chaîne de son argument z de sorte qu'un programme Jelly composé de ce code renvoie z .

Le premier appel renvoie consciencieusement la chaîne "" \ n " , qui est un caractère littéral. Le prochain appel renvoie "" "," \ n " - une paire de littéraux de caractères. Le troisième et dernier appel renvoie "" "," "," ,, "", "\ n" - un quintuplet de littéraux de caractères.

Enfin, l' atome d' index de fenêtrew promeut son argument droit '\ n' dans la chaîne "\ n" et recherche le premier index d'une sous-chaîne commençant par "\ n" . Cela retourne 14 .

⁴ḟ€⁴Ṁ

⁴est la constante 16 . Le lien rapide filterfalse each ( ḟ€) favorise son argument de gauche 16 dans l'intervalle [1,…, 16] , puis itère sur ses éléments.

Pour chaque élément z , ḟ⁴est exécuté, en promouvant d'abord z en [z] , puis en supprimant toutes les occurrences (le cas échéant) de 16 . Cela donne le tableau [[1], [2],…, [14], [15], []] , où le dernier tableau est vide car il en contient 16 .

Enfin, l' atome maximalṀ sélectionne [15] .

mmmmċ

L' atome modulairem - appelé avec les arguments x (tableau) et y (entier) prend habituellement tous les | y | ^e élément de x , en commençant par le premier si y> 0 , avec le dernier si y <0 . Cependant, lorsque y = 0 , il retourne x concaténé avec son inverse.

L'argument entier gauche 0 est d'abord promu à [0] . La première copie de [0]m concatène avec elle-même, donnant [0, 0] . Les copies restantes transforment ce résultat en [0, 0, 0, 0] , puis [0, 0, 0, 0, 0, 0, 0, 0] et enfin [0, 0, 0, 0, 0, 0 , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] .

Enfin, count atom ċcompte le nombre de fois que l'argument implicite 0 apparaît dans le tableau résultant, renvoyant 16 .

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

ṭest l’ atome tack et ajoute son argument de gauche à celui de droite. Puisque ṭet les suivants ḍsont dyadiques, tous les appels pour ṭpasser l'argument implicite 0 comme argument correct ṭ. Le premier appel renvoie [0, 0] , le second [0, [0, 0] et les huitième et dernier [0, [0, [0, [0, [0, [0, [0, [0, 0]]]]]]]] .

ḍest l' atome de divisibilité ; des arguments x et y , il renvoie 1 est x est divisible par y , 0 sinon. Ḅest un no-op pour les entiers, donc ḍḄteste 0 pour la divisibilité par chaque entier du tableau construit. 0 est divisible par lui-même, nous obtenons donc [1, [1, [1, [1, [1, [1, [1, [1, [1, 1]]]]]]]]] .

Maintenant, l' atome non binaireḄ fonctionne sur des tableaux plats. Pour une paire [a, b] , il retourne simplement 2a + b . Comme mentionné précédemment, Ḅest un no-op pour les entiers: un argument entier c est promu en [c] , et [c] dans n'importe quelle base est simplement c .

Le premier appel à Ḅréduire [1, 1] à 3 , donnant ainsi [1, [1, [1, [1, [1, [1, [1, [], 3]]]]]]] . Le prochain appel réduit [1, 3] à 5 , le suivant [1, 5] à 7 , et ainsi de suite jusqu’à ce que le neuvième Ḅrenvoie 17 .

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

Ṇest l' atome logique NOT logique et mappe l'argument implicite 0 à 1 . +est l'atome d'addition, donc chacune des dix-huit copies d' +Ṇincrémenter la valeur de retour précédente (initialement 0 ). L'ensemble du programme revient donc 18 .

CNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNC

Cest l' atome du complément et mappe son argument z à 1-z . Nest l' atome de négation et mappe son argument z sur -z . Ensemble, CNmappe z sur - (1-z) = z-1 , de sorte que les dix-huit copies transforment l'argument implicite 0 en -18 . Une dernière application de Crendements 1 - (-18) = 19.

ĖḌĖḌ

L' énumération atome Ėénumère les éléments dans un tableau, ce qui crée des paires valeur d'index. L'argument implicite 0 est promu à [0] , puis Ėdonne [[1, 0]] . L' atome non-décimal convertit un tableau plat de la base 10 en entier, ce qui donne [10] dans ce cas particulier.

Le deuxième appel à Ėtransformer [10] en [[1, 10]] , que le second Ḍse transforme enfin en [20] .

21 - 30

ṫṣȦJṫȦ⁸ȦJ

L' atome de queueṫ (une dyade) sélectionne le postfixe de son argument de gauche qui commence à l'index (basé sur 1 et modulaire) spécifié dans son argument de droite, en promouvant un argument entier de gauche x à [x] . Lorsqu'il est appelé avec les deux arguments définis sur 0 , ṫrenvoie [0] .

L' atome any et allȦ renvoie 1 si son argument est véridique et ne contient aucun zéros à aucune profondeur, 0 sinon. Ici, nous l'utilisons simplement comme fonction d'identité pour renvoyer l'argument implicite 0 . La scission atome diviseṣ son argument de gauche [0] aux occurrences de son argument de droite 0. Elle renvoie donc [[], []] ici.

L' atome d' indexJ supprime les éléments de la valeur de retour et les remplace par leurs indices, ce qui donne la plage [1, 2] dans ce cas particulier. Ȧet les ṫdeux fonctionnent comme avant, ils réduisent donc [1, 2] au postfixe qui commence au dernier index, donnant [2] .

Dans les liens niladiques, la constante ⁸est vérifiée [] . C'est un nilad imparable, c'est-à-dire qu'il ne s'inscrit pas dans la chaîne. En conséquence, la valeur de retour précédente ( [2] ) est imprimée dans STDOUT, puis remplacée par la valeur du nilad ( [] ).

Puisque [] est faux, le Ȧtransforme en 0 . L' Jatome promeut 0 à [0] , puis renvoie la liste de ses index ( [1] ), qui est imprimée implicitement à la fin du programme.

22

Un autre littéral. Les représentants semblent être le meilleur endroit pour les utiliser.

“@ṃ»

Ceci utilise la compression de chaîne incorporée de Jelly. Les index de @ et ṃ dans la page de code de Jelly sont 64 et 220 et les littéraux de chaîne peuvent contenir 250 caractères différents. Le premier nombre calculé est donc 250 × 65 + 220 = 16470 .

16470 étant divisible par 3, le quotient 16470/3 = 5490 code un caractère imprimable ASCII ou un saut de ligne. Il y en a 96 et 5490 = 96 × 57 + 18 , ce qui signifie que nous avons décodé le caractère ASCII imprimable à l'index 18 à base 0 , qui est '2' .

Il nous reste 57 , qui est également divisible par 3 , donc le quotient 57/3 = 19 = 96 × 0 + 19 code un caractère ASCII imprimable à l’indice 18 basé sur 0 , qui est '3' .

Cela laisse 0 ; le processus de décodage s'arrête. Les caractères générés sont concaténés pour former "23"

!ḤḤ!

L' atome factoriel! transforme l'argument implicite 0 en 1 . Deux invocations de l' atome inhaléḤ transforment 1 en 2 , puis 2 en 4 . Enfin, !calcule 4! = 24 .

³HH

En l'absence d'arguments de ligne de commande, la constante ³vaut 100 . Deux invocations des Htours 100 à 50 , puis 50 à 25 .

ØaM

La constante Øacontient l'alphabet minuscule. L' atome maximalM produit tous les indices d'éléments maximaux, et puisque z est la plus grande lettre minuscule, le résultat est [26] .

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

Vingt-six exemplaires du concatenate atome ;concaténer la valeur de retour initiale 0 et vingt-six cas de l'argument par défaut 0 , la construction d' un ensemble de 27 zéros.

¬est l' atome logique NOT , ;¬ajoute donc un 1 au tableau de zéros. La prochaine ¬nie tous les éléments du tableau, nous laissant un tableau de 27 et 1 zéro.

ḅest le unbase atome et convertit un tableau de chiffres à partir de son argument de gauche de la base spécifiée dans son argument de droite en entier. ḅ¬convertit de unaire en entier, il effectue donc simplement une somme. Pour un tableau de 27, cela retourne 27 .

irið8c

L' indice d' atome ipromeut son argument de gauche de 0 à [0] , puis trouve l'indice de son argument de droite 0 dans ce tableau, ce qui donne 1 .

L' atome de portéer construit une gamme ascendante ou descendante de son argument de gauche à son argument de droite. Le bon argument est l’argument implicite 0 , ce qui donne [1, 0] . Une seconde invocation de itrouve l'index de 0 dans [1, 0] , donnant 2 .

ðcommence une nouvelle chaîne dyadique. Comme la chaîne précédente était niladique, les arguments gauche et droit de cette chaîne seront égaux à la valeur de retour de la première chaîne ( 2 ). cdans les combinaisons atome. Avec l'argument gauche 8 et l'argument droit 2 , il compte toutes les 2 combinaisons uniques et non ordonnées d'un ensemble de 8 éléments, renvoyant 8C2 = 8! / (6! 2!) = 28 .

⁶ḲĠṂ°İṂĊ

La constante ⁶contient un caractère d'espacement et définit l'argument et la valeur renvoyée sur '' . Le mot atome Ḳpromeut le caractère "" dans la chaîne de singleton "" et le divise en espaces, donnant [[], []] .

L' atome de groupeĠ regroupe tous les indices d'éléments égaux. Puisque les deux éléments de la dernière valeur de retour sont égaux, il renvoie ici [[1, 2]] . L' atome minimum extrait un élément minimal (le seul) de ce tableau, donnant [1, 2] .

Le degré atome °convertit les deux nombres entiers du degré sexagésimal en radians, donnant 1 ° × 2π / 360 ° = π / 180 et 2 ° × 2π / 360 ° = π / 90 . L' atome inverse prend les inverses multiplicatifs, ce qui donne 180 / π ≈ 57,3 et 90 / π ≈ 28,6 .

Ensuite, Ṃune fois de plus prend le minimum, donnant 28,6 . Enfin, l’ atome de ceilĊ transforme 28,6 en 29 .

œṡ¹ẆẆTUṖṖṖṖP

L' atome d' identité¹ renvoie 0 pour l'argument implicite 0 . La division autour de l' atome œṡpromeut ses deux arguments (les deux 0 ) à [0] , puis divise [0] autour des sous-réseaux contigus égaux à [0] . Cela donne [[], []] .

L' atome de la fenêtre glissanteẆ construit tous les sous-tableaux contigus de son argument. La première instance transforme [[], []] en [[[]], [[]], [[], []]] , la deuxième instance transforme [[[]], [[]], [[] , []]] en
[[[]]], [[[]]], [[[], []]], [[[]], [[]], [[]], [ [], []]], [[[]], [[]], [[], []]] .

L' atome de véritéT répertorie tous les indices d'éléments de vérité. Aucun des tableaux du premier niveau n'est vide, donc cela donne [1, 2, 3, 4, 5, 6] . L' atome supérieurU renverse ce tableau, donnant [6, 5, 4, 3, 2, 1] .

Quatre copies de l' atome de popṖ suppriment les quatre derniers éléments, nous laissant avec [6, 5] . Enfin, l’ atome de produitP transforme ce tableau en 30 .

31 - 40

ȷ½RṪ

ȷest un raccourci pour 1 × 10 ³ = 1000 . L' atome de racine carrée½ donne 31,6 , que l' atome de distanceR transforme en [1,…, 31] . Enfin, l’ atome de queueṪ extrait le dernier élément et renvoie 31 .

LµdddddµFL

L' atome de longueurL favorise l'argument implicite 0 à [0] , puis prend la longueur pour donner 1 . µdémarre une nouvelle chaîne monadique et le résultat 1 devient son argument.

Pour les arguments x et y , l’ atome de divmodd donne [x / y, x% y] . Chaque appel aura y = 1 , ainsi le résultat sera toujours [x, 0] .

Le premier appel commence par x = 1 et donne [1, 0] . dne fonctionne que sur des entiers, il est donc vectorisé lors des appels suivants. Le deuxième appel donne [[1, 0], [0, 0]] , le troisième [[[1, 0], [0, 0]], [[0, 0], [0, 0]]] , et le cinquième et dernier un tableau de profondeur 5 contenant un seul et 31 zéros.

µUne fois de plus, une nouvelle chaîne monadique commence et le tableau précédent devient son argument. L' atome platF cache ce tableau, donnant un tableau plat de 31 zéros. Enfin, Lprend la longueur du résultat, retournant 32 .

33

Un autre représentant, un autre littéral.

WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWŒḊ

Chaque instance de l' atome intégré transforme son argument z en [z] . Avec la valeur de retour initiale de 0 , toutes les 34 occurrences ensemble donnent [[[[[[[[[[[[[[[[[[[[[[[[[[]]] ]]]]]]]]]]]]]]]]]]]]]]]]]]]] . Enfin, l' atome de profondeurŒḊ calcule la profondeur maximale du tableau résultant, renvoyant 34 .

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

La fenêtre existe Atom ẇvalorise ses deux arguments (les deux valeurs par défaut étant 0 ) à [0] , puis teste si ** [0] ** apparaît sous la forme d'une sous-matrice contiguë de [0] . C'est le cas, donc ẇrenvoie 1 .

ɓcommence une nouvelle chaîne dyadique. Comme la chaîne précédente était niladique, les arguments gauche et droit de cette chaîne seront égaux à la valeur de retour de la première chaîne ( 1 ). La chaîne utilise deux atomes dyadiques différents: bitshift left ( æ«) et bitwise OR ( |).

Une chaîne dyadique qui commence par trois dyades ou plus appelle initialement la première dyade avec les arguments de la chaîne. Ici, cela donne 1 << 1 = 2 . Les six dyades suivantes sont regroupées par paires (appelées fourches ). La dyade la plus à droite est appelée en premier avec les arguments de la chaîne, puis la plus à gauche est appelée avec les valeurs de retour précédentes des deux côtés.

Pour æ«æ«, on obtient 2 << (1 << 1) = 2 << 2 = 8 . Ensuite, æ«æ«calcule 8 << (1 << 1) = 8 << 2 = 32 . Maintenant, |æ«nous obtient 32 | (1 << 1) = 32 | 2 = 34 .

Enfin, la fin se |comporte comme un crochet et est appelée avec la valeur de retour précédente comme argument de gauche et l'argument de droite de la chaîne comme argument de droite. Ceci retourne 34 | 1 = 35 .

⁹ṚḢ²

En l'absence d'un second argument, la constante ⁹vaut 256 . L' atome inverse favorise 256 au tableau [2, 5, 6] et l'inverse pour donner [6, 5, 2] . Ensuite, l’ atome de têteḢ extrait le premier élément et l’ atome carré² renvoie ** 6² = 36 *.

‘‘‘0‘‘‘‘‘‘‘

L' incrément atome ‘incrémente son argument par 1 , donc ‘‘‘tourner à la valeur de retour initiale 0 à 3 . Le 0 suivant est un nilad imparable, c’est-à-dire qu’il ne rentre pas dans la chaîne. En conséquence, la valeur de retour précédente ( 3 ) est imprimée dans STDOUT, puis remplacée par la valeur du nilad ( 0 ).

Les 7 copies suivantes de ‘tournent ce 0 en 7 , qui est imprimé implicitement à la fin du programme.

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

Le décrément atome ’décrémente son argument par 1 , donc trente-huit copies tourner la valeur de retour initiale 0 à -38 . L' atome de différence absolueạ calcule la différence non signée entre -38 et l'argument implicite 0 , renvoyant 38 .

-____---__________

-est un raccourci pour -1 et définit l'argument du lien et la valeur renvoyée à -1 . Chacun _est une instance de l' atome de soustraction dyadique , dont l'argument de droite est défini par défaut sur -1 s'il est manquant.

Tout d'abord, -____-calcule (-1) - (-1) - (-1) - (-1) - (-1) = 3 . Le -1 suivant est un nilad imparable. La valeur de retour précédente ( 3 ) est donc imprimée sur STDOUT, puis remplacée par la valeur du nilad ( -1 ).

Ensuite, -_calcule (-1) - (-1) = 0 , où le littéral -définit l' argument de gauche de _et utilise la valeur de retour comme valeur de droite. Les neuf copies suivantes de _soustraient l'argument par défaut -1 de la valeur de retour, ce qui donne 9 , qui est imprimé implicitement à la fin du programme.

”(O

”(est un caractère littéral et l' atome ordinalO recherche son point de code Unicode, ce qui donne 40 .

41 - 47

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

En l'absence d'un troisième argument de ligne de commande, la constante ⁵vaut 10 . L' atome unlengthḶ crée une plage basée sur 0, en particulier [0,…, 9] pour l'argument 10 , des deux côtés de l' atome de répétition sur placex . Ce dernier fait correspondre les éléments de son argument de gauche avec les répétitions de son argument de droite et répète chacun des éléments le nombre de fois correspondant. Avec [0,…, 9] comme argument à gauche et à droite, nous obtenons donc zéro zéro, un un, deux deux, etc.

L' index en atome ịextrait l'élément de son argument de droite à l'index spécifié dans son argument de gauche. Avec l'argument gauche 10 ( ⁵à sa gauche) et l'argument droit [1, 2, 2, 3, 3, 3, 4, 4, 4, 4,…, 9] (résultat précédent), cela donne 4 .

La chaîne jusqu'à ce point est suivie d'un nilad imparable ⁵. La valeur de retour précédente ( 4 ) est donc imprimée sur STDOUT. La valeur de retour est définie sur 10 et le reste de la chaîne est analysé comme d'habitude.

Comme précédemment, vous ⁵ḶxḶobtiendrez le tableau [1, 2, 2, 3, 3, 3, 4, 4, 4,…, 9] . Cette fois, nous appelons l' atome triéṢ sur l'argument 10 , qui promeut 10 à [1, 0] , puis le trie pour obtenir [0, 1] . L' atome de tête dyadique récupère maintenant les préfixes de longueur 0 et 1 du résultat à gauche, nous laissant avec [[], [1]] . Une fois imprimé, seul 1 restera visible.

⁽{ʂ%⁽{}

⁽et ses deux caractères suivants constituent un littéral numérique. Si j et k sont leurs points de code dans la page de code de Jelly et (j, k) <(124, 250) , on obtient le nombre entier 1001 + 250j + k . Les points de code de '{' , '}' et 'ʂ' sont 123 , 125 et 167 ; le littéral gauche est donc évalué à 1001 + 250 × 123 + 167 (= 31918) , tandis que celui de droite est évalué à 1001 + 250 x 123 + 125 (= 31876) .

Puisque le nombre entier gauche est inférieur au double de celui de droite, le résultat est (… + 167)% (… + 125) = (… + 167) - (… + 125) = 167-125 = 42 .

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

L' atome shuffleẊ randomise l'ordre des éléments de son argument; un argument numérique z est préalablement promu dans la plage [1,…, z] . Pour l'argument implicite 0 , cette plage est vide et Ẋdonne [] . L' atome toutẠ retourne 1 si tous les éléments de son argument sont vrais, 0 sinon. Puisqu'un tableau vide ne contient pas d'éléments faussement, Ạretourne 1 ici.

Le zip avec atome ż(une dyade) prend les arguments x et y et transpose la paire [x, y] . Pour les entiers x et y , ceci donne simplement [[x, y]] , donc ce particulier ż, appelé avec les arguments 1 et 0 (l'argument implicite), renvoie [[1, 0]] . L' atome d' évaluation dyadicv transforme tous les tableaux plats (contenant uniquement des nombres et des caractères) de l'argument de gauche en chaînes, puis évalue les chaînes résultantes en programmes monadiques Jelly avec son argument de droite en tant qu'arguments des programmes. Depuis ["10"]se compose uniquement de littéraux, ceci ignore le bon argument de vet aboutit simplement à [10] .

La copie se© joint rapidement vet copie son résultat dans le registre. Les occurrences ultérieures de l' atome de rappel® (un nilad) extrairont [10] du registre.

Les trois copies suivantes de żvtravail fonctionnent comme précédemment, mappant [10] à [[10, 0] à [100] à… à [10000] . L' atome d' ordreọ teste le nombre de fois que son argument de gauche est divisible par son argument de droite; il calcule donc ici l'ordre de 10 (recherché avec ®) dans 10000 = 10 ⁴ , ce qui donne [4] .

Ce qui suit ®est un nilad imparable. La valeur de retour précédente ( [4] ) est donc imprimée sur STDOUT, puis remplacée par la valeur du nilad ( 10 ). Nous appliquons Ạensuite, donnant 1 . (Ceci est nécessaire car un nilad suivi d'une dyade serait analysable à ce stade.)

Comme auparavant, żvżvżvajoute trois zéros à la valeur de retour actuelle en transformant 1 en [1000] . Enfin, ọ®calcule l’ordre de 10 sur 1000 = 10 ³ et 3 est imprimé sur STDOUT à la fin du programme.

44

Encore un autre repdigit, encore un autre littéral.

111111l11&K1111111Kl11&

D'abord et avant tout, le littéral 111111définit l'argument et la valeur de retour initiale sur 111111 . Les autres exécutions 1sont aussi littérales.

lest l' atome du logarithme qui calcule le logarithme de son argument de gauche à la base spécifiée dans celui de droite. Lorsqu'il est appelé le 111111 avec le bon argument 11 , nous obtenons le log ₁₁ 111111 ≈ 4.85 .

Le mot atome Kjoint un argument de liste au niveau d'espaces, après la promotion d'un caractère numérique / caractère z en [z] . Ici, nous l'utilisons simplement pour transformer l'argument du lien 111111 en [111111] . (Nous n'avons pas besoin d'un tableau ici, mais nous n'avons plus d'atomes d'identité.) L' atome AND au niveau du bit& prend les valeurs de retour des deux côtés, les convertit en entier si nécessaire et calcule leur AND au niveau du bit. Dans ce cas particulier, elle renvoie [4.85 & 111111] = [4 & 111111] = [4] .

Ce qui suit 1111111est un nilad imparable. La valeur de retour précédente ( [4] ) est donc imprimée sur STDOUT, puis remplacée par la valeur du nilad ( 1111111 ). Ktransforme ensuite cet entier en [1111111] . (Ceci n'est encore une fois pas vraiment nécessaire, mais un nilad suivi d'une dyade serait analysable à ce stade.)

Comme auparavant, l11calcule log ₁₁ 1111111 ≈ 5,81 , puis &renvoie [5.81 & 111111] = [5 & 111111] = [5] .

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

C'est le seul programme composé de plusieurs liens définis par l'utilisateur. Le dernier lien est le lien principal et s’exécute au démarrage du programme, les autres sont des liens d’assistance. Le rapide Çfait toujours référence au lien au-dessus du lien actuel et l'exécute de façon monadique. De même, le raccourci Ñfait toujours référence au lien situé en dessous du lien actuel (en boucle) et l'exécute également monadiquement.

Le lien supérieur est constitué de l’ atome de la paire, - une dyade transformant les arguments x et y en [x, y] - et un atome de sommeS - un monade qui promeut un argument entier z en [z] et réduit un argument de tableau par addition. Lorsque le lien ,SSest appelé avec un argument entier n , il calcule [n, n] = [n, n] = 2n .

Le chaînon intermédiaire comprend les atomes ci-dessus, le rapide susmentionné Çet l' atome insignifiantỊ - une monade qui donne 1 pour les arguments numériques z avec -1 ≤ z ≤ 1 , mais 0 pour tous les autres. En appliquant Ịdeux fois un entier, l'argument n le remplace essentiellement par 1 , car la sortie du premier Ị(l' entrée du second) est toujours non significative. Ce résultat est ensuite associé à la valeur de retour de Ç(appelé avec l'argument n ) et la paire résultante est réduite de S. Au total, nous calculonsΣ [(| n | ≤ 1) ≤ 1, 2n] = Σ [1, 2n] = 2n + 1 .

Avec ces deux liens auxiliaires en place, le lien principal peut désormais construire tout entier non négatif en consultant ses chiffres binaires. Avec une valeur de retour initiale de 0 , la chaîne ÇÑÇÇÇÑcalcule le résultat final (((((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

le prochain atome premier trouve le plus petit nombre premier positif strictement supérieur à son argument. Avec la valeur de retour initiale 0 , quinze invocations Æncalculent le quinzième nombre premier, qui est 47 .

brainfuck , score 2, 255 144 10 octets

... Ouais, pas la meilleure idée car je n'ai que 8 personnages (les tarpits vont tarpit) avec qui travailler mais voyons ce qu'il est possible de faire. Je pense que c'est tout ce qui est possible. : P Cette réponse montre six des huit personnages utilisés par le brainfuck, les deux autres étant, entrée et la .sortie.

+
>--[<->-]

Visualisez-le en ligne!

Explication

Chaque numéro est créé et stocké dans la cellule de départ sur la bande. Repose fortement sur les cellules d’emballage, qui ne sont pas implémentées dans quelques interprètes.

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 octets

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

Explication:

• Pour 1, nous utilisons le jeton 'check for equal', exploitant ici que lorsque Neim tente de faire apparaître une entrée vide, il obtient 0. Comme 0 et 0 sont équivalents, cela pousse 1 qui est implicitement imprimé.
• De 2 à 9, nous utilisons simplement des littéraux numériques.
• De 10 à 32, Neim a en fait une constante sur un octet (oui, c’est fou).
• Pour 33, nous utilisons uniquement la commande increment. Au premier octet, Neim essaie de faire apparaître quelque chose pour l’incrémenter, mais comme l’entrée est vide, sa valeur par défaut est popping 0.
• Pour 34, nous utilisons la même approche, mais en décrémentant et en prenant la valeur absolue.
• Pour 35, nous exploitons le fait que zéro factorielle est un, et nous l’utilisons en dupliquant celui-ci et en ajoutant de manière répétée
• Pour 36, on ℂvérifie 0 et 0 pour la co-primalité, ce qu’ils sont. Cela pousse 1. Ensuite, nous obtenons le premier nombre premier 𝐋, ce qui donne une liste de singleton contenant seulement 2. Nous obtenons ensuite le plus grand élément ( 𝐠), qui donne 2 comme nombre. Ensuite, nous répétons ce processus jusqu'à ce que nous obtenions la liste [2 3 5 7 11]. Après cela, nous utilisons 𝐝pour calculer les deltas, ce qui donne la liste [1 2 2 4]. Ensuite, nous utilisons 𝐬pour obtenir la somme - qui est 9 - puis nous calculons une plage exclusive de 0 à 9, ce qui donne [0 1 2 3 4 5 6 7 8]. Enfin, 𝐬est utilisé à nouveau pour obtenir 37.
• Pour 37, α est une constante qui représente une valeur négative et que nous poussons et soustractons à plusieurs reprises (exploitant à nouveau le fait que lorsque nous essayons d'afficher une entrée vide, 0 est poussé)
• Pour 38, en utilisant encore une fois le 0 par défaut pour une entrée vide, nous continuons à ajouter le 0 à lui-même, en créant une longue liste, puis en calculant la longueur.

Peut être essayé ici

Python 2, 15

Voici un début, cherchez plus

Merci à Léo dont le pourboire m'a aidé à atteindre 15

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

---

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 octets, score 42

Une grande collaboration entre Shaggy , ETHproductions et 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

Ces caractères (utiles) sont laissés:

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

---

Des explications

Quelques choses à savoir sur Japt avant de commencer, que j'ai utilisées fréquemment. Tout d'abord, Japt dispose de 6 variables réservées à la saisie, les majuscules U-Z. Si aucune entrée n'est transmise via ces variables, elles sont toutes définies par défaut 0. La deuxième chose est couverte dans cette astuce .

Cliquez sur un extrait pour l'essayer dans l' interprète en ligne .

---

v

Appliquée à un nombre, la vméthode prend un entier n comme argument et renvoie 1 si le nombre est divisible par n , 0 sinon. Si n n'est pas fourni, la valeur par défaut est 2 . 0 (la valeur par défaut pour U) est divisible par 2 , ce qui nous donne notre 1 .

---

y

Très semblable au premier. Appliquée à un nombre, la yméthode prend un entier n comme argument et renvoie le GCD des deux nombres. Si n n'est pas fourni, la valeur par défaut est 2 . Puisque 0 est divisible par 2 , GCD (0, 2) nous donne notre 2 .

---

Íà

Íest le raccourci pour n(2)ou 2- this. Parce que nous avons pas d' entrée, nous avons par défaut thisà 0, ce qui entraîne 2-0 = 2.

àretourne le nombre de combinaisons de [1...this], ce qui retourne 3

---

Qiiii)iiii)âQ

QLa valeur par défaut est un guillemet simple. isur une chaîne insère une autre chaîne au début; comme expliqué dans # 3 , chacun iiii)est équivalent à .i("i".i("i"))JS, insérant ainsi deux copies de iau début de la chaîne. Faites ceci deux fois et vous avez la chaîne iiii". âQsimule ensuite .search(Q), en donnant l’indice du premier "dans la chaîne, qui est 4 .

---

ÂHq

Hest la constante pour 32 . Appliquée à un nombre, la qméthode, qui prend pour argument l' entier n , renvoie la n- ^ème racine de ce nombre. Si n n'est pas fourni, la valeur par défaut est 2 , Hqnous donne donc la racine carrée de 32 qui est approximativement 5,6568 . Âest le raccourci pour ~~, qui planifie le résultat, nous donnant 5 .

---

LÁL

Lest préréglé sur 100 et Áconstitue le raccourci pour >>>(décalage à droite bit par bit). 100>>>100est le même que 100>>>4(l'opérande de droite enveloppe le mod 32), qui est 6 .

---

´Vn´VnVnVn

Comme indiqué précédemment, la valeur par Vdéfaut est 0 . ´est le raccourci pour l' --opérateur, donc le code est équivalent au JS suivant:

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

X.n(Y)est équivalent à Y - X ou -X + Y ; le premier --Vretourne -1 , et le second -2 , donc c'est à peu près équivalent à - (- 1) + (- (- 2) + (- (- 2) + - (- 2))) . En simplifiant, on obtient 1 + 2 + 2 + 2 = 7 .

---

8
9

Littéralement, 8 et 9 .

---

A
B
C
D
E
F
G

Ce sont les constantes pour 10 - 16 inclus.

---

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

Jest préréglé sur -1 . L’interprète Japt parvient à l’analyser correctement en tant que (J--) - (--J) - (--J) - (--J) - (--J). En faisant un peu plus de calcul, nous trouvons que cela équivaut à (-1) - (-3) - (-4) - (-5) - (-6) , ou -1 + 3 + 4 + 5 + 6 = 17 .

---

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

¾est, comme vous pouvez le deviner, un raccourci pour .75. Nous mettons 24 copies de 0.75 dans un tableau, puis sommeons avec x, donnant 0.75 * 24 = 18 .

---

;Iìw

Je pense que c'est mon préféré. ;au début du programme change les valeurs de certaines des constantes Japt; sans elle, Ic'est 64 , mais avec elle, Ic'est 91 . ìwle convertit en une liste de chiffres et s’exécute wsur la liste en inversant le tableau, puis reconvertit en un nombre pour nous en obtenir 19 .

---

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

½est un raccourci pour .5. esur un nombre x prend un argument y et retourne x * 10 ^y . Donc, la chaîne de calculs qui se produit est la suivante:

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

Et la finale ~~sert à obtenir un nombre entier, ce qui donne notre résultat de 20 .

---

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

Test préréglé à 0 . ++est l'opérateur d'incrémentation dans JS et également dans Japt; T+++Test analysé comme (T++) + T, mais ++T+++Test analysé comme (++T) + (++T), cela équivaut donc au code JS

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

Le résultat est 1 + 2 + 3 + 4 + 5 + 6 , soit un total de 21 .

---

22

Un littéral 22 .

---

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

Äest un raccourci pour +1, alors cela résume simplement 23 1 s.

---

4á

Ceci trouve le nombre de permutations de [1, 2, 3, 4], qui est 4! = 24 .

---

5²

²est un raccourci pour p2, qui élève un nombre à la puissance de deux. 5 ** 2 est 25 .

---

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

°est un raccourci pour l' ++opérateur, ou si elle ne peut pas être analysé en tant que tel, + +. Comme indiqué précédemment, lorsqu'il n'y a pas d'entrée, la valeur par Udéfaut est 0 . Donc, le code est équivalent à (++U), (U++) + + (++U) + + (++U) + + (++U) + + (++U) + + (++U), ce qui est très similaire au # 17 : il Uest d'abord incrémenté 1, puis incrémenté de manière répétée et ajouté de manière à ce que le résultat final soit 1 + 3 + 4 + 5 + 6 + 7 = 26 .

---

»³³

³est le raccourci pour la pméthode avec un argument de 3 . Toutefois, si une lettre minuscule apparaît directement après une parenthèse gauche ( »correspond au raccourci ((), elle devient une chaîne. Cela permet de le transmettre à une méthode et de l’appeler en tant que fonction (c’est m³-à- dire que mapper par .p(3)). Dans ce cas, cependant, ("p",3)retourne notre 3, puis nous l’élevons à la puissance de 3( pc’est la méthode de puissance appliquée à un nombre), ce qui nous donne notre 27 .

---

7/¼

¼, comme vous le savez probablement maintenant, est un raccourci pour .25, donc cela calcule 7 / 0.25 = 28 .

---

$'_____________________________b'$bb

Tout ce qui est entouré de $symboles est traité comme du pur JavaScript. Nous avons donc une chaîne de 29 caractères de soulignement suivis de a b. (Sans le $, 'serait une chaîne à caractère unique.) La bméthode appliquée à une chaîne renvoie le premier index de son argument dans cette chaîne. Comme expliqué au point 3 , le dernier best converti en chaîne. Nous saisissons donc le premier index de bnotre chaîne, qui est 29 .

---

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

µest un raccourci pour -=, et Épour -1. L'effet soustrait 30 copies de -1 à 0 , ce qui donne 30 .

---

"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"aa

Très bien comme # 29. La améthode, lorsqu'elle est appliquée à une chaîne, renvoie le dernier index de son argument dans cette chaîne. En utilisant l'indexation 0, le dernier index d' aune chaîne de 32 asecondes est 31 .

---

Sc

Sest prédéfini dans un seul espace et, csur une chaîne à un seul caractère, renvoie son code, ce qui donne 32 .

---

33

Littéral 33 .

---

Mg011

MgNrenvoie le numéro Nth de Fibonacci. 011est 9 en octal; le 9ème numéro de Fibonacci est 34 .

---

##

#renvoie le code de caractère du caractère suivant. Le code de caractère #lui - même se trouve être 35 , rendant notre travail ici particulièrement facile.

---

6p

pest une exponentiation, et sans second argument, la valeur par défaut est 2 ; ainsi, cela imprime 6 ** 2 = 36 .

---

Rí í í í í è.

Celui-ci est plutôt délicat. Rutilise par défaut un seul caractère de nouvelle ligne (le fait qu’il s’agisse d’une nouvelle ligne devient important ultérieurement). ísur une chaîne, sans aucun argument, prend chaque caractère et ajoute son index: une transformation plutôt inutile, mais le résultat en 5 itérations est le suivant: (utiliser à la Rplace d'un retour à la ligne littéral)

R
R0
R001
R0010213
R001021304251637
R0010213042516370849210511112613314715

Ce qui est intéressant, c'est que chaque entrée est simplement un préfixe du suivant ... Mais de toute façon, la dernière partie è., compte le nombre de /./gcorrespondances trouvées dans le résultat. Il y a 38 caractères dans la chaîne; cependant, puisque /./gseuls les caractères non-newline correspondent, le résultat est 37 .

---

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

Les Backticks marquent une chaîne compressée et se ¥décompressent en ll. lsur une corde donne length, donc après décompression, cela donne 38 .

---

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

Oooh garçon, celui-ci est un doozy. Tout d'abord, nous générons trueavec ¨N( ¨signifie pour >=, et Navec aucune entrée est le tableau vide), puis convertissons cela en 1avec |N. À partir de là, ça devient assez fou:

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

(Les ¹s ne sont que des substituts pour les proches parents et ont été omis.) La finale oapparaît et renvoie le dernier élément du tableau, donnant 39 .

---

º¤¤*º¤

Principalement le même truc que avec # 3 . ¤est le raccourci pour la sméthode avec un argument de 2 . Dans ce cas, cependant, le code transpilé est (("s", 2).s(2) * (("s", 2) * (("s", 2)))), ou simplifié (2).s(2) * (2 * 2). .s(2)renvoie le nombre sous forme de chaîne en base 2, ce qui donne "10"; * (2 * 2)convertit implicitement cela en un nombre et multiplie par 4 , donnant 40 .

---

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

Semblable à la précédente. Åest le raccourci pour la sméthode avec un argument de 1 . Dans ce cas, cependant, chaque (Åcopie ("s", 1), qui ne retourne que 1 . 1<<1<<1<<1<<1<<1est 32 et 1<<1<<1<<1est 8 ; ceux-ci sont combinés avec 1pour obtenir 41 .

---

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

±est un raccourci pour +=, et ¶pour ===. Cela signifie que le code est réellement

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

Y===Y est toujours vrai, nous pouvons donc simplifier ceci:

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, score 17, 130 octets

caractères utilisés 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 constante booléenne Z (non définie) égale constante Z

2 FTP_MOREDATA est une constante en PHP avec la valeur 2

3 bits et caractères; et W

4 bitwise Décalage à gauche et logique non converti tableau vide sur booléen true avec est converti en entier 1 à travers l'opérateur de décalage gauche

7 bitwise Ou caractères # et $ et 1

9 SIGKILL est une constante en PHP avec la valeur 9

10 bitwise Shift right chaque étape est une division entière avec 8 donc nous avons les étapes 333333, 41666, 5208, 651, 81, 10

13 caractères X dans la chaîne X ... depuis le début

15 valeur hexadécimale f = 15

17 bits au format Xor avec les chaînes ha et YV

Tous les extraits sont des éléments dans un tableau

Essayez-le en ligne!

PHP, score 16, 94 octets

caractères utilisés 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 constante booléenne Z (non définie) égale constante Z

2 bitwise et caractères: et w

3 Pi converti en valeur entière par un tableau vide converti à zéro

7 caractères binaires xor A et v

10 variable $ s non définie! $ S = une concat avec une longueur de chaîne de la variable $ s

13 111/2 = 55/2 = 27/2 = 13 divisions entières au niveau du bit

15 valeur hexadécimale f = 15

Tous les extraits sont des éléments dans un tableau

Essayez-le en ligne!

PHP, score 14, 84 octets

caractères utilisés $!_^[]()%/+~-=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 constante booléenne Z (non définie) égale constante Z

3 Pi converti en valeur entière par un tableau vide converti à zéro

7 ERA est une constante avec la valeur 131116 mod 11 = 7

10 variable $ s non définie! $ S = une concat avec une longueur de chaîne de la variable $ s égale à zéro

13 valeur hexadécimale d = 13 14 au niveau du bit pas et signe moins élever NULL à 14

Tous les extraits sont des éléments dans un tableau

Essayez-le en ligne!

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

Vous en avez un supplémentaire grâce à user2390246.

Caractères utilisés:

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

MATL , score 21 22 23 numéros (273 octets)

Merci à J Doe pour avoir passé de 22 à 23 numéros!

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

Essayez-le en ligne! Chaque extrait de code dans le lien se termine parD(affichage) ou]D(boucle explicitement et affichage) pour effacer la pile et ainsi isoler de l'extrait suivant.

Explication

0~

Poussez 0. Nier. Donne true, qui est affiché comme 1.

'bd'd

Poussez la chaîne 'bd'. Différence consécutive entre les points de code des personnages.

{P}gk

Push tableau de cellules contenant le nombre pi. Convertir en tableau numérique (c.-à-d. En un seul nombre). Arrondir vers le bas.

HH^

Poussez 2deux fois. Puissance.

5

Littéral numérique.

6

Littéral numérique.

7

Littéral numérique.

8

Littéral numérique.

9

Littéral numérique.

3 3.333333333333333*

Poussez 3. Poussez 3.333333333333333. Multiplier. Cela donne une précision en virgule flottante 10.

11

Littéral numérique.

IEE

Poussez 3. Multiplier par 2deux.

[B]Yq

Push [6](qui est le même que 6). Calculer n- prime.

llllllllllllllNwxwxwxwxwxwxwxwxwxwxwxwxwxwx

Poussez 114 fois. Nombre d'éléments dans la pile. Effacer le reste de la pile.

KUKUa-

Poussez 4. Carré. Faire de même. Any: donne 1. Soustraire.

4W

Poussez 4. 2élevé à cela.

FFFFFFFFFFFFFFFFFn

Push array [false false ... false](17 fois). Nombre d'éléments dans le tableau.

TTTTTTTTTTTTTTTTTTs

Push array [true true ... true](18 fois). Somme du tableau.

rrrrrrrrrrrrrrrrrrrhhhhhhhhhhhhhhhhhhz

Appuyez sur 19 nombres aléatoires pris dans l'intervalle (0,1). Concaténer horizontalement 18 fois. Nombre d'éléments non nuls dans un tableau.

OOOOOOOOOOOOOOOOOOOOvZyX>

Poussez 020 fois. Concaténez le contenu de la pile verticalement (donne un vecteur colonne). Taille: donne le tableau [20 1]. Maximum de tableau.

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

Appuyez sur 1j(unité imaginaire) 21 fois. Ajouter 20 fois. Diviser par 1j.

22

Littéral numérique

`@QQQQQQQQQQQQQQQQQQQQQQ@@<

Do ... while loop ( `) avec fin implicite. Dans la première itération, il pousse l'index d'itération ( @) et l'incrémente Q22 fois, ce qui donne 23. La condition de boucle ( @@<) étant fausse, la boucle est abandonnée.

Quelques idées d'amélioration

• (espace) dans l'extrait 10 pourrait être remplacé par |
• X>dans l'extrait 20 pourrait être remplacé par p, libérant ainsi le préfixe X.
• À l' heure actuelle utilisé et potentiellement utile: :,A

Vim 8 sur Windows, score 13, 104 octets

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ésente <C-{keystroke}>, tel ^Xest <C-x>, sauf pour ^@qui est <C-j>. J'essaie toujours d'ajouter plus de numéros à cette liste et <CR>représente un saut de ligne.

Remarque: pour exécuter ces commandes, démarrez vim en utilisant -u NONE -U NONE. Ceci permet de s’assurer que vos configurations n’interféreront pas avec le code.

Les extraits 1 à 10 commencent en mode insertion. Tandis que les extraits 12 et 13 démarrent en mode normal.

Des explications

Le fragment 8 est :^R=&ts^@. Je tiens à remercier @ L3viathan pour cette proposition et @ nmjcman101 pour avoir suggéré ^@de remplacer le saut de ligne et @ ØrjanJohansen pour une réduction &tabstopde &ts. &tsévalue ensuite la taille de l'onglet, qui est par défaut à 8, et cette valeur est insérée dans l'éditeur.

Snippet 10 est 8^O^A^O^A. Nous insérons un 8, puis l'incrémentons deux fois pour obtenir 10.

Snippet 11 est 0^[^X^X^X^X^X^X^X^X^X^X^X0x. Nous écrivons un 0 et le décrémentons 11 fois pour obtenir -11. Ensuite, nous supprimons le moins pour obtenir 11.

Le fragment 12 est :h<CR>wwwwwwwwwwwy$:q<CR>p. Cela ouvre le menu d'aide de Vim 8, qui contient les informations suivantes:

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

Et la séquence de wdéplacement du s à 12, à quel point y$copie le nombre. Ensuite, il est collé dans l'éditeur à l'aide de p.

Snippet 13 est grgKjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjYZZvPWWWllld|llDgrâce à @DJMcMayhem pour l'avoir proposé. Cela ne fonctionne que sous Windows. L'extrait recherche dans le menu d'aide les commandes commençant par g. Ensuite, il descend en utilisant jpour arriver à cette ligne:

|g?|        g?      2  Rot13 encoding operator

après quoi il le copie et le colle dans le tampon. Après cela, tout sauf le 13 est retiré du tampon.

Mathematica, score 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 octets

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

Essayez-le en ligne!

PingPong , score 127

Dans PingPong, chaque caractère a sa propre valeur numérique distincte, ce qui rend le décompte allant jusqu'à 127 jusqu'à une tâche triviale. Le langage fonctionne en lisant la valeur de chaque caractère et en le poussant au sommet d'une pile, où toutes les opérations sont effectuées. Théoriquement, PingPong peut aller au-delà de 127, mais il faudrait passer un bloc de caractères qui apparaissent simplement sous la forme d'espaces dans un éditeur de texte; je les ai donc laissés en dehors de ma solution.

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

Octave, Score 14, 74 octets

Je suis presque sûr que je suis proche de la limite maintenant.

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

Nous avons dû retirer strchrdepuis que je l' ai déjà cen nombre 10. J'ai encore j, ^, =,! , espace et tabulation horizontale (ASCII-9) à gauche, de sorte qu'il pourrait être possible de presser un plus.

Onglet horizontal peut être utilisé comme un espace, donc l'astuce utilisée avec strchret nnzpeut être utilisée une fois de plus. Les seules lettres minuscules qui restent sont abdfgjkmoquvwxy. Il n'y a pas beaucoup de fonctions que l'on peut en tirer.modpourrait fonctionner, mais cela ne peut pas prendre d’entrée de chaîne.

Il est facile d'utiliser les caractères restants pour obtenir 1, mais je ne sais pas comment je peux obtenir autre chose.

Tout tester .

Peut-être utile: fun aest le même que fun('a'), fun a best le même que fun('a','b')et ainsi de suite. Cela peut être utilisé à plusieurs endroits:

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

En utilisant cela fera 0 disponible, mais je ne vois pas comment le rendre utile pour le moment.

e (2.71828...)et jsont encore inutilisés. Doit enlever ceilpour utilisere si.

Alternatives (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 nombres entiers, 137 130 128 octets

J'ai pris la réponse de @ETHproductions et l' ai utilisée pendant un moment; ça a tellement changé que je l'affiche séparément. Les idées sont les bienvenues. :)

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

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

Ou, si l'extrait de code pour 1 est remplacé par !!/!//!!/!/:
$_@#^&|*?:", ABDEGHIJKLNPQRUVWZcghjklmpqrsuvwyz

---

JavaScript (ES7), 16 entiers, 127 octets

Un octet plus court. : 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

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

Dyalog APL, score 15, 89 octets

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

_{Les nouvelles lignes avant l:lfont partie de 12.}

_{Les espaces en 14 représentent des onglets.}

> <> , score 20, 93 90 74 65 octets

(3 octets sauvegardés par Teal Pelican, beaucoup d'octets sauvegardés par Jo King!)

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

Essayez-les au terrain de jeu du poisson! Vous pouvez faire en sorte que les extraits impriment leurs résultats en les ajoutant n;à la fin de chacun. Notez que le 9ème extrait contient un onglet, qui est mangé par échange de pile.

Explication:

• Dans iii((, chacun iessaie d'obtenir une entrée, mais comme il n'y en a pas, ils poussent EOF = à la -1place. Alors (est le moins-instruction, et puisque -1n'est pas moins que -1, il pousse une falsey 0; mais le second (demande si -1est inférieur à 0, ce qui est, alors il pousse une vérité 1.
• 2et 3sont évidents.
• Pour ll{lll{[, le premier lpousse la longueur de la pile, ce qui est 0, puis le second pousse la nouvelle longueur, amenant la pile à 0, 1. Le {fait pivoter la pile à gauche, en échangeant le 1et 0. Trois autres ls apportent la pile à 1, 0, 2, 3, 4. Puis {fait pivoter le 1vers l’avant, et [siphonne la première 1chose sur la pile, qui est 4.
• 5, 6, 7Et 8sont trop évidentes.
• Dans !\t00=0g(où \treprésente un onglet), !saute l'onglet, puis 00=pousse deux zéros et vérifie s'ils sont égaux - ils le sont, nous obtenons donc une vérité 1. Après avoir appuyé sur un autre bouton 0, le gobtient le caractère en position 1,0du code, qui correspond à la tabulation contenant le code du caractère 9.
• aà fchaque pression 10à 15respectivement (probablement pour rendre hexadécimal agréable).
• 44*pousse deux 4s et les multiplie ensemble, pour 16.
• 'RA'pousse les codes de caractère de Ret A(82 et 65 respectivement) dans la pile, puis les %calcule 82 mod 65 = 17.
• 999-9--évalue à 9 - ((9 - 9) - 9) = 18.
• "&F#"pousse les codes de caractère de &, Fet #, qui sont 38, 70et 35respectivement. Ensuite ,, la division, alors nous obtenons 38 / (70 / 35) = 19.
• Enfin, 1::pousse a 1et le duplique deux fois, +ajoute deux de ceux ensemble pour obtenir 2; :+duplique le 2et l'ajoute à lui-même pour obtenir 4; +ajoute les restes 1à obtenir 5; puis :+:+duplique et ajoute deux fois, résultant en 20.

C'est le score maximum possible avec> <>. Tout extrait doit inclure une instruction quelque part qui transforme une pile vide dans une pile non vide, et il n'y a que 18> instructions <> qui peut le faire ( à savoir i, let les chiffres 0–9et a–f), ainsi que le mode de chaîne. (Toute autre instruction ne fait rien sur une pile vide ><v^/\|_#x!{}r, ou essaie de faire apparaître quelque chose et des erreurs ?.+-*,%=():~$@[]on&gp,.) La saisie en mode chaîne utilise "ou ', ou , de sorte qu'il y a tout au plus des 18 + 2 = 20extraits possibles.

---

Si vous êtes plus à l'aise avec les non imprimables que moi, c'est possible en 53 octets, grâce à Jo King:, 00=, iii((i-, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f, 2222***, !Xll$g, 11+::+:+:++, 'Y', "Z"où X, Yet Zsont remplacés par des caractères avec des codes 17, 19et 20respectivement.

MathGolf , 48 51 53 entiers, 324 octets

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

+2 score (et -2 octets distincts utilisés pour 40) grâce à @maxb .

Chaque ligne est un programme séparé.

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

Explication et liens TIO:

MathGolf est une nouvelle langue de golf spécialisée dans les défis mathématiques du golf. Il comporte de nombreuses fonctions intégrées codées sur un octet, ce qui en fait un défi de taille.

1) î: Appuyez sur la valeur 1-indexée de la boucle, qui est 1 par défaut: essayez-le en ligne.
2) ª∞~: appuyez sur [1]; le doubler ([2]); liste déroulante et placez son contenu dans la pile: essayez-le en ligne.
3) c±b±+: poussez -2; puis pop et poussez sa valeur absolue; poussez -1; puis pop et poussez sa valeur absolue; et ajoutez-les ensemble Essayez-le en ligne.
4) φⁿ_¥-: Poussez le nombre d'or (1,618033988749895); le cube (4.23606797749979); dupliquer le haut de la pile; prendre le modulo 2 (0,23606797749979); soustrayez-les les uns des autres: essayez-le en ligne.
5,6,7) Les chiffres eux-mêmes: Essayez-le en ligne.
8) Essayez-le en ligne. 9) : Poussez -3; au carré: essayez-le en ligne.○¢i♀/ : Poussez 2048; convertir en chaîne hexadécimale (800); cast to integer; poussez 100; diviser:
d² 10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,26,27,28,29,30,31,32,33,34, 35,36,37,38) Pousser les éléments intégrés pour les nombres eux-mêmes ( ♂ABCDE☻FGHIJKLMNOPQRST♥UVWXYZ): Essayez-le en ligne.
39) ♫¼¼¼¼: Poussez 10000; entier divisé par 4 à quatre reprises: essayez-le en ligne.
40) 88888]Σ: Poussez 8 cinq fois; les envelopper dans une liste; résumer cette liste: essayez-le en ligne.
41) Le numéro lui-même: essayez-le en ligne.
42) ╔½½½½½½½½½½½: Push 86400; entier divisé par 2 onze fois: Essayez-le en ligne.
43) π░3§3: Push PI (3.141592653589793) couler à la ficelle; pop et poussez son troisième caractère indexé par 0 (4); poussez 3; affiche la pile entière réunie de manière implicite: 44)Essayez-le en ligne. 48)
22#22#: Poussez 2 deux fois; prenez le pouvoir des deux (4); refais-le; affiche la pile entière réunie de manière implicite: Essayez-le en ligne.
45) τ╥└: appuyer 2 * PI (6.283185307179586); éjectez et poussez la puissance de 2 en dessous qui est la plus proche (4); poussez le haut de la pile + 1 sans éclater (5); affiche la pile entière réunie de manière implicite: Essayez-le en ligne.
46) ♦⌡⌡⌡⌡⌡⌡⌡⌡⌡: Poussez 64; décrémentez de neuf fois: essayez-le en ligne.
47) !⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠: Appuyez sur gamma (n + 1) (1 par défaut); incrémente de 2 vingt-trois fois: essayez-le en ligne. : chaîne de poussée
'0$: Indique la valeur ordinale du caractère '0': essayez-le en ligne.
49) ; pop et pousser sa longueur (4); poussez 9; affiche la pile entière réunie de manière implicite:ÿ@@@@£9"@@@@"Essayez-le en ligne.
50) )))))))))))))))))))))))))))))))))))))))))))))))))): Incrémente de 1 fois et demi: Essayez-le en ligne.
51) ►◄╠•╠: Pousser 1 000 000; Pousser 10 000 000; pop et entier-divisez-les l'un avec l'autre (10); poussez 512; pop à la fois et entier-diviser les uns avec les autres: Essayez-le en ligne.
52) "hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh"h : chaîne de poussée "hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh"; poussez sa longueur (sans éclater la corde); tout supprimer de la pile sauf le dernier élément: essayez-le en ligne.
53) ♣(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((: Poussez 128; décrémenté de soixante-quinze fois: essayez-le en ligne.

Je vais essayer d’en ajouter un peu plus tard. Il me reste encore des choses utiles, y compris modulo %et multiplier *.

Java 8, 11 12 13, 39 octets

Java ne contient que 10 symboles pour les nombres (0 à 9) et tous les appels de méthodes et les constantes nécessitent un point; je ne suis donc pas sûr de pouvoir obtenir plus de 11 sorties.

Apparemment, les caractères sont convertis en nombres entiers par défaut lorsque des opérations sont appliquées

+1 avec l'aide de @ OlivierGrégoire

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

Explications:

i->-~i

entier lambda qui ne prend aucune entrée et renvoie 1. Lorsqu'un paramètre ne prend aucune entrée, la valeur par défaut est utilisée conformément à la méta publication ci-dessus, qui pour les entiers vaut 0

2
3
4
5
6
7
8
9

littéraux entiers

'P'^'Z'

XOR de deux personnages à renvoyer 10

11

littéral entier

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

expression lambda qui renvoie la longueur d'une chaîne de 12 caractères

0xD

Hexadécimal 13

Lien TIO si vous voulez vérifier.

Gaia , score 25, 203 octets

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

Je considère cela comme un score parfait, car plus de nilads ne peuvent être utilisés compte tenu des limitations de caractères.

Des explications

1. §‼

§est un caractère d'espace, ‼contraint de booléen, le résultat est donc 1.

2 ..⌉+⌉

.est un raccourci pour 0.5, alors c'est ceil(0.5+ceil(0.5)).

3 ₵P~~

₵P est pi, ~ est la négation au niveau du bit. La double négation au niveau du bit est simplement une troncature.

4 4

5 5

6 6

sept. ∂Ql

∂Q est une liste contenant les noms des jours de la semaine, l is length.

8 8

9 9

dix. ¶c

Code cdu saut de ligne¶ .

11 11

12 '¡ċ⌋u⌋

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

13 --⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻

-est un raccourci pour -1, ⁻est la soustraction. Alors ceci est-1 - -1 - -1... assez de temps pour faire 13.

14 7:,Σ

Poussez 7, dupliquez :, jumelez ,les deux 7 dans une liste et additionnezΣ .

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

Øest une chaîne vide, il en Ø!va de 1. Incrémenter )1 14 fois.

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

La fermeture d'une chaîne avec en ‘fait un littéral en base 250. ⟩est à la valeur d'octet 17 dans la page de code de Gaia.

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

Chacun ]encapsule la pile dans une liste. Faites cela 19 fois et obtenez la profondeur nde la liste.

20 ⇑’e

Fermer une chaîne avec en ’fait une liste de points de code pour la page de codes.evide la liste sur la pile. ⇑a un point de code de 20 dans la page de codes.

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

Décrémentez (0 21 fois, puis annulez_ .

22 22

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

Convertissez la chaîne en “B”base 24, où se trouvent les chiffres de 0 à 23 ↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺B. Le résultat est23 .

24 3₈×

3 × 8.

25 ℍḥḥ

100 ℍréduit de moitié ḥ, et encore moitié.

C, note 13

Ce ne sont que des tas de constantes entières.

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==0 évalue à 1
2. Suppose que le code est à la ligne 2. __LINE__= 2
3. Constante entière
4. Constante entière
5. Constante entière
6. Constante entière
7. Constante entière
8. Constante entière
9. Constante entière
10. 1+1+1...= 1*10= 10
11. 'o'est 111, '.'représente le 0x10 ASCII non imprimable. 111/10 = 11
12. (2<<2)= 8, 8*2= 16, 16-2-2= 12
13. longueur de chaîne de "strlenstrlens"= 13

Ohm , score 21 22, 160 octets au total

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

Essayez-le en ligne!

Des explications

1. ╓S@Ri

Appuyez sur les secondes de la date / heure en cours ( ╓S). Obtenez la plage comprise entre 1 et secondes ( @), inversez-la ( R), obtenez le dernier élément (i ), qui est toujours 1.

2 ΓΓ-Γ-Γ-

Γ est -1, donc c'est (-1) - (-1) - (-1) - (-1), qui est 2.

3 αê⌠

αêest le numéro d'Euler (2.71828 ...), ⌠est ceiling. 3 est le résultat.

4 ¡¡¡¡¼

¡incrémente le compteur, ¼pousse le compteur.

5 5

Juste un littéral.

6 ▀lll▀l

▀lll▀est un littéral de chaîne compressé équivalent à "of >ic". lprend la longueur, donc le résultat est 6.

sept. ÑÑÑÑÑÑÑÿWÿk

Nous allons d’abord pousser 7 newline chars ( Ñ) puis une chaîne vide ( ÿ). La pile est encapsulée dans un tableau ( W), puis l'index de la chaîne vide dans ce tableau est trouvé.

8 ü`½½

üest un caractère d'espace. `pousse sa valeur ASCII (32), puis se divise par deux (½½ ).

9 9

Juste un littéral.

dix. ..≥°

..est un .personnage littéral . Il obtient incremented ( ≥), qui analyse la chaîne sous forme de nombre, la valeur par défaut étant 0 car ce nombre n'est pas valide, et l'incrémente à 1. Ensuite, nous calculons 10 ¹ ( °).

11 $$J

$ pousse la valeur actuelle du registre, initialement 1. Alors poussez 1 deux fois, joignez la pile et imprimez.

12 3dd

Appuyez sur 3 et doublez-le deux fois.

13 7ƒ

Pousse le 7ème numéro de Fibonacci.

14 2≡≡≡Σ

Appuyez sur 2, tripliquez-le trois fois, en laissant 7 2 sur la pile. Ensuite, prenez la somme de la pile ( Σ).

15 ║F

║est le délimiteur pour les littéraux en nombre de base 220. Comme il s’agit d’une fin de ligne, il n’est pas nécessaire de la terminer.

16 4º

Calculer 2 ⁴ .

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

òis bitwise negate, ~est arithmetic negate. En combinant ces opérateurs, nous pouvons incrémenter 0 17 fois.

18 6DD++

Appuyez sur 6, dupliquez-le deux fois et calculez 6 + 6 + 6.

19 8π

Poussez le 8 nombre premier.

20 τ╛hτ*

Poussez 10 ( τ), obtenez le premier élément ( h) de ses facteurs premiers ( ╛), multipliez-le par 10.

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

Comme pour les extraits précédents, la chaîne "≤"est analysée à 0. Nous la décrémentons 21 fois, puis prenons la valeur absolue.

22 1111 11v11%L1111 11v11%L

Ici, nous calculons 1111 div 11 mod 11, qui est 2, puis imprimons 2. Ensuite, recommencez.

PowerShell, score 12, 91 octets. 14, 176 octets

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

Modifier:

• Merci à Ørjan Johansen d’avoir suggéré le littéral hexadécimal 0xd pour 13 et la réorganisation de 5 pour libérer 1 + 1 + 1 + 1 .. en option.
• Modification de la longueur du tableau en longueur de chaîne, de [int] à [octet] et de la table de hachage pour utiliser les tables de hachage en tant que valeurs, libérant ainsi (),""Pondering 15 avec quelque chose comme, "ZZZZZZZZZZZZZZZA".InDeXof("A")mais ne peut pas réutiliser le point ou le 'e' ..

PowerShell ne peut pas faire de variables sans $, ne peut pas faire d’exponentiation, de décalage de bits, de Pi, de ceil (), etc. avec des symboles de base, et fait surtout le type coercien de / vers bool et de / sous forme de chaînes, donc il y a relativement peu de place pour la génération de nombres à faible syntaxe.

TI-Basic (série 83), score 21 22 23 24 25 (1003 octets)

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

Consultez http://tibasicdev.wikidot.com/one-byte-tokens pour obtenir une liste des tâches que le défi ne permet pas et ne permet pas ici.

Tous ces programmes peuvent constituer des programmes complets, car la dernière ligne d’un programme est imprimée automatiquement. Mais (à l'exception de 17, qui correspond à plusieurs lignes), ils peuvent également être des extraits sur l'écran d'accueil.

À ce stade, je ne vois aucun autre moyen d’obtenir une valeur non nulle à partir des jetons disponibles. S'il y a une amélioration à faire, il faudra d'abord rendre certaines des solutions ci-dessus plus conservatrices.

Des explications

• A=Aest un booléen 1 car la variable Aest égale à elle-même.
• Best 0 par défaut, tan(tan(cos(cos(cos(Best environ 2.21, puis nous prenons la parole.
• C!°est 1 degré en radians, environ 0,017. Une puissance positive de ceci est tanh (2), environ 0,964. Nous codons ce pouvoir en binaire en utilisant la multiplication implicite et √(, puis prenons tanh⁻¹(.
• 4 est simple
• cosh(sinh⁻¹(X$\sqrt{1+X^2}$
• 6-9 sont simples
• ₁₀^( est un octet intégré pour les puissances de 10 et 10 ^ 10 ^ 0 = 10 ^ 1 = 10.
• 11 est 11.
• Un autre exemple du tour utilisé sur 5. F nPr Fest 1. sin(tan⁻¹(Xsimplifie en$\frac{1}{\sqrt{1+1/X^2}}$ , et utilisé 143 fois à partir de 1, cela nous donne 1/12. La division 1 par ce nombre est 12.
• G≤Gest 1, donc [[G≤G]...[G≤G]]est un vecteur de colonne 13x1. Prendre le produit de sa transposition avec lui même donne la matrice[[13]] , dont le déterminant est 13.
• not(H)est 1. tanh(not(H))est juste un nombre différent de 0 ou 1, etln(XXX....X)ln(X)^⁻1 simplifiera le nombre de X'dans le premier log à condition queX ne soit pas 0 (pour que le journal existe) et pas 1 (pour que nous ne divisions pas par 0).
• e^(e^(e^(F évalue à environ 15,15, puis nous prenons la parole.
• J≥Jest 1. identity(construit une matrice d'identité 1x1, dim(trouve ses dimensions de ligne et de colonne, etsum( ajoute pour obtenir 2. Ensuite, on répète l'opération en ajoutant les dimensions d'une matrice 2x2 pour obtenir 4 et en ajoutant les dimensions d'une matrice 4x4. pour obtenir 8, et encore, en ajoutant les dimensions d'une matrice 8x8 pour obtenir 16.
• K nCr K est le coefficient binomial 0 choisissez 0 ou 1. En additionnant 17 1, on obtient 17.
• i-i-...-i simplifie à ⁻18i, et en prenant abs( donne 18.
• rand→Lstocke un nombre réel aléatoire dans L, mais nous ne nous soucions pas de ce que c'est. Nous calculonslog(L)⁻¹log(L^19) , ce qui simplifie à 19.
• sinh(sinh(cos⁻¹(Iest un peu plus de 4, seq(III,I,I,sinh(sinh(cos⁻¹(Idonne donc la liste{0 1 8 27 64} dont la moyenne arithmétique est 20.
• Un autre exemple du tour utilisé pour obtenir 3. Ici, un pouvoir de πdevrait donner 21; nous codons ce pouvoir de manière ternaire en utilisant la multiplication implicite et ³√(.
• 22 est 22.
• Un autre exemple du tour utilisé pour obtenir 3 et 21. Nous codons la puissance de 3 égale à 23 en ternaire, en utilisant 3×√(comme racine de cube et( pour la multiplication.
• Fix 0 est le paramètre permettant d'afficher 0 chiffre après la virgule, en arrondissant toutes les valeurs à des entiers. sin⁻¹(ᴇ0évalue à π / 2, et π / 2 multiplié par lui-même 7 fois donne environ 23,59, ce qui arrondit à 24.
• 5*5est 25. (Il serait plus prudent d'utiliser 5pour obtenir 5 et d'adapter la solution utilisée pour 25. Mais cette façon permet de gagner beaucoup d'espace et *n'est pas un personnage très utile car la multiplication implicite existe.)

SOGL , score 16 18 20, 109 octets, 47 caractères utilisés

=                    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 nombres entiers, 86 octets

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

Essayez-le en ligne!(L'entrée contrôle quel programme est exécuté, de 1 à N)

Explication

                       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

Gelée , score 22, 177 octets

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

Essayez tout à la fois ou essayez un à la fois (l'argument est la sortie souhaitée).

Caractères inutilisés:

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

Reng, score 40, 149 octets

Essayez-le ici!

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

Toutes les lettres majuscules sont des chiffres, alors c'est bien. Tous sauf deux d'entre eux sont des extraits. Les deux qui sont des programmes:

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

Le lien fourni permet de voir la pile en cours d'exécution. J'écrirai une explication plus tard.

CJam, score 27, 168 octets

1-3: X , Y,Z

Les variables X, YetZ sont initialisées à 1, 2 et 3, respectivement.

4: ",,,,",

Poussez la ficelle ,,,,et prenez la longueur.

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

Littéraux numériques.

10-20 : A-K

Variables préinitialisées.

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

La variable Uest initialisée à 0. Poussez Uet incrémentez 22 fois.

22: 22

Littéral numérique.

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

Appuyez sur le caractère ;et décrémentez-le 9 fois pour obtenir 2, puis appuyez à ;nouveau et décrémentez-le 8 fois pour obtenir 3.

24: 4m!

Prenez la factorielle de 4.

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

TT=pousse 1. Ce code est équivalent à 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-

Npousse une chaîne contenant une nouvelle ligne. :ile convertit en une liste de codes de caractères [10]. ~le déballe, donne 10.W-est l'équivalent d'en ajouter un. Incrémenter 10 seize fois donne 26.

27: LLLLLLLLLLLLLLLLLLLLLLLLLLL0]0#

Trouvez l'index de 0 dans une liste où 0 est le 27ème index.

Caractères encore disponibles: $%&*./1<>?@MOPQRSV[\^_`abcdefghjklmnopqrstuvwxyz{|}

Quelques notes pour une expansion potentielle:

• Je devrais peut-être changer 10-20 pour utiliser les variables pour autre chose. Si je reçois des nombres supérieurs à 1, je peux utiliser *(et éventuellement des opérateurs au niveau du bit, mais je ne pense pas qu'ils vont aider beaucoup).

• J'ai toujours Sce qu'il y a de mieux pour moi.

• Si je change de 26 à N{}/iW-W-W-W-W-W-W-W-W-W-W-W-W-W-W-W-, alors :sera disponible.

• Je peux pousser des listes vides et obtenir plus de zéros avec les variables existantes. Je peux aussi obtenir π, mais cela ne semble pas très utile à moins de pouvoir le convertir en un entier, et m(pour m[) et isont déjà pris.

• En termes de manipulation de tableau, je peux:

  • Utilisez une carte avec %ouf
  • Utilisez un pli avec *
  • Faire quelques opérations setwise
  • Conversion de base (cela semble prometteur, mais je ne sais pas comment obtenir le numéro de base)
  • Construisez des tableaux en utilisant |:M1|2|3|

Haskell , score 13, 86 octets

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

Essayez-le en ligne!

Merci à Ørjan Johansen d'avoir trouvé le moyen de corriger le chevauchement de ma lettre tout en préservant le score de treize. (Également pour m'avoir mis au courant de la situation alors que cette réponse était supprimée.)

pi/piest 1.0.
sum[]évalue à 0, 0^0à 1et sum[1,1]à 2. 3pour 9décoder simplement eux - mêmes.
length"eeeeeeeeee"donne la longueur de la chaîne, qui est 10.
2+2+2+2+2+2est 12.
0xDest hexadécimal pour 13.