Amorcez votre code

37

Contribution

aucune entrée pour ce défi

Le défi

Ecrivez un code qui donne:
Les 10 premiers nombres premiers dont la somme de leurs chiffres est égale au nombre d'octets de votre code

Exemples

Disons que votre code est Co&%423@k"oo"ce qui est 13 bytes
votre code doit sortir [67, 139, 157, 193, 229, 283, 337, 373, 409, 463]
ce sont les 10 premiers nombres premiers dont la somme .... ok vous l'avez!

Si votre code est 8 bytes, vous devez générer[17, 53, 71, 107, 233, 251, 431, 503, 521, 701]

Règles

Vous devez utiliser uniquement les 10 ^ 8 premiers nombres premiers,
ce qui signifie que tous vos nombres doivent être <2038074743 = 10 ^ 8e prime

Si vous ne trouvez pas 10 nombres premiers dans cette plage qui correspondent à vos octets, vous devrez alors ajuster votre code (vous devrez peut-être même ajouter quelques octets!) Afin de trouver un " nombre de travail en octets ".

Vous n'avez qu'à sortir les 10 nombres premiers comme vous le souhaitez

C'est du code-golf , donc le code le plus court en octets gagne!

code-golf primes source-layout
la source
1
Ne peut pas modifier un commentaire , donc je suis juste supprimer et reposter: Voici un point essentiel contenant les nombres premiers , vous aurez besoin de sortie pour un bytecount donné, ainsi que leurs indices: lien Depuis que je l' ai fait ingénument, je ne ai vérifié pour les sommes vers le haut aux 10 premiers ^ 7 premiers nombres. Comme certaines réponses l'ont mentionné, il manque des valeurs qui sont probablement liées à des sommes numériques irréalisables, bien que cela ne soit pas le cas pour des sommes plus importantes (rappelez-vous que je n'ai vérifié que les 10 premiers nombres premiers).
cole
"comme tu veux" : les premiers doivent-ils être commandés?
Arnauld
@Arnauld Non, mais ils doivent être les 10 plus petits dans n'importe quel ordre
1
@KevinCruijssen Bien que votre réponse soit invalide, vous pouvez la poster pour discuter avec d'autres membres afin de vous aider à en trouver une meilleure.
1
@TessellatingHeckler Je pense aussi que le seuil de 10 ^ 8 est plutôt arbitraire. Pour vérifier que dix nombres donnés ont tous une somme de 350, ils doivent tous être rapides. Cependant, vérifier que ces dix sont en réalité les plus petits possibles pourrait être plus difficile, je suppose.
Jeppe Stig Nielsen

Réponses:

15

Neim , 10 8 7 octets

-1 octet grâce à ASCII uniquement.

πᛦ𝐋Λ𝐬7𝔼

Essayez-le en ligne!

Les sorties:

[7 43 61 151 223 241 313 331 421 601]

Ceci (du moins l'approche) est non-golfable.

Explication

πᛦ𝐋Λ𝐬7𝔼

π        push 13 (yes, very unintuitive :P)
 ᛦ       square (13² = 169)
  𝐋      push the first 169 primes
   Λ     filter those that when the following are executed, evaluate to 1
    𝐬    sum its digits and...
     7𝔼  check for equality against 7
totalement humain
la source
2
meilleur jusqu'ici .. !!!
νᛦ𝐋Λ𝐬7𝔼pour 7 ... modifier: π-> ν: p
Jonathan Allan
@ JonathanAllan Il semble que vous ayez été ninja par ASCII uniquement. ;)
totalement humain
Wow, il y a vraiment une instruction pour pousser les n premiers nombres premiers? Soigné!
isaac9A
9

Gelée , 14 octets

‘ÆNDS=14ø⁵#‘ÆN

Essayez-le en ligne!

Cela imprime:

[59, 149, 167, 239, 257, 293, 347, 383, 419, 491]

Comment ça marche

‘ÆNDS=14ø⁵#‘ÆN
          #     Count the first 
         ⁵        10
                Non-negative integers which meet:
‘ÆN               the (z+1)-th prime  (1-indexed :*()
   D              digits
    S             sum
     =            equals
      14          14
           ‘ÆN  Get those primes
fireflame241
la source
8
Obtenez ces primes!
undergroundmonorail
6

Pyth , 14 octets

.f&qsjZT14P_ZT

Essayez ici.

C'est 14 octets et affiche:

[59, 149, 167, 239, 257, 293, 347, 383, 419, 491]

Pyth , 16 octets

.f&qssM`Z16P_ZTZ

Essayez-le ici!

Notez que cela pourrait être 15 octets:, .f&qssM`Z16P_ZTZmais il n'y a pas de nombres premiers qui ont 15 comme somme de leurs chiffres, car 15est divisible par 3, ce qui impliquerait que le nombre serait également divisible par 3, donc n'est pas premier.

C'est 16 octets de long et affiche:

[79, 97, 277, 349, 367, 439, 457, 547, 619, 673]

Comment?

Explication 1

.f&qsjZT16P_ZT - Full program.

.f&           T  - First 10 numbers that satisfy the following:

           P_Z     - Are prime and
    sjZT           - And their sum of digits
   q     14        - Equals 14.

Explication 2

.f&qssM`Z16P_ZTZ - Full program.

.f&           T  - First 10 numbers that satisfy the following:

           P_Z     - Are prime and
    ssM`Z          - And their sum of digits
   q     16        - Equals 16.
M. Xcoder
la source
1
Bien joué! et rapide!
«Très peu d'entiers premiers dont la somme de 15 est égale à 15» - en effet, une somme de chiffres divisible par 3 implique la divisibilité par 3 :)
Lynn
@ Lynn Oh sure> _> - Je suis idiot, désolé. Fixe
M. Xcoder
6

Coque , 13 octets

↑10fȯ=13ΣdfṗN

Essayez-le en ligne!

Explication

            N    Take the (infinite) list of all natural numbers.
          fṗ     Select only the primes.
   fȯ            Filter again by the result of composing the following three functions:
         d         Get the decimal digits.
        Σ          Sum them.
     =13           Check whether the sum equals 13.
↑10              Take the first 10 primes in the result.
Martin Ender
la source
J'ai presque joué jusqu'à 10 octets, mais l'un des résultats est faux :( tio.run/##yygtzv7//1HbREODtPxDyywftU04sqHg/38A
Leo
@Leo Heh, serait très chouette si cela fonctionnait :)
Martin Ender
6

Haskell , 77 71 octets

x=take 10[i|i<-[1..],sum(read.pure<$>show i)==71,all((>0).rem i)[2..i-1]]

Essayez-le en ligne!

Économisé 6 octets grâce à Laikoni

Pour 71 octets:

[89999999,99899999,99998999,99999989,189989999,189998999,189999989,197999999,199898999,199979999]

tous vos numéros doivent être <2038074743

1999999999 est le nombre avec la somme maximale de chiffres dans la plage autorisée, et cette somme est 82. Tout programme dont la taille excède 82 octets ne remplira pas la condition. J'espère que 77 octets c'est bien, mais je ne sais pas (ça fonctionne toujours sur mon ordinateur).

EDIT: une version légèrement optimisée donnait pour 77 octets:

[699899999,779999999,788999999,789999989,797999999,798899999,799898999,799899899,799999799,879999899]
jferard
la source
6

Gelée ,  14 à  13 octets

DS⁼13
.ȷÆRÇÐf

Essayez-le en ligne!

Comment?

DS⁼13 - Link 1, test digit sum equals thirteen: number, n
D     - get a list of the decimal digits of n
 S    - sum them
  ⁼13 - equals thirteen?

.ȷÆRÇÐf - Main link: no arguments
.ȷ      - literal 500
  ÆR    - prime range (all primes less than or equal to 500)
     Ðf - filter keep if:
    Ç   -   call last link (1) as a monad
Jonathan Allan
la source
5

05AB1E , 10 octets

83LØʒSOTQ}

