Выведите n-е простое число, содержащее n


39

Этот вопрос станет поворотом при поиске nпростого числа.

Вызов

Вы должны написать программу, которая будет принимать один вход nи выводить nпростое число, десятичное представление которого содержит десятичное представление nв виде подстроки.

Смущенный? Вот несколько примеров.

n=1
Primes: 2, 3, 5, 7, 11
                    ^1 first prime that contains a 1
Output: 11

n=2
Primes: 2, 3, 5, 7, 11, 13, 17, 19, 23
        ^1                          ^2 second prime that contains a 2
Output: 23

n=3
Primes: 2, 3, 5, 7, 11, 13, 17, 19, 23
           ^1           ^2          ^3 third prime that contains a 3
Output: 23

n=10
Primes: 2, 3, 5, 7, 11, ..., 97, 101, 103, 107, 109, ..., 997, 1009, 1013, 1019, 1021, 1031, 1033
                                 ^1   ^2   ^3   ^4             ^5    ^6    ^7    ^8    ^9    ^10 tenth prime that contains a 10
Output: 1033

Это , поэтому выигрывает меньшее количество байтов.

Если что-то сбивает с толку, пожалуйста, оставьте комментарий.


2
Есть ли OEIS для этого? Такое ощущение, что должно быть
MayorMonty

@SpeedyNinja Нет, я уже проверил.
Аднан


1
Я не могу поверить, что это добралось до номера 5 в Hot Network Questionsсписке.
ericw31415

Ответы:


12

05AB1E , 8 байтов

Код:

µN¹åNp*½

Объяснение:

µ          # Run this until the counting variable has reached the input value.
 N¹å       # Check if the input number is in the range variable.
    Np     # Check if the range variable is prime.
      *    # Multiply those two numbers (which is basically an AND operator).
       ½   # If true, increment the counting variable.
           # After the loop, the stack is empty and implicitly prints N.

Использует кодировку CP-1252 . Попробуйте онлайн! ,



8

Python 2, 67 65 62 байта

f=lambda n,k=0,m=2,p=1:k/n or-~f(n,k+p%m*(`n`in`m`),m+1,p*m*m)

Проверьте это на Ideone .

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

Мы используем следствие теоремы Вильсона :

следствие теоремы Вильсона

Всегда переменная p равна квадрату факториала m - 1 .

Если k <n , то k/nбудет 0 и f вызывается рекурсивно. m увеличивается, p обновляется, а k увеличивается тогда и только тогда, когда m является простым числом, содержащим n .

Последнее достигается путем добавления результата p%m*(`n`in`m`)к k . По следствию из теоремы Вильсона, если m простое, p%mвозвращает 1 , а если нет, то возвращает 0 .

Как только k достигает n , мы нашли q , n- е простое число, которое содержит n .

Мы находимся в следующем звонке во время проверки, поэтому m = q + 1 . k/nвернет 1 , и побитовые операторы -~будут увеличивать это число один раз для каждого вызова функции. Так как для увеличения m от 2 до q + 1 требуется q - 1 вызовов f , самый внешний вызов f вернет 1 + q - 1 = q , как и предполагалось.


6

Баш, 27 байт

primes 0|grep $1|sed $1q\;d

primes происходит от bsdgames.

Принимает ввод в качестве аргумента командной строки и выводит на STDOUT.



4

Mathematica, 75 байтов

