1946 년 Erdos와 Copeland는 특정 숫자 가 정상적인 숫자 임을 증명했습니다 . 즉, 십진 확장의 숫자는 균일하게 분포됩니다.

사용자는 일련의 숫자를 입력하고 10을 기준으로 해당 문자열을 포함하는 가장 작은 소수를 찾을 수 있습니다.

예:

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

바이트 단위의 최단 코드가 이깁니다. 일부 언어 (수학, 세이지, pari-gp ...)에는 소수와 관련된 내장 함수가 포함되어 있습니다. 프로그램이 이러한 기능에 의존하지 않는 경우 -50 바이트 귀하의 언어가 이미 큰 이점을 가지고 있다면 보너스를 주장하지 마십시오.

편집하다

아래의 몇 가지 의견에 따르면 "03"을 포함하는 가장 작은 소수는 3입니다. 실제로 차이가 있습니까? 내가 생각할 수있는 유일한 것은 아마도 숫자가 문자열보다 다루기가 더 쉽다는 것입니다.

"03"과 같은 경우 선호되는 출력은 103이됩니다. 그러나 출력을 프로그램의 기본 부분으로 간주하지 않으므로 바이트 수가 적은 경우 0을 무시해도됩니다.

골프 공, 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찾을 수없는 경우), 증가, 부정 의 텍스트 형식으로 입력을 찾습니다 .
• | -또는

하스켈 프로그램, 97 자 = 47 점

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

하스켈 함수, 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은 정수에 대해 예상되는 십진 표기법을 사용합니다.

그리 빠르지 않습니다. 출력 값 (크기가 아님)의 2 차.

ungolfed 버전 :

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++;}}}

매스 매 티카 58

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

내 Mac의 상대 타이밍 (8GB 메모리가있는 2.6GHz i7).

"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)제공 i0 번째 주요 2 인 상태 일 소수를.

R, 56 문자 -50 = 6

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

stdin으로 입력하십시오. k가 소수가 될 때까지 k를 증가시킵니다 (k mod 2에서 k가 0 인 인스턴스를 합산하여 테스트하므로 0이 논리로 바뀌 었으므로 FALSE는 FALSE 임). 우리는 결과적으로 논리를 원하기 때문에).

용법:

> 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

쉘 oneliner (coreutils) : 45chars

여기에 함수를 정의하지 않고 하나의 인수를 가져와 $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.11 초)

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입니다. 그렇지 않으면 1보다 큰 GCD가 하나 이상 있으므로 제품이 카운터보다 큽니다.
• >./@(E.":)-카운터 ( ":) 의 문자열 표현에 문자열 ( )이 포함되어 있는지 테스트하십시오 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), Brachylog 인코딩에서 3 바이트

ṗ≜s

온라인으로 사용해보십시오!

함수 인수, 오른쪽 인수에서 입력을 받아 왼쪽 인수를 변경하여 출력합니다. (이것은 일반적인 Brachylog 규칙과 반대입니다. 자세한 내용은 이 메타 게시물 을 참조하십시오 . 인수를보다 일반적인 순서로 바꾸는 데 3 바이트가 소요됩니다.) 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는이 이상을 놀라 울 정도로 자주 칠 수 있습니다. 여기서 질문은 "주어진 부분 문자열을 포함하는 가장 작은 소수"를 찾는 것입니다. 문자 그대로 "가장 작은 소수를 포함하는 가장 작은 소수"라는 개념을 올바른 순서로 묶을 수 있습니다. 따라서 Brachylog는 문제 해결을위한 알고리즘을 명시 적으로 지정해야하는 언어보다 의사 소통의 본질에 대해 훨씬 더 많은 것을 말합니다. 때로는 다른 사람들과 대화 할 때 문제를 해결하기 위해 취한 단계를 설명하여 문제를 설명하려고하지만 드물게 발생합니다. 그렇다면 왜 우리 언어가 달라야합니까?

자바 스크립트 83 바이트 = 33 점

골프 :

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)

자바 스크립트 (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);}

apt, 10 바이트

_j *ZsøU}a

시도 해봐

깔끔한 37 바이트

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

온라인으로 사용해보십시오!

펄 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

파이썬 3 , 80 79 바이트-50 = 30 29 점

ASCII 전용의 창조적 인 사용의 @ -1 바이트 감사 %s대신str

테스트 시간이 오래 걸리기 때문에 테스트 케이스 "98765"가 아직 확인되지 않았습니다 . 몇 시간 후에 테스트 케이스 "98765"에 대해 확인되었지만 단락 평가를 사용하여 일부 우선 순위 테스트를 피하는 유사한 방법으로 작동합니다. 훨씬 더 빨리. 또는 추가 바이트 비용없이 "2"가 입력이 아니라는 것을 알면 ( i=3초기의 짝수를 확인하는 것을 피할 수 있음) 초고속으로 2 배 빠를 수 있습니다 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/ 12 (포함)에서 자체 (제외)까지의 정수로 나눌 때 현재 카운터에 항상 나머지가있는 경우, 즉 소수입니다. False/ 0그렇지.

*승산 함께 두 조건과는 역할 and운영자 - 생성물 인 True/ 1만약 두 조건이있는 경우에만 True/ 1.

는 -1A와 작용 not연산자 False/ 0- 1 개 결과 -1사실로 간주되는 반면, True/ 1- 1 개 결과 0오류로 간주된다. 따라서 숫자는 원하는 숫자 시퀀스를 포함하지 않거나 소수가 아닌 동안 루프가 계속됩니다.

를 교체 *와 함께 and모든 것을 괄호를 추가하지만, -1훨씬 빠른을위한, 해당 솔루션 (즉 약간 이상).

@ASCII 전용으로 제공된 Python 2 의 76 바이트-50 = 26 점수 솔루션 ( ``대신에 활용 str(),

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

온라인으로 사용해보십시오!

자바 스크립트, 65-50 = 15 점

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

온라인으로 사용해보십시오!