Essayez-le en ligne!

Le }est utilisé comme remplissage, car 9 est un nombre d'octets invalide.

Sortie: [19, 37, 73, 109, 127, 163, 181, 271, 307, 433]

Explication

83L        Push array [1, ..., 83], since 433 is the 83rd prime
   Ø       Map each to the nth prime
    ʒ      Get elements that return 1
     SO     When the sum of the digits
        Q   Equals
       T    10

Presque 8 octets

Cela serait valable si un octet supplémentaire pouvait être ajouté au golf.

žyLØʒSO8Q

Essayez-le en ligne!

Sortie: [17, 53, 71, 107, 233, 251, 431, 503, 521, 701]

Explication

žy          Push number 128, since 701 is the 125th prime
  L         Push array [1, ..., 128]
   ØʒSO8Q   Map to nth primes and filter to those with a digit sum of 8 (see above)
Justin Mariner
la source
3

Mathematica, 52 octets

Select[Prime@Range[10^6],Tr@IntegerDigits@#==52&,10]

{799999,998989,999979,1789999,1798999,1979899,1989979,1997899,1999969,2599999}

merci à @Not un arbre pour -6 octets

J42161217
la source
1
Vous pouvez dire Selectcombien de choses vous voulez retourner:Select[Prime@Range[10^6],Tr@IntegerDigits@#==52&,10]
Pas un arbre
1
Select[Prime@Range[77705],Tr@IntegerDigits@#==50&]
Lynn
2

J, 29 octets

(#~(29=[:+/"."0@":)"0)p:i.872

Essayez-le en ligne!

Fonctionne certainement sur le REPL, fonctionne probablement aussi sur un programme régulier (je ne sais pas comment J effectue la sortie pour que les programmes soient honnêtes).

Premier passage, pas particulièrement idéal, mais je ne vois pas d’approches plus intelligentes. Aller enquêter sur le codage en dur d'une séquence plus petite.

Explication

(#~(29=[:+/"."0@":)"0)p:i.872
                      p:i.872  First 872 primes
 #~                            Filter by
   (29=[:+/"."0@":)"0            Digital sum = 29
                   "0              For each
                ":                 Convert to string
           "."0                    Convert each character to a number
         +/                        Sum results
    29=                            Equate to 29

872 garantit que seuls les 10 premiers nombres premiers dont la somme numérique est 29 seront utilisés.

Cole
la source
2

V , 73 71 octets

i8aa9
998a99
a98a
aa89
18998a9
18a8a
18a9989
197aa
199898a
1a7a9Ía/999

Essayez-le en ligne!

Compression simple de remplacement de sous-chaîne - J'ai vérifié toutes les sorties de réponse possibles, puis j'ai testé "dont l'une remplace une chaîne simple qui enregistre la plupart des caractères". par exemple générer cette table . [edit: J'ai encore regardé la table et j'ai vu que je pouvais faire la version à 71 octets à la place].

Les nombres premiers les plus longs ont 9 suites, et le meilleur que j'ai trouvé est celui où les chiffres totalisent 73, le motif 89999 -> 1 caractère réduit le texte de 99 à 63 octets. Trouver un moyen de défaire 'a' -> '89999' dans les 10 octets restants m'a conduit à V.

TessellatingHeckler
la source
1

Japt , 19 octets

L²õ f_j ©Zìx ¥19ïA

Essaye-le

Explantaion

L²õ

Génère un tableau d'entiers ( õ) compris entre 1 et 100 ( L) au carré.

f_          Ã

Filtrer ( f) en passant chacun à travers une fonction, où Zest l'élément en cours.

j

Vérifiez si Zest un premier.

©

ET logique ( &&).

Zìx

Diviser Zen un tableau de chiffres ( ì) et réduire par addition ( x).

¥19

Vérifiez l'égalité avec 19.

¯A

Slice ( ¯) vers le 10ème élément et génère implicitement le tableau résultant.

Hirsute
la source
1

Japt , 19 octets

AÆ_j ©19¥Zì x «X´}a

Essayez-le en ligne! avec le -Qdrapeau pour formater le tableau.

Affiche les 10 premiers nombres premiers dont les chiffres s'ajoutent à 19:

[199, 379, 397, 487, 577, 739, 757, 829, 883, 919]

Notez que cela pourrait être joué au golf à 18 octets ( ì x→ ìx), mais il n’existe pas de nombres premiers avec une somme de 18.

Explication

AÆ

Mappez le tableau [0, ..., 9]à l'aide de la fonction suivante, où Xest la valeur actuelle.

  _              }a

Renvoie le premier entier renvoyant la valeur true à partir de la fonction suivante, où Zest la valeur actuelle

   j ©

Vérifiez si ce nombre est premier et ...

      19¥Zì x

La somme ( x) des chiffres ( ì) en Zégal à ( ¥) 19,

              «X´

Et Xest la fausseté ( «est "et pas", ou &&!). Cela diminue également X( ´).

Le tableau résultant est implicitement généré.

Justin Mariner
la source
Oh sympa; nous avons noué avec des approches différentes.
Shaggy
1

PARI / GP, 40 octets

select(x->sumdigits(x)==40,primes(8600))

Pas beaucoup de golf à ce sujet (sélectionnez ceux xavec la somme des chiffres 40 parmi les 8600 premiers premiers). La sortie est:

[49999, 68899, 69997, 77899, 78889, 78979, 79699, 79987, 85999, 88789]
Jeppe Stig Nielsen
la source
1

Ruby 2.4.1, 74 octets

Je n'allais jamais battre l'un des langages optimisés pour Codegolf, mais c'était quand même amusant de le faire en Ruby. Frustrer le fait que Prime ne soit pas dans Core mais dans la bibliothèque standard. Je suis également frustré de ne pouvoir battre Haskell.

2.4.1 :014 > require'prime';2.step.lazy.select{|n|n.digits.sum==74&&n.prime?}.first(10)
=> [389999999, 398999999, 498989999, 498998999, 499898999, 499899989, 499979999, 499989989, 579989999, 588999899]
cpt_peter
la source
0

Paradoc (v0.2.7 +), 10 octets (CP-1252)

5h¶fφTBŠT=

Essayez-le en ligne!

5h         .. 5 hundred
  ¶        .. Check if a number is prime...
   f       .. ...filter by the preceding block; converts 500
           .. to the range [0, 1, ..., 499]
    φ      .. Filter by the following block:
     T     .. Ten
      B    .. Base; convert to base-10 digits
       Š   .. Sum, resulting in the digit sum
        T  .. Ten
         = .. Check if (the digit sum and ten are) equal

Un peu discutable car il affiche tous les nombres sans séparateur. Un programme de 11 octets qui imprime chaque numéro sur une ligne distincte:

nIè¶fφTBŠE=

La seule chose qui mérite d’être mentionnée à ce sujet est la limite supérieure qui est légèrement plus difficile à construire: Ièsoit 18² = 324.

betaveros
la source
0

Bubblegum , 37 octets

00000000: 0dc6 3901 4031 0c80 5043 9dfe 9180 7f63  [email protected]
00000010: 6579 f028 9ed7 352d e7a3 4f48 37ff 9164  ey.(..5-..OH7..d
00000020: 4c96 04f7 02                             L....

Essayez-le en ligne!

La sortie est 29989,39799,39979,48799,48889,49789,56989,58699,58789,58897

ovs
la source