Nest[NestWhile[b=NextPrime,b@#,!StringContainsQ@@ToString/@{#,a}&]&,1,a=#]&

Может все еще быть пригодным для игры в гольф.


Это, пожалуй, самое быстрое решение, поскольку оно использует NextPrime :)

4

Ява, 194 180 173 171 112 байт

Код:

a->{int i=1,j,n,r=0;for(j=n=new Integer(a);(r+=++i>=j&(""+j).contains(""+n)?1:0)!=n;j+=j%i==0?i=1:0);return j;}

Ungolfed:

class P{
    static int i=1,j,n,r;
    public static void main(String[]s) {
        for(
                j=n=new Integer(s[0]); //executes once before first iteration
                (r+=++i>=j&(""+j).contains(""+n)?1:0)!=n; //executes on first and every iteration
                j+=j%i==0?i=1:0 //executes after first and every iteration
           ) {
            ;
        }
        System.out.print(j);
    }
}

Привет, добро пожаловать в PPCG! Обратите внимание на две вещи: 1. Вы можете удалить два пробела в P {и String[] s. И 2. вы в настоящее время только даете вывод для 10, но задача кода-гольфа заключалась в том, чтобы взять вход nи дать правильный вывод на основе этого ввода. Кроме того, вы можете найти это интересным: Советы по игре в гольф на Яве.
Кевин Круйссен

3

Рубин, 62 61 байт

->i{Prime.lazy.map(&:to_s).grep(/#{i}/).first(i)[-1]}

Требуется -rprimeфлаг (+8 байт).

->i{            # lambda with one argument
Prime           # iterator over all primes
.lazy           # make the iterator lazy (can't evaluate infinite primes)
.map(&:x.to_s)  # convert the primes to strings
.grep(/#{i}/)   # find primes that regex match on the input (contain it)
.first(i)       # take the first (input) primes that satisfy this
[-1]            # take the last of those
}


3

MATL , 18 байт

`@YqVGVXf?3M]NG<]&

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

объяснение

Это генерирует простые числа в порядке, используя do...whileцикл. Для каждого простого числа проверяется условие (и простое число расходуется). Если выполнено, то простое число снова помещается в стек. Количество элементов в стеке используется для подсчета количества найденных нами подходящих простых чисел. Когда их достаточно, отображается последний.

`         % Do...while
  @       %   Push iteration index, k. Starts at 1
  YqV     %   k-th prime. Convert to string
  GV      %   Push input, n. Convert to string
  Xf      %   Find string within another
  ?       %   If non-empty
    3M    %     Push k-th prime again (increase stack size by 1)
  ]       %   End if
  NG<     %   Is stack size less than input number? If so proceeed with
          %   a new iteration; else exit do...while loop
]         % End do...while
&         % Implicitly display only top number in the stack 


1

Bash + GNU coreutils, 66 байт

В отличие от решения @ Doorknob, для этого нужны только те вещи, которые установлены на каждом GNU / Linux:

for((n=2;;n++)){
[ `factor $n|wc -w` -eq 2 ]&&grep $1<<<$n&&exit
}

seq 1e20|factor|grep -Po "(?<=: )\d*$2\d$"|sed $1q\;d
Цифровая травма

@DigitalTrauma, мой мозг не работает таким образом ;-)
rexkogitans

Нужны ли ему новые строки?
ericw31415

После for((...)){должен быть пробел или перевод строки, поэтому это не имеет значения. Перед закрытием }должен быть ; символ новой или новой строки, поэтому это тоже не имеет значения.
rexkogitans

1

Perl 6 , 41 байт

->$n {grep({.is-prime&&/$n/},2..*)[$n-1]}

Объяснение:

-> $n { # has one parameter
  grep(
    {
      .is-prime # check that it is prime
      &&        # and
      / $n /    # that it contains the argument in the "string"
    },
    2 .. *      # for all numbers starting with 2
  )[ $n - 1 ]   # only take the $n-th one
                # ( accounting for 0 based array access )
}

Тест:

#! /usr/bin/env perl6
use v6.c;
use Test;

my &prefix:<ℙ𝕟> = ->$n {grep({.is-prime&&/$n/},2..*)[$n-1]}

my @test = (
  1  => 11,
  2  => 23,
  3  => 23,
  10 => 1033,
);

plan +@test;

for @test {
  is ℙ𝕟.key, .value, .gist
}
1..4
ok 1 - 1 => 11
ok 2 - 2 => 23
ok 3 - 3 => 23
ok 4 - 10 => 1033

1

Java 8, 192 183 181 171 байт (полная программа)

interface M{static void main(String[]a){long n=new Long(a[0]),c=0,r=1,m,i;for(;c<n;c+=m>1&(r+"").contains(a[0])?1:0)for(m=++r,i=2;i<m;m=m%i++<1?0:m);System.out.print(r);}}

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

Объяснение:

interface M{                    // Class
  static void main(String[]a){  //  Mandatory main-method
    long n=new Long(a[0]),      //   Input argument as number
         c=0,                   //   Counter, starting at 0
         r=1,                   //   Result-number, starting at 1
         m,i;                   //   Temp number
    for(;c<n;                   //   Loop as long as `c` does not equals `n`
        c+=                     //     After every iteration: increase `c` by:
           m>1                  //      If the current `r` is a prime,
           &(r+"").contains(a[0])?
                                //      and this prime contains the input `n`
            1                   //       Increase `c` by 1
           :                    //      Else:
            0)                  //       Leave `c` the same
      for(m=++r,                //    Increase `r` by 1 first with `++r`, and set `m` to it
          i=2;i<m;              //    Inner loop `i` in the range [2, `m`)
        m=m%i++<1?              //     If `m` is divisible by `i`
           0                    //      Change `m` to 0 (so it's not a prime)
          :                     //     Else:
           m);                  //      Leave `m` unchanged
    System.out.print(r);}}      //    Print `r` as result

Java 8, 105 байт (лямбда-функция)

n->{int c=0,r=1,m,i;for(;c<n;c+=m>1&(r+"").contains(n+"")?1:0)for(m=++r,i=2;i<m;m=m%i++<1?0:m);return r;}

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

То же, что и выше, но с nцелочисленным вводом и без подробного материала класса.


1
вы можете заменить &&с &и удалить ?из вашего регулярного выражения.
Утес

@cliffroot Спасибо, отредактировал пост. Я всегда забываю &&и &по какой-то причине ..
Кевин Круйссен

0

Clojure, 118 байт

(defn s[n](nth(filter(fn[x](if(.contains(str x)(str n))(not-any? #(=(mod x %)0)(range 2 x))))(drop 2(range)))(dec n)))

Просто получает n-й элемент ленивой бесконечной последовательности чисел, которые являются простыми и имеют nв своем строковом представлении.

Вы можете попробовать это здесь: https://ideone.com/ioBJjt


0

На самом деле, 16 байтов

;$╗`P$╜@íu`╓dP.X

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

Объяснение:

;$╗`P$╜@íu`╓dP.X
;$╗               make a copy of n, push str(n) to reg0
   `      `╓      push the first n values where f(k) is truthy, starting with k=0:
    P$              kth prime, stringified
      ╜@íu          1-based index of n, 0 if not found
            d     remove last element of list and push it to the stack (dequeue)
             P    nth prime
              .   print
               X  discard rest of list

0

PowerShell v2 +, 108 99 байт

Ooof. Отсутствие каких-либо встроенных простых вычислений / проверок действительно вредит здесь.

param($n)for(){for(;'1'*++$i-match'^(?!(..+)\1+$)..'){if("$i"-like"*$n*"){if(++$o-eq$n){$i;exit}}}}

Принимает ввод $n, входит в бесконечный for()цикл. На каждой итерации мы используем forцикл, обернутый вокруг основной проверки регулярных выражений PowerShell (h / t для Мартина), чтобы превратить его в простой генератор путем увеличения$i каждый раз цикл. (Например, запуск только for(){for(;'1'*++$i-match'^(?!(..+)\1+$)..'){$i}}выдаст2, 3, 5, 7... разделенный новыми строками).

Затем просто -likeпроверьте, есть ли $nгде-нибудь $i, и увеличьте наш счетчик $o. Если мы достигли, где $nи $oравны, выведите $iи exit. В противном случае мы продолжаем через forпоиск следующего простого числа, и процесс повторяется.


0

APL (NARS), 39 символов, 78 байтов

{s←⍕w←⍵⋄2{(w≤⍵)∧k←∨/s⍷⍕⍺:⍺⋄(1π⍺)∇⍵+k}1}

1π - следующее простое число ...; тест:

  f←{s←⍕w←⍵⋄2{(w≤⍵)∧k←∨/s⍷⍕⍺:⍺⋄(1π⍺)∇⍵+k}1}
  f¨1 2 3 10
11 23 23 1033 

но это уже в 20 выходит из стека ... Вместо этого это выглядит хорошо, даже если длина немного длиннее (61 символ)

∇r←f w;i;k;s
r←2⋄s←⍕w⋄i←1
→0×⍳(w≤i)∧k←∨/s⍷⍕r⋄r←1πr⋄i+←k⋄→2
∇

  f¨1 2 3 10 20 100
11 23 23 1033 4201 100999 

0

Добавить ++ , 36 байт

L,5*2^RßÞPABDBJVB]dG€Ωezߣ*BZB]A1_$:

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

Довольно неэффективно. Итерирует по каждому целому числуя такой, что я25Икс2 и отфильтровывает композиты и простые числа, которые не содержат N, Наконец, мы беремNth значение оставшихся целых чисел.


Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.