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 i ) i ) 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 3 = 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 4 , 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 3 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 11 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 11 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 .