> 1
> Input
>> 1…2
>> L!
>> L+1
>> L∣2
>> L⋅R
>> 2%L
>> Each 4 3
>> Each 5 9
>> Each 6 10
>> Each 7 11 3
> {0}
>> 12∖13
>> Each 8 14
>> L≠1
>> Each 16 15
>> Each 7 17 15
>> 18∖13
>> [19]
>> 2’
>> 21⋅20
>> Output 22
Essayez-le en ligne!
Cela renvoie une liste vide pour les nombres premiers non Pillai, et une liste non vide sinon.
Comment ça fonctionne
Whispers a été conçu pour être manipulé sur des nombres réels / complexes, avec un peu de commandes de tableau ajoutées pour faire bonne mesure, d'où l'utilisation répétée de Eachpour parcourir les listes générées.
Un peu d'histoire sur Whispers:
Whispers est légèrement différent dans son chemin d'exécution vers la plupart des autres langages. Plutôt que de parcourir chaque ligne de façon linéaire, en ne ramifiant que les conditions, Whispers commence sur la dernière ligne du fichier commençant par >(les règles sont légèrement plus compliquées que cela, mais c'est tout ce que nous devons savoir pour l'instant), et la signification des nombres diffèrent selon que la ligne commence par >ou >>.
Si la ligne commence par >, comme > 1ou > Input, c'est une ligne constante - elle renvoie la même valeur à chaque fois. Ici, les nombres représentent leur forme numérique, donc la première ligne retournera toujours 1 lors de l'appel.
Si la ligne commence par >>cependant, les nombres sont traités comme des références à d'autres lignes, sorte d'appels de fonction similaires, si vous voulez. Par exemple, dans la ligne >> 1…2, cela n'exécute pas la …commande sur les entiers 1 et 2 , mais plutôt sur les valeurs renvoyées par les lignes 1 et 2 . Dans ce cas, ces valeurs sont l'entier 1 et quel que soit l'entier que nous transmettons en entrée.
Pour cet exemple, considérons l'entrée de 23 . Gardez à l'esprit qu'en raison du prétraitement de Whispers, la deuxième ligne ( > Input) est convertie en > 23.
Notre première commande est en ligne 3: >> 1…2. …est une gamme dyadique, dans ce cas de 1 à 23 , donnant {1, 2, ... 22, 23} . Ensuite, nous sautons aux lignes 9 à 12 :
>> Each 4 3
>> Each 5 9
>> Each 6 10
>> Each 7 11 3
Ici, nous avons 4 Eachdéclarations consécutives , chacune d'elles répétant le résultat précédent, mappant essentiellement les 4 commandes sur le tableau de la ligne 3 : la plage. Les trois premiers énoncés sont de simples cartes, avec les lignes 4 , 5 et 6 :
>> L!
>> L+1
>> L∣2
Ces trois commandes, sur un entier n , donnent (n! +1) ∣x , où ! dénote factorielle , ∣ dénote la divisibilité et x est l'entrée. Enfin, la ligne 12 a une structure de carte dyadique .
Une structure de carte dyadique prend trois entiers: la cible, la gauche et la droite, chacun indexe sur d'autres lignes. Ici, nous zip la gauche et la droite pour produire une liste de paires, puis réduisons chaque paire par la commande dyadique (la cible). Ici, si l'entrée est 23 , les listes sont {1, 2, ... 22, 23} et {0, 0, ... 1, 0} et la commande est
>> L⋅R
qui multiplie l'argument de gauche par la droite. Cela produit un tableau d'entiers, avec 0 aux index des entiers dont les factorielles incrémentées ne sont pas divisibles par les entrées, et l'index d'origine où elles se trouvent. Nous appellerons ce tableau A . Ensuite, nous supprimons les 0 de A en prenant la différence définie entre {0} et A :
> {0}
>> 12∖13
Avec notre exemple d'entrée, cela produit l'ensemble {14, 18, 22} . Ensuite, nous prenons le reste de l'entrée divisé par chaque valeur de l'ensemble et vérifions si ce reste n'est pas égal à 1 :
>> 2%L
>> Each 8 14
>> L≠1
>> Each 16 15
Encore une fois, nous avons une liste de 0 ou de 1 s et devons supprimer les 0 et remplacer les 1 par les valeurs d'origine. Ici, nous répétons le code que nous avons vu ci-dessus, mais avec >> 18∖13plutôt que 12. Enfin, nous avons converti cet ensemble résultant en une liste pour une vérification finale. Malheureusement, notre code doit également rejeter les nombres composites qui répondent à tous ces critères, tels que 437 . Nous ajoutons donc notre contrôle final, en multipliant notre liste finale par la primauté de l'entrée. En raison du fonctionnement de la multiplication Python sur les listes, 0 la remplace par une liste vide et 1 n'a aucun effet. Nous calculons donc la primauté de l'entrée, multiplions cela par la liste de ms pour l'entrée et la sortie du résultat final:
>> 2’
>> 21⋅20
>> Output 22