Prepare seu código

37

Entrada

nenhuma contribuição para este desafio

O desafio

Escreva um código que produz:
Os 10 primeiros números primos cuja soma de seus dígitos é igual ao número de bytes do seu código

Exemplos

Digamos que seu código é Co&%423@k"oo"qual é o 13 bytes
seu código deve gerar [67, 139, 157, 193, 229, 283, 337, 373, 409, 463]
esses são os 10 primeiros números primos cuja soma .... ok, você conseguiu!

Se o seu código for 8 bytes, você deve enviar[17, 53, 71, 107, 233, 251, 431, 503, 521, 701]

Regras

Você deve usar apenas os primeiros 10 ^ 8 números primos, o
que significa que todos os seus números devem ser <2038074743 = 10 ^ 8º primo

Se você não encontrar 10 números primos nesse intervalo que correspondam aos seus bytes, precisará ajustar o seu código (talvez seja necessário adicionar alguns bytes!) Para encontrar um " número funcional de bytes "

Basta imprimir os 10 números da maneira que desejar

Isso é código-golfe , então o código mais curto em bytes vence!

code-golf  primes  source-layout 
11
Não é possível editar o comentário, apenas excluindo e repassando: Aqui está uma lista contendo os números primos que você precisa gerar para um determinado bytecount, bem como seus índices: link Desde que eu fiz isso ingenuamente, só verifiquei as somas para os primeiros 10 ^ 7 primos. Como algumas respostas mencionaram, existem valores ausentes que provavelmente se correlacionam com somas digitais inatingíveis, embora para somas maiores esse possa não ser o caso (lembre-se, verifiquei apenas os primeiros 10 ^ 7 primos).
— cole
"como você quiser" : os números primos precisam ser pedidos?
— Arnauld
@Arnauld Não, mas eles devem ser os 10 menores em qualquer ordem
11
@KevinCruijssen Embora sua resposta seja inválida, você pode publicá-la para ter uma discussão com outros membros para ajudá-lo a encontrar uma melhor.
11
@TessellatingHeckler Eu também acho que o limite de 10 ^ 8 é bastante arbitrário. Para verificar se dez números fornecidos possuem soma de dígitos 350 e são números primos, deve ser rápido. No entanto, verificar se esses dez são de fato o menor possível, poderia ser mais difícil, eu acho.
— Jeppe Stig Nielsen

Respostas:

15

Neim , 10 8 7 bytes

-1 byte graças ao ASCII-only.

πᛦ𝐋Λ𝐬7𝔼

Experimente online!

Saídas:

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

Isso (bem, pelo menos a abordagem) é inacreditável.

Explicação

πᛦ𝐋Λ𝐬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
— totalmente humano
fonte
2
melhor até agora .. !!!
νᛦ𝐋Λ𝐬7𝔼Para 7 ... edit: π-> ν: p
— Jonathan Allan
@ JonathanAllan Parece que você foi ninja apenas por ASCII. ;)
— totallyhuman 24/08
Uau, há realmente uma instrução para empurrar os primeiros n primos? Arrumado!
— Isaac9A
9

Gelatina , 14 bytes

‘ÆNDS=14ø⁵#‘ÆN

Experimente online!

Isso imprime:

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

Como funciona

‘Æ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
fonte
8
pegue esses números primos!
— Undergroundmonorail
6

Pitão , 14 bytes

.f&qsjZT14P_ZT

Experimente aqui.

São 14 bytes e são impressos:

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

Pitão , 16 bytes

.f&qssM`Z16P_ZTZ

Experimente aqui!

Observe que isso pode ser 15 bytes:, .f&qssM`Z16P_ZTZmas não há números primos que tenham 15 como a soma de seus dígitos, pois 15é divisível por 3, o que implicaria que o número também seria divisível por 3, portanto, não sendo primo.

Tem 16 bytes e imprime:

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

Quão?

Explicação 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.

Explicação 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.
— Mr. Xcoder
fonte
11
Bem feito! e rápido!
“Muito poucos números inteiros primos que têm 15 como a soma de seus dígitos” - na verdade, porque um divisível soma dígitos por 3 implica divisibilidade por 3 :)
— Lynn
@ Lynn Oh certeza> _> - Eu sou burra, desculpe. Corrigido
— Sr. Xcoder
6

Casca , 13 bytes

↑10fȯ=13ΣdfṗN

Experimente online!

Explicação

            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
fonte
Quase golfed-lo para 10 bytes, mas um dos resultados é errada :( tio.run/##yygtzv7//1HbREODtPxDyywftU04sqHg/38A
— Leo
@Leo Heh, seria muito legal se que funcionou :)
— Martin Ender
6

Haskell , 77 71 bytes

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

Experimente online!

Guardado 6 bytes graças a Laikoni

Para 71 bytes:

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

todos os seus números devem ser <2038074743

1999999999 é o número com a soma máxima de dígitos no intervalo permitido e essa soma é 82. Qualquer programa com mais de 82 bytes não satisfará a condição. Espero que 77 bytes estejam ok, mas não sei (ainda está sendo executado no meu computador).

