В 1946 году Эрдос и Коупленд доказали, что определенное число является нормальным числом , то есть цифры в его десятичном разряде распределены равномерно.

Пользователи будут вводить последовательность цифр, и вы найдете наименьшее простое число, которое содержит эту строку в базе 10.

Пример:

input   -> output
"10"    -> 101
"03"    -> 103
"222"   -> 2221
"98765" -> 987659

Самый короткий код в байтах побеждает. Я знаю, что некоторые языки (mathematica, sage, pari-gp ...) поставляются со встроенными функциями, связанными с простыми числами. -50 байт, если ваша программа не использует такие функции. Не пытайтесь обмануть это, пожалуйста, если ваш язык уже имеет огромное преимущество, не претендуйте на бонус.

редактировать

Согласно нескольким комментариям ниже, наименьшее простое число, которое содержит «03», равно 3. Это действительно имеет значение? Единственное, о чем я могу думать, это то, что, возможно, числа легче обрабатывать, чем строки.

В таких случаях, как «03», предпочтительным выводом будет 103. Однако я не считаю его основной частью вашей программы, поэтому вы можете игнорировать любой начальный ноль, если он дает вам меньшее количество байтов.

Golfscipt, 33 32 байта = -18 балл

2{:x,2>{x\%!},!!x`3$?)!|}{)}/;;x

Объяснение:

• 2{...}{)}/- начиная с 2, пока что-то верно, увеличивать вершину стека

• ;;x- отбросьте промежуточные значения, собранные {}{}/и введенные данные, затем поместите последнее проверенное значение

• :x,2>- хранить значение , как x, то список от 2доx-1

• {x\%!},!!- оставьте те, которые xделятся на, затем приведите к логическому (не пустому)
• x`3?)!- поискать ввод в текстовом виде x( -1если не найден), приращение, отрицание.
• | - или

Программа на Haskell, 97 символов = 47 баллов

main=getLine>>= \i->print$head$[x|x<-[2..],all((/=0).mod x)[2..x-1],i`Data.List.isInfixOf`show x]

Функция Haskell, 75 символов = 25 баллов

p i=head$[x|x<-[2..],all((/=0).mod x)[2..x-1],i`Data.List.isInfixOf`show x]

тип pесть (Integral a, Show a) => [Char] -> a. Если вы предоставляете свой собственный целочисленный тип, вы можете искать по инфиксам в своем собственном представлении этих значений. Стандарт Integerиспользует ожидаемые десятичные обозначения для целых чисел.

Не очень быстро Квадратичное значение (не размер) вывода.

версия без золота:

import Data.List
leastPrime infix = head $ filter prime' [2..]
  where prime' x  = all (\n-> x`mod`n /= 0) [2..x-1]
                 && i `isInfixOf` show x
main = print . leastPrime =<< getLine

пример:

Prelude> let p i=head$[x|x<-[2..],all((/=0).mod x)[2..x-1],i`Data.List.isInfixOf`show x]
Prelude> p "0"
101
Prelude> p "00"
1009
Prelude> p "000" -- long pause
10007

Ява - 175 символов.

class s{public static void main(String[]a){int i,n=2,p;for(;;){p=1;for(i=3;i<n;i++)if(n%i==0)p=0;if((n==2||p>0)&&(""+n).indexOf(a[0])>=0) {System.out.println(n);break;}n++;}}}

Mathematica 58

