Ingresso

nessun input per questa sfida

La sfida

Scrivi un codice che genera:
I primi 10 numeri primi la cui somma delle loro cifre è uguale al numero di byte del tuo codice

Esempi

Diciamo che il tuo codice è Co&%423@k"oo"qual è il 13 bytes
tuo codice che deve generare [67, 139, 157, 193, 229, 283, 337, 373, 409, 463]
quelli che sono i primi 10 numeri primi la cui somma .... ok hai capito!

Se il codice è 8 bytes, è necessario l'output[17, 53, 71, 107, 233, 251, 431, 503, 521, 701]

Regole

Devi usare solo i primi 10 ^ 8 numeri primi, il
che significa che tutti i tuoi numeri devono essere <2038074743 = 10 ^ 8o numero primo

Se non riesci a trovare 10 numeri primi in questo intervallo adatti ai tuoi byte, dovrai adattare il tuo codice (potresti anche dover aggiungere alcuni byte!) Per trovare un " numero di byte funzionante "

Invia semplicemente i 10 numeri primi nel modo che preferisci

Questo è code-golf , quindi vince il codice più breve in byte!

Neim , 10 8 7 byte

-1 byte grazie solo a ASCII.

πᛦ𝐋Λ𝐬7𝔼

Provalo online!

Uscite:

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

Questo (beh, almeno l'approccio) è ungolfable.

Spiegazione

πᛦ𝐋Λ𝐬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

Gelatina , 14 byte

‘ÆNDS=14ø⁵#‘ÆN

Provalo online!

Questo stampa:

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

Come funziona

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

Pyth , 14 byte

.f&qsjZT14P_ZT

Provalo qui.

Si tratta di 14 byte e stampe:

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

Pyth , 16 byte

.f&qssM`Z16P_ZTZ

Provalo qui!

Si noti che questo potrebbe essere 15 byte:, .f&qssM`Z16P_ZTZma non ci sono numeri primi che hanno 15 come somma delle loro cifre, poiché 15è divisibile per 3, il che implicherebbe che il numero sarebbe anche divisibile per 3, quindi non essere primo.

È lungo 16 byte e stampa:

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

Come?

Spiegazione 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.

Spiegazione 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.

Buccia , 13 byte

↑10fȯ=13ΣdfṗN

Provalo online!

Spiegazione

            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.

Haskell , 77 71 byte

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

Provalo online!

6 byte salvati grazie a Laikoni

Per 71 byte:

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

tutti i tuoi numeri devono essere <2038074743

1999999999 è il numero con la somma massima di cifre nell'intervallo consentito e tale somma è 82. Qualsiasi programma che superi gli 82 byte non soddisferà la condizione. Spero che 77 byte sia ok, ma non lo so (è ancora in esecuzione sul mio computer).

EDIT: una versione leggermente ottimizzata ha dato per 77 byte:

[699899999,779999999,788999999,789999989,797999999,798899999,799898999,799899899,799999799,879999899]

Jelly ,  14  13 byte

DS⁼13
.ȷÆRÇÐf

Provalo online!

Come?

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

Brachylog , 13 byte

{.≜ṗẹ+13∧}ᶠ¹⁰

Provalo online!

05AB1E , 10 byte

83LØʒSOTQ}

Provalo online!

Il } viene utilizzato come riempitivo, dal 9 è un numero di byte non valido.

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

Spiegazione

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

Quasi 8 byte

Ciò sarebbe valido se fosse possibile escludere un altro byte.

žyLØʒSO8Q

Provalo online!

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

Spiegazione

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

Mathematica, 52 byte

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

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

grazie a @Non un albero per -6 byte

J, 29 byte

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

Provalo online!

Funziona sicuramente su REPL, probabilmente funziona anche con un programma regolare (non sono sicuro di come J esegua l'output dei programmi per essere onesti).

Primo passaggio, non particolarmente ideale ma non riesco a pensare ad approcci più intelligenti. Andando a studiare hardcoding una sequenza più piccola.

Spiegazione

(#~(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 garantisce che verranno utilizzati solo i primi 10 numeri primi la cui somma digitale è 29.

V , 73 71 byte

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

Provalo online!

Semplice compressione di sostituzione della sottostringa - Ho controllato tutti i possibili risultati delle risposte, e poi ho fatto alcuni "quale ha una semplice sostituzione di stringa che salva la maggior parte dei caratteri". ad es. generare questa tabella . [modifica: ho guardato di nuovo la tabella e ho visto che invece potevo fare la versione a 71 byte].

I numeri primi più alti hanno più lunghe sequenze di 9 in essi, e il migliore che ho trovato è stato il punto in cui le cifre si sommano a 73, il modello 89999 -> 1 carattere porta il testo da 99 byte a 63 byte. Trovare un modo per annullare 'a' -> '89999' nei restanti 10 byte mi ha portato a V.

Japt , 19 byte

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

Provalo

Explantaion

L²õ

Genera una matrice di numeri interi ( õ) da 1 a 100 ( L) al quadrato.

f_          Ã

Filtra ( f) passando ciascuno attraverso una funzione, dove si Ztrova l'elemento corrente.

j

Controlla se Zè un numero primo.

©

AND logico ( &&).

Zìx

Dividi Zin una matrice di cifre ( ì) e riduci per addizione ( x).

¥19

Controlla l'uguaglianza con 19.

¯A

Slice ( ¯) al decimo elemento e genera implicitamente l'output della matrice risultante.

Japt , 19 byte

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

Provalo online! con il-Q flag per formattare l'array.

Emette i primi 10 numeri primi le cui cifre si aggiungono a 19:

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

Si noti che questo può essere giocato a 18 byte ( ì x→ìx ), ma non esistono numeri primi con una somma di 18 cifre.

Spiegazione

AÆ

Mappare l'array [0, ..., 9]mediante la seguente funzione, dove si Xtrova il valore corrente.

  _              }a

Restituisce il primo numero intero che restituisce true dalla seguente funzione, dove Zè il valore corrente

   j ©

Controlla se questo numero è primo e ...

      19¥Zì x

La somma ( x) delle cifre ( ì) in Zequals ( ¥) 19,

              «X´

Ed Xè falsa ( «è "e non", o &&!). Anche questo decrementa X( ´).

L'array risultante viene implicitamente emesso.

PARI / GP, 40 byte

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

Non molto golf a riguardo (seleziona quelli xcon la somma delle cifre 40 tra i primi 8600 numeri primi). L'output è:

[49999, 68899, 69997, 77899, 78889, 78979, 79699, 79987, 85999, 88789]

Pyke , 10 byte

~p#.cTq)T>

Provalo qui!

~p         -   primes
  #.cTq)   -  filter(^)
   .c      -    digit_sum
     Tq    -   ^ == 10
        T> - [:10]

Ruby 2.4.1, 74 byte

Non avrei mai battuto una delle lingue ottimizzate di Codegolf, ma è stato comunque divertente farlo in Ruby. Frustrante che Prime non sia in Core ma in invece nella libreria standard. Sono anche frustrato di non poter battere 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]

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

5h¶fφTBŠT=

Provalo online!

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 po 'discutibile poiché stampa tutti i numeri senza un separatore tra di loro. Un programma a 11 byte che stampa ogni numero su una riga separata:

nIè¶fφTBŠE=

L'unica cosa degna di nota è il limite superiore che è leggermente più difficile da costruire: Ièè 18² = 324.

Bubblegum , 37 byte

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

Provalo online!

L'output è 29989,39799,39979,48799,48889,49789,56989,58699,58789,58897