EDIT: uma versão ligeiramente otimizada deu para 77 bytes:

[699899999,779999999,788999999,789999989,797999999,798899999,799898999,799899899,799999799,879999899]
— jferard
fonte
6

Geléia ,  14  13 bytes

DS⁼13
.ȷÆRÇÐf

Experimente online!

Quão?

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
fonte
5

05AB1E , 10 bytes

83LØʒSOTQ}

Experimente online!

O }é usado como preenchimento, pois 9 é uma contagem de bytes inválida.

Saída: [19, 37, 73, 109, 127, 163, 181, 271, 307, 433]

Explicação

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

Quase 8 bytes

Isso seria válido se mais um byte pudesse ser eliminado.

žyLØʒSO8Q

Experimente online!

Saída: [17, 53, 71, 107, 233, 251, 431, 503, 521, 701]

Explicação

ž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
fonte
3

Mathematica, 52 bytes

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

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

thanx para @Não uma árvore para -6 bytes

— J42161217
fonte
11
Você pode dizer Selectquantas coisas você quer retorno:Select[Prime@Range[10^6],Tr@IntegerDigits@#==52&,10]
— Não uma árvore
11
Select[Prime@Range[77705],Tr@IntegerDigits@#==50&]
— Lynn
2

J, 29 bytes

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

Experimente online!

Definitivamente funciona no REPL, provavelmente também funciona em um programa regular (não sei como J faz a saída para os programas serem honestos).

Primeira passagem, não particularmente ideal, mas não consigo pensar em nenhuma abordagem mais inteligente. Indo para a codificação codificada de uma sequência menor.

Explicação

(#~(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 garante que apenas os 10 primeiros números primos cuja soma digital é 29 serão usados.

— Cole
fonte
2

V , 73 71 bytes

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

Experimente online!

Compactação simples de substituição de substring - verifiquei todas as saídas de resposta possíveis e depois fiz alguns testes - "qual deles tem uma substituição simples de string que salva a maioria dos caracteres". por exemplo, gerar esta tabela . [edit: Olhei novamente para a mesa e vi que eu poderia fazer a versão de 71 bytes].

Os números primos mais altos têm execuções mais longas de 9, e o melhor que encontrei foi onde os dígitos somam 73, o padrão 89999 -> 1 char reduz o texto de 99 bytes para 63 bytes. Encontrar uma maneira de desfazer 'a' -> '89999' nos 10 bytes restantes me levou a V.

— TessellatingHeckler
fonte
1

Japonês , 19 bytes

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

Teste-o

Explantaion

L²õ

Gere uma matriz de números inteiros ( õ) de 1 a 100 ( L) ao quadrado.

f_          Ã

Filtre ( f) passando cada um por uma função, onde Zestá o elemento atual.

j

Verifique se Zé primo.

©

AND lógico ( &&).

Zìx

Divida Zem uma matriz de dígitos ( ì) e reduza pela adição ( x).

¥19

Verifique a igualdade com 19.

¯A

Fatia ( ¯) para o 10º elemento e gera implicitamente a matriz resultante.

— Shaggy
fonte
1

Japonês , 19 bytes

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

Experimente online! com o -Qsinalizador para formatar a matriz.

Produz os 10 primeiros números primos cujos dígitos são adicionados a 19:

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

Observe que isso pode ter um golfe de 18 bytes ( ì x→ ìx), mas não existem números primos com uma soma de dígitos 18.

Explicação

AÆ

Mapeie a matriz [0, ..., 9]pela seguinte função, onde Xestá o valor atual.

  _              }a

Retorna o primeiro número inteiro que retorna true a partir da seguinte função, onde Zestá o valor atual

   j ©

Verifique se esse número é primo e ...

      19¥Zì x

A soma ( x) dos dígitos ( ì) em Zigual a ( ¥) 19,

              «X´

E Xé falso ( «é "e não", ou &&!). Isso também diminui X( ´).

A matriz resultante é gerada implicitamente.

— Justin Mariner
fonte
Ah legal; nós amarramos com diferentes abordagens.
— Shaggy
1

PARI / GP, 40 bytes

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

Não há muito golfe nisso (selecione aqueles xcom a soma dos dígitos 40 entre os primeiros 8600 primos). A saída é:

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

Ruby 2.4.1, 74 bytes

Eu nunca iria vencer uma das linguagens otimizadas do Codegolf, mas ainda era divertido fazê-lo em Ruby. Frustrante que o Prime não esteja no Core, mas na biblioteca padrão. Também estou frustrado por não conseguir derrotar 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
fonte
0

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

5h¶fφTBŠT=

Experimente 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

Um tanto questionável, pois imprime todos os números sem separador entre eles. Um programa de 11 bytes que imprime cada número em uma linha separada:

nIè¶fφTBŠE=

A única coisa que vale a pena mencionar é o limite superior que é um pouco mais difícil de construir: Ièé 18² = 324.

— betaveros
fonte
0

Bubblegum , 37 bytes

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

Experimente online!

Saída é 29989,39799,39979,48799,48889,49789,56989,58699,58789,58897

— ovs
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.