(n=1;While[StringCases[ToString[p=Prime@n],#]=={},n++];p)&

Относительная синхронизация на моем Mac (2,6 ГГц i7 с 8 ГБ памяти).

Найдите наименьшее простое число, содержащее «01».

AbsoluteTiming[(n = 1; While[StringCases[ToString[p = Prime@n], #] == {}, n++]; p) &["01"]]

{0.000217, 101}

Найдите наименьшее простое число, содержащее «012345».

AbsoluteTiming[(n = 1; While[StringCases[ToString[p = Prime@n], #] == {}, n++]; p) &["012345"]]

{5.021915, 10123457}

Найдите наименьшее простое число, содержащее «0123456».

AbsoluteTiming[(n = 1; While[StringCases[ToString[p = Prime@n], #] == {}, n++]; p) &["0123456"]]

{87.056245, 201234563}

Мудрец , 72

Запускается в интерактивном режиме

a=raw_input()
i=0
p=2
while a not in str(p):i+=1;p=Primes().unrank(i)
p

Primes().unrank(i)дает iпростое число, причем 0-е простое число равно 2.

R, 56 знаков -50 = 6

k=2;n=scan(,"");while(!grepl(n,k)|sum(!k%%2:k)>1)k=k+1;k

Примите вход как стандартный. Увеличивает k, пока k не станет простым числом (проверяется путем суммирования экземпляров, для которых k mod 2 и k равны нулю, следовательно, FALSE, поскольку 0 превращено в логическое, равно FALSE) и содержит строку, заданную в качестве входных данных (проверено с помощью простого grep, здесь grepl так как мы хотим логичный результат).

Использование:

> k=2;n=scan(,"");while(!grepl(n,k)|sum(!k%%2:k)>1)k=k+1;k
1: "03"
2: 
Read 1 item
[1] 103
> k=2;n=scan(,"");while(!grepl(n,k)|sum(!k%%2:k)>1)k=k+1;k
1: "003"
2: 
Read 1 item
[1] 2003

оболочки оболочки (coreutils): 45 знаков

Не определяя здесь функцию ... просто единый аргумент, который принимает один аргумент $nи сканирует целочисленный диапазон (фактически немного больше, чтобы сделать код короче). Версия из 55 символов:

seq 5e9|grep $n|factor|awk '{if(NF==2)print $2}'|head -n1

Это даже не слишком медленно. Для n=0123456возвращается 201234563в 81.715s. Это впечатляюще быстро для длинного конвейера с двумя строковыми процессорами.

Удалив два символа (до 53) и один канал, мы можем запустить его еще быстрее:

seq 5e9|grep $n|factor|awk '{if(NF==2){print $2;exit}}'

И, наконец, немного sedволшебства, чтобы уменьшить его до 45 символов , хотя распечатка уродлива:

seq 5e9|grep $n|factor|sed -n '/: \w*$/{p;q}'

n = 000 -> 10007: 10007 (пользователь 0,017 с)

n = 012345 -> 10123457: 10123457 (пользователь 7.11s)

n = 0123456 -> 201234563: 201234563 (пользователь 66.8s)

J - 38 символов -50 = -12 баллов

Обычно в J вы бы использовали очень оптимизированные встроенные функции, предназначенные для простых чисел, поэтому я не собираюсь извиняться за медлительность выполнения.

>:@]^:(>./@(E.":)*:]=*/@(+.i.)@])^:_&2

Разъяснение:

• >:@]^:(...)^:_&2- Начиная с 2, увеличивать до тех пор, пока не (...)вернется значение false.
• (+.i.)@]- Возьмите GCD счетчика с каждым целым числом меньше его. (Мы используем соглашение GCD (X, 0) = X.)
• ]=*/@- Возьмите произведение всех этих чисел и проверьте на равенство со счетчиком. Если счетчик прост, список был все 1, за исключением GCD с 0; иначе будет хотя бы один GCD, который больше 1, поэтому продукт будет больше, чем счетчик.
• >./@(E.":)- Проверьте, ":содержит ли строковое представление counter ( ) строку ( E.) в любой точке. >./является функцией max, и мы используем ее, потому что E.возвращает логический вектор с 1, где подстрока начинается в основной строке.
• *:- Логически NAND результаты вместе. Это будет ложью, только если оба входа были истинны, то есть если счетчик был простым и содержал подстроку.

Использование:

   >:@]^:(>./@(E.":)*:]=*/@(+.i.)@])^:_&2 '03'
103
   >:@]^:(>./@(E.":)*:]=*/@(+.i.)@])^:_&2 '713'
2713

Для потомков, вот версия, использующая встроенный прайм (длиной 30 символов, но без бонуса):

>:@]^:(>./@(E.":)*:1 p:])^:_&2

1 p:] проверяет счетчик на простоту вместо трюка GCD.

Brachylog (v2), 3 байта в кодировке Brachylog

ṗ≜s

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

Передача функции, принимая входные данные из правого аргумента, выводя их путем изменения левого аргумента. (Это противоположно обычному соглашению Brachylog; см. Этот мета-пост для дальнейшего обсуждения. Замена аргументов в более обычный порядок будет стоить три байта.) Ссылка TIO имеет оболочку, которая вызывает функцию с соответствующим соглашением о вызовах и печатает результат.

объяснение

ṗ≜s
 ≜   Find the integer closest to zero
ṗ      which is prime {implicit: and output it via the left argument}
  s    and which is a substring of the {right argument}

К сожалению, Brachylog настолько подходит для этой задачи, что в соответствии с правилами в этой задаче я даже не могу попытаться получить бонус (что по иронии судьбы означает, что он не способен выиграть).

Одна из причин, по которой мне так нравится Brachylog, заключается в том, что программирование - это связь между человеком и компьютером, и, таким образом, «идеальный» язык позволил бы вам просто перевести спецификацию проблемы на английский напрямую; идеи, с помощью которых была сформулирована проблема, и посредством которых написана программа, были бы одинаковыми. Брахилог может удивлять этот идеал на удивление часто; вопрос здесь заключается в том, чтобы «найти наименьшее простое число, содержащее данную подстроку», и я могу буквально связать воедино понятия «наименьшая простое число, содержащее подстроку» в правильном порядке и получить работающую программу. Таким образом, Brachylog говорит гораздо больше о природе общения, чем язык, на котором вы должны были явно указать алгоритм для решения проблемы; иногда при общении с другими людьми, мы пытаемся объяснить проблему, объясняя шаги, которые вы предпримете для ее решения, но это редко. Так почему же наши языки должны отличаться?

JavaScript 83 байта = 33 балла

Golfed:

for(s=prompt(n=x=0);!n;x++)for(n=(''+x).match(s)?2:0;n&&n<x;n=x%n?n+1:0);alert(x-1)

Неуверенный (немного):

s=prompt() // get the input
n = 0
for(x=0;!n;x++) // stop when n is non-zero
    if ((''+x).match(s)) { // if x matches the pattern, check if x is prime
        for(n=2;n&&n<x;)
            n = (x%n == 0) ? 0 : n+1; // if x%n is zero, x is not prime so set n=0
        // if n is non-zero here, x is prime and matches the pattern
    }
alert(x-1)

Javascript (Node.JS) - 93 байта = 43 балла

l:for(i=x=process.argv[2];j=i;i++){while(--j>2)if(!(i%j*(""+i).match(x)))continue l
throw i}

В извлеченном виде с разумными именами переменных:

outerLoop:for (currentTry=inputNumber=process.argv[2]; primeIterator=currentTry; currentTry++ ) {
    while (--primeIterator > 2) 
        if(!(currentTry % primeIterator * (""+currentTry).match(inputNumber)))
            continue outerLoop;
    throw i
}

Ржавчина 0,9 136 байт = 86 баллов

fn main(){
   let mut n:u32=2;
   while n.to_str().find_str(std::os::args()[1])==None ||
         range(2,n).find(|&x|n%x==0)!=None {
      n=n+1;
   }
   print!("{}",n);
}

Очень явный, несмотря на компактность. Слишком много места потрачено на поиск строки. :(

Вот версия без пробелов (136 символов)

fn main(){let mut n:u32=2;while n.to_str().find_str(std::os::args()[1])==None||range(2,n).find(|&x|n%x==0)!=None{n=n+1;}print!("{}",n);}

Japt, 10 байт

_j *ZsøU}a

Попытайся

Приборка , 37 байт

{s:s&{s,p:s in"".p}from primes|first}

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

Perl 6 , 36 - 50 = -14 очков

{$^a;first {/$a/&&$_%%one ^$_},2..*}

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

Учитывая $_%%one ^$_, что только 2 байта меньше, чем .is-prime, я думаю, это стоит того, чтобы получить бонус. Это время ожидания для последнего контрольного примера.

Объяснение:

{                                  }  # Anonymous code block
 $^a;                                 # Assign input to $a
     first                    ,2..*   # Find the first number
           {                 }        # Which
            /$a/                        # Contains the input
                &&                      # And
                  $_%%one ^$_           # Is prime

Python 3 , 80 79 байтов - 50 = 30 29 баллов

-1 байт благодаря творческому использованию @ ASCII-only %sвместоstr

Контрольный пример "98765" еще не подтвержден из-за того, сколько времени уходит на тестирование. Подтверждено для контрольного примера "98765" через пару часов, но с аналогичным подходом, который использует оценку короткого замыкания, чтобы избежать проверки на простоту, он работает намного быстрее. В качестве альтернативы, это может быть примерно в 2 раза быстрее, если мы знаем, что «2» не является входом (мы можем избежать проверки четных чисел на простоту), устанавливая i=3изначально и i+=2в цикле, без дополнительных затрат в байтах.

def f(x):
 i=2
 while(x in"%s"%i)*all(i%j for j in range(2,i))-1:i+=1
 return i

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

Объяснение whileусловия ( (x in"%s"%i)*all(i%j for j in range(2,i))-1):

(x in"%s"%i): True/ 1если текущий счетчик содержит желаемую последовательность чисел в нем; False/ 0иначе.

all(i%j for j in range(2,i)): True/ 1если текущий счетчик всегда имеет остаток при делении на любое целое число от 2 (включительно) до себя (исключая), т.е. является простым; False/0 иначе.

В *умножает два условия вместе, и выступает в качестве andоператора - продукт True/ 1тогда и только тогда , когда оба условия True/ 1.

-1Выступает в качестве notоператора: False/ 0- 1 приводит к -1, который считается истинным, тогда как True/ 1- 1 приводит к 0, который считается ложным. Таким образом, цикл продолжается, пока число либо не содержит желаемой последовательности чисел, либо не является простым.

Замените *с andи добавьте круглые скобки вокруг всего, но -1для гораздо более быстрого, эквивалентного решения (которое немного длиннее).

76 байт - 50 = 26 баллов раствор в Python 2 дается @ ASCII - только (использует ``вместо того str(),

def f(x):
 i=2
 while(x in`i`)*all(i%j for j in range(2,i))-1:i+=1
 return i

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

JavaScript, 65 - 50 = 15 баллов

x=>(f=y=>(''+y).match(x)&&(p=n=>--n<2||y%n&&p(n))(y)?y:f(y+1))(x)

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