вход

нет входных данных для этого вызова

Соревнование

Напишите код, который выводит:
первые 10 простых чисел, сумма цифр которых равна количеству байтов вашего кода

Примеры

Допустим, ваш код - Co&%423@k"oo"это 13 bytes
ваш код, который должен выводить [67, 139, 157, 193, 229, 283, 337, 373, 409, 463]
те первые 10 простых чисел, чья сумма .... хорошо, вы поняли!

Если ваш код есть 8 bytes, вы должны вывести[17, 53, 71, 107, 233, 251, 431, 503, 521, 701]

правила

Вы должны использовать только первые 10 ^ 8 простых чисел,
что означает, что все ваши числа должны быть <2038074743 = 10 ^ 8-е простые

Если вы не можете найти 10 простых чисел в этом диапазоне, которые соответствуют вашим байтам, то вам придется скорректировать свой код (возможно, вам даже придется добавить несколько байтов!), Чтобы найти « рабочее число байтов »

Просто выведите 10 простых чисел так, как вам нравится

Это код-гольф , поэтому выигрывает самый короткий код в байтах!

Нейм , 10 8 7 байт

-1 байт благодаря ASCII-только.

πᛦ𝐋Λ𝐬7𝔼

Попробуйте онлайн!

Выходы:

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

Это (ну, по крайней мере, подход) нелегко.

объяснение

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

Желе , 14 байт

‘ÆNDS=14ø⁵#‘ÆN

Попробуйте онлайн!

Это печатает:

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

Как это работает

‘Æ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 байт

.f&qsjZT14P_ZT

Попробуй это здесь.

Это 14 байтов и отпечатки:

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

Pyth , 16 байт

.f&qssM`Z16P_ZTZ

Попробуй это здесь!

Обратите внимание, что это может быть 15 байт:, .f&qssM`Z16P_ZTZно нет простых чисел, в которых сумма их цифр 15равна 15, поскольку она делится на 3, что означает, что число также будет делиться на 3, следовательно, не будет простым числом .

Это 16 байтов в длину и печатает:

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

Как?

Объяснение 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.

Объяснение 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.

Шелуха , 13 байт

↑10fȯ=13ΣdfṗN

Попробуйте онлайн!

объяснение

            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 байт

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

Попробуйте онлайн!

Сохранено 6 байтов благодаря Laikoni

Для 71 байта:

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

все ваши номера должны быть <2038074743

1999999999 - это число с максимальной суммой цифр в допустимом диапазоне, и эта сумма равна 82. Любая программа, длина которой превышает 82 байта, не будет удовлетворять условию. Я надеюсь, что 77 байтов в порядке, но я не знаю (он все еще работает на моем компьютере).

РЕДАКТИРОВАТЬ: слегка оптимизированный вариант дал для 77 байтов:

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

Желе ,  14  13 байтов

DS⁼13
.ȷÆRÇÐf

Попробуйте онлайн!

Как?

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

Брахилог , 13 байт

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

Попробуйте онлайн!

05AB1E , 10 байтов

83LØʒSOTQ}

Попробуйте онлайн!

В }качестве заполнителя используется, так как 9 - неверное количество байтов.

Выход: [19, 37, 73, 109, 127, 163, 181, 271, 307, 433]

объяснение

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

Почти 8 байт

Это было бы действительно, если бы можно было отключить еще один байт.

žyLØʒSO8Q

Попробуйте онлайн!

Выход: [17, 53, 71, 107, 233, 251, 431, 503, 521, 701]

объяснение

ž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 байта

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

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

спасибо @ не дереву за -6 байт

J, 29 байт

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

Попробуйте онлайн!

Определенно работает на REPL, возможно, работает и обычная программа (не уверен, как J выводит программы, если честно).

Первый проход, не особенно идеальный, но я не могу придумать более умных подходов. Собираюсь исследовать жесткое кодирование меньшей последовательности.

объяснение

(#~(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 гарантирует, что будут использоваться только первые 10 простых чисел, чья цифровая сумма равна 29.

V , 73 71 байт

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

Попробуйте онлайн!

Сжатие с простой заменой подстроки - я проверил все возможные выходные данные ответа, а затем выполнил тестирование «у которого простая замена строки, которая сохраняет большинство символов». например, создание этой таблицы . [править: я снова посмотрел на таблицу и увидел, что могу вместо этого сделать версию на 71 байт].

Более высокие простые числа содержат более длинные серии из 9, и лучшее, что я нашел, было то, где цифры складывают до 73, шаблон 89999 -> 1 символ сокращает текст с 99 байтов до 63 байтов. Поиск пути отмены 'a' -> '89999' в оставшихся 10 байтах привел меня к V.

Japt , 19 байт

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

Попробуй это

Explantaion

L²õ

Создайте массив целых чисел ( õ) от 1 до 100 ( L) в квадрате.

f_          Ã

Filter ( f), передавая каждый через функцию, где Zнаходится текущий элемент.

j

Проверьте, Zявляется ли простое число.

©

Логическое И ( &&).

Zìx

Разбить Zна массив цифр ( ì) и уменьшить путем добавления ( x).

¥19

Проверьте на равенство с 19.

¯A

Slice ( ¯) до 10-го элемента и неявно выводить результирующий массив.

Japt, 19 bytes

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

Try it online! with the -Q flag to format the array.

Outputs the first 10 primes whose digits add to 19:

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

Note that this could be golfed to 18 bytes (ì x → ìx), but no primes with a digit sum of 18 exist.

Explanation

AÆ

Map the array [0, ..., 9] by the following function, where X is the current value.

  _              }a

Return the first integer that returns true from the following function, where Z is the current value

   j ©

Check if this number is prime, and...

      19¥Zì x

The sum (x) of the digits (ì) in Z equals (¥) 19,

              «X´

And X is falsy (« is "and not", or &&!). This also decrements X (´).

Resulting array is implicitly outputted.

PARI/GP, 40 bytes

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

Not much golf about it (select those x with sum of digits 40 among first 8600 primes). Output is:

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

Pyke, 10 bytes

~p#.cTq)T>

Try it here!

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

Ruby 2.4.1, 74 Bytes

I was never going to beat one of the Codegolf optimised languages, but it was still fun to do it in Ruby. Frustrating that Prime is not in Core but in instead in the standard library. I am also frustrated that I can't beat 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 bytes (CP-1252)

5h¶fφTBŠT=

Try it 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

Somewhat questionable since it prints all the numbers with no separator between them. An 11-byte program that prints each number on a separate line:

nIè¶fφTBŠE=

The only thing worth mentioning about it is the upper bound that's slightly more difficult to construct: Iè is 18² = 324.

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

Try it online!

Output is 29989,39799,39979,48799,48889,49789,56989,58699,58789,58897