소수 격차 계산


19

소수를 찾는 것은 프로그래밍의 전례이며, 종종 누군가가 처음 시도하는 심각한 프로그램입니다 (보통 시험 분할).

그러나 소수는 이미 마모되었습니다. 다음으로 더 흥미로운 것은 소수의 격차를 얻는 것입니다 : 연속적인 소수 사이의 가장 긴 간격. 이들은 매우 희귀하고 "귀중한"것입니다. 처음 몇 쌍과 그 차이점은 다음과 같습니다.

2 3 1
3 5 2
7 11 4
23 29 6
89 97 8
113 127 14
...

아버지는 10K까지의 재미를 위해 이것을 손으로 계산했습니다. 코드가 얼마나 짧은 지 보자.

규칙 :

  • 프라임 테스트, 프라임 생성 또는 프라임 갭을위한 내장 함수 없음
  • http://oeis.org/A002386 또는 이와 유사한 정보를 검색하지 않음 (원격에서 사기꾼 냄새를 맡을 수 있습니다 :))
  • 사전 계산 된 배열이 없음
  • 내부 정수 유형이 실패 할 때까지 계속 인쇄

캐릭터 수가 가장 적습니다. 소수없이 공백 만 인쇄하는 경우 +10 자

내장 함수가있는 버전을 흥미로울 수도 있습니다. 창의력을 발휘하십시오.

설명 : 소수를 살펴보고 이전에 본 격차보다 큰 격차를 볼 때마다보고합니다. 예를 들어, 3에서 5 사이의 너비는 2 단위입니다. 5와 7 사이의 격차도 2이지만 오래된 뉴스입니다. 더 이상 걱정하지 않습니다. 새로운 가장 큰 차이가있을 때만보고합니다. 이것은 격차가 넓어지고 넓어짐에 따라 소수가 점점 줄어들고 있음을 반영합니다.


편집 : 대부분의 답변은 훌륭하고 더 많은 인정을받을 가치가 있습니다. 그러나 지금까지 48 자로 된 GolfScript 항목이 가장 짧습니다.


1
귀하의 예에서 3은 한 쌍의 끝이며 다음 쌍의 시작이지만 다른 숫자의 경우는 아닙니다. 무엇을 원하세요?
mmumboss

신경 쓰지 마, 지금 알았어
mmumboss

규칙을 "프라임 테스트, 프라임 계산 또는 프라임 간격을위한 내장 함수 없음"으로 다시 작성할 수 있습니다. 그렇지 않으면 명백한 해결책은 n 번째 소수 를 반환 한 다음 n 을 증가 시키고 함수를 다시 실행하고 차이를 찾는 함수를 사용합니다.
user12205

2
앗 나는 OEIS를 좋아한다
TheDoctor

나는 @mmumboss와 같은 의심을 가지고 있습니다. xplain 좀 주시겠습니까?
Clyde Lobo 2016 년

답변:


3

GolfScript 66 59 57 49 48

[2.0{:d{;\;.{).{(1$1$%}do(}do.2$-.d>!}do].p~.}do

여기에서 http://golfscript.apphb.com/을 실행하는 데 문제가 있지만 (사이트는 무한 루프를 좋아하지 않습니까?) golfscript.rb를 사용하여 컴퓨터에서 실행할 때 제대로 작동합니다. 저는 GolfScript를 처음 사용하므로 골프를 더 많이 할 수 있습니다. 업데이트 : 알고리즘을 변경하지 않고도 이것이 훨씬 더 많이 줄어들 수 있다고 생각하지 않습니다.

처음 몇 줄이 인쇄됩니다 ( ""인쇄가 마음에 들지 않으면 스크립트의 시작 부분에 추가 할 수 있지만 최대 49 자까지 가능합니다) :

[2 3 1]
["" 3 5 2]
["" 7 11 4]
["" 23 29 6]
["" 89 97 8]
["" 113 127 14]
["" 523 541 18]
["" 887 907 20]
["" 1129 1151 22]
...

이것이 어떻게 작동하는지에 대한 일반적인 사람이 읽을 수있는 아이디어 (이 버전에서는 스택을 사용하지 않기 때문에 약간 다릅니다) :

cur_prime = 2
next_prime = 2
gap = 0        

do {
    do {
        cur_prime = next_prime
        do {
            next_prime = next_prime + 1
            possible_factor = next_prime
            do {
                possible_factor = possible_factor - 1
            } while (next_prime % possible_factor > 0)
        } while (possible_factor != 1)
    } while (next_prime - cur_prime <= gap)

    gap = next_prime - cur_prime
    print [cur_prime next_prime gap]
} while (true)

11

파이썬 121 개 110 109 108 104 103 문자

p,n,m=[2],3,0
while 1:
 if all(n%x for x in p):
  c=n-p[0]
  if m<c:m=c;print(p[0],n,c)
  p=[n]+p
 n+=1

처음 여기에 대답하려고했을 때, 나는 그것을 올바르게했으면 좋겠다.

흠, 파이썬 2.x로 다운 그레이드하여 인쇄물에 다른 문자를 저장할 수 있습니다 ...


121 문자, 제목으로 제목을 만드십시오. #진지하게 문자를 세지 않습니까? javascriptkit.com/script/script2/charcount.shtml
user80551

아니요, 손으로 세지 않았습니다 :) 그러나 공백을 줄이는 방식으로 한 줄로 평평 해지는 몇 가지 질문에 대한 다른 Python 답변을 보았으며 솔직히 줄 바꿈이 1 또는 2 문자로 계산되는지 확실하지 않습니다. ...
Tal

1
질문 규칙에 명시 적으로 달리 명시되어 있지 않은 한 개행 문자를 1 자로 계산합니다. PPCG에 오신 것을 환영합니다!
Jonathan Van Matre

3
어서 오십시오! 좋은 대답이며 개선의 여지가 있습니다. 예를 들어 if all(n%x>0for x in p):조금 짧습니다. 문장을 같은 줄 (예 :)로 이동하여 일부 문자를 저장할 수도 있습니다 a=1;b=2;f().
grc

1
최근의 변화는 언급 된 것처럼 [n]을 앞으로 밀지 않음으로써 코드를 깨뜨 렸습니다.
오리온

4

자바 스크립트, 90 85 78 74 자

짧은 코드 (Google Closure Compiler-고급 최적화, 일부 수동 편집, @ MT0 추가 편집 )

for(a=b=2,c=0;b++;)for(d=b;b%--d;)d<3&&(c<b-a&&console.log(a,b,c=b-a),a=b)

긴 코드

var lastPrime = 2,
    curNumber = lastPrime,
    maxDistance = 0,
    i;

// check all numbers
while( curNumber++ ) {

  // check for primes
  i = curNumber;
  while( curNumber % --i != 0 ) {}

  // if prime, then i should be equal to one here
  if( i == 1 ) {

    // calc distance
    i=curNumber-lastPrime;

    // new hit
    if( maxDistance < i ) {
      maxDistance = i;
      console.log( lastPrime, curNumber, maxDistance );
    }

    // remember prime
    lastPrime = curNumber;
  }
}

산출

2 3 1
3 5 2
7 11 4
23 29 6
89 97 8
113 127 14
523 541 18
887 907 20
1129 1151 22
1327 1361 34
9551 9587 36
15683 15727 44
19609 19661 52
31397 31469 72
...

소수에 대해서는 매우 비효율적 인 테스트이지만 더 적은 문자를 사용합니다.

여기에 첫 번째 게시물이므로 실수를 용서하십시오.


78 자 –for(a=b=2,c=0;b++;){for(d=b;b%--d;);1==d&&(c<b-a&&console.log(a,b,c=b-a),a=b)}
MT0

@ MT0 감사합니다. 그것들을 발견하지 못했습니다. 편집했습니다.
Sirko

훨씬 더 비효율적이지만 74 자for(a=b=2,c=0;b++;)for(d=b;b%--d;)d<3&&(c<b-a&&console.log(a,b,c=b-a),a=b)
MT0

3

매스 매 티카, 114 108

시퀀스의 특정 지점이 지나면 팬이 회전하고 CPU가 프리셀을 재생하는 동안 바쁘게 보이도록 최선을 다하고 있음을 의심하기 시작하지만 무한 출력을 허용합니다.

p@x_:=NestWhile[#+1&,x+1,Divisors@#≠{1,#}&];m=0;q=1;While[1<2,If[p@q-q>m,Print@{q,p@q,p@q-q};m=p@q-q];q=p@q]

출력 샘플 (이것은 처음 ~ 30 초에 픽업 된 샘플입니다) :

{1,2,1}
{3,5,2}
{7,11,4}
{23,29,6}
{89,97,8}
{113,127,14}
{523,541,18}
{887,907,20}
{1129,1151,22}
{1327,1361,34}
{9551,9587,36}
{15683,15727,44}
{19609,19661,52}
{31397,31469,72}
{155921,156007,86}
{360653,360749,96}
{370261,370373,112}
{492113,492227,114}
{1349533,1349651,118}
{1357201,1357333,132}
{2010733,2010881,148}

Ungolfed 코드 :

p@x_ := NestWhile[
   # + 1 &,
   x + 1,
   Divisors@# ≠ {1, #} &];
m = 0;
q = 1;
While[
 1 < 2,
 If[
  p@q - q > m,
  Print@{q, p@q, p@q - q}; m = p@q - q];
 q = p@q]

인식 합니까?
Riking

그렇습니다. 그런 식으로 내보내지는 않지만 노트북에 코드를 붙여 넣을 때 잘 파싱됩니다. 이미 그에 따라 점수를 매겼지만 단순화하기 위해 수정하겠습니다.
Jonathan Van Matre

당신이 경우 얼마나 많은 문자를 어떻게 사용 티카 내장 총리의 기능?
Michael Stern

76. 전체 p @ x_ 정의는 NextPrime을 다시 구현 한 것이므로 p = NextPrime으로 대체 할 수 있습니다.
Jonathan Van Matre

3

하스켈 - 122 116 114 112 110

q=[n|n<-[3..],all((>0).rem n)[2..n-1]]
d m((p,q):b)|q-p>m=print(p,q,q-p)>>d(q-p)b|q>p=d m b
main=d 0$zip(2:q)q

Will Ness 에서 도난당한 (비효율적 인) 프라임리스트 표현 .

-편집-나는 x|y=z|w=q유효한지 몰랐다 .


2

MATLAB 104 89

가능한 모든 부서를 확인하여 기본 방법을 구현했습니다.

a=2;g=0;for n=3:inf;b=n*(sum(mod(n,1:n)<1)<3);h=b-a;if(h>g)g=h;[a,b,h]
end;a=max(a,b);end

산출:

  2     3     1
  3     5     2
  7    11     4
 23    29     6
 89    97     8
113   127    14
523   541    18
887   907    20

나는에있어 octaveinf점은하지 않습니다 작업 (인쇄가 루프 종료 될 때까지 지연됩니다). matlab에 게으른 범위 평가가 있습니까?
오리온

Matlab은 루프를 반복 할 때마다 실시간으로 인쇄합니다. 프로그램을 시작하면 최대 색인이 2147483647이라는 경고가 표시되고 시작됩니다. 또는 inf를 intmax로 바꿀 수는 있지만 세 문자 이상입니다.
mmumboss

2

렐랑 76 자

파이썬 버전 에서 변환 :

g=0
i=l=2
while i+=1=>all$map(i%)(2..i)=>(i-l>g=>(g=i-l),print(l,i,g)),(l=i)

산출:

(2, 3, 1)
(3, 5, 2)
(7, 11, 4)
(23, 29, 6)
(89, 97, 8)
(113, 127, 14)
(523, 541, 18)
(887, 907, 20)
(1129, 1151, 22)
...

승자로 선정되어야합니다!
Sarge Borsch

2

골프 스크립트, 59 51 50 자

각 캐릭터는 잃기 매우 어렵습니다.

0[2.{).,2>{\.@%!},{.2$-.4$>{].p~\[}{;\;}if..}or}do

출력 :

[2 3 1]
[3 5 2]
[7 11 4]
[23 29 6]
[89 97 8]
[113 127 14]
...

설명 :

스택은 각 반복이 이와 같은 스택으로 시작하도록 설정되며 상단은 오른쪽입니다. 은 [통역자가 발생할 때 즉, 현재의 배열을 나타내는 마커 ]배열에 넣고 가기 마크로부터 스택에 다.

g [ last | cur

g지금까지 최대 간격입니다. 위에서 아래로 :

 command         | explanation
-----------------+----------------------------------------
 0[2.            | initialize vars g=0, last=2, cur=2
 {...}do         | loop forever...

루프 내부 :

 )               | cur += 1
 .,2>{\.@%!},    | put all divisors of cur into a list
 {...}or         | if the list is empty, cur is prime, so
                 | the block is executed. otherwise,
                 | 'do' consumes the stack, sees it is truthy,
                 | and loops again

모든 제수를 목록에 어떻게 넣습니까? 단계별로 해보자

 Command         | explanation                                  | stack
-----------------+----------------------------------------------+----------------
                 | initial stack                                | n
 .,              | make list of 0..n-1                          | n [0,1,...,n-1]
 2>              | take elements at index 2 and greater         | n [2,3,...,n-1]
 {...},          | take list off stack, then iterate through    |
                 | the list. on each iteration, put the current |
                 | element on the stack, execute the block, and |
                 | pop the top of the stack. if the top is      |
                 | true then keep the element, else drop it.    |
                 | when done, push list of all true elements    |
                 | So, for each element...                      | n x
   \.            |   Swap & dup                                 | x n n 
   @             |   Bring x around                             | n n x
   %             |   Modulo                                     | n (n%x)
   !             |   Boolean not. 0->1, else->0. Thus this is 1 |
                 |   if x divides n.                            | n (x divides n)
                 | So only the divisors of n are kept           | n [divisors of n]

제수가 비어 있으면 어떻게합니까?

 Command         | explanation                                  | stack
-----------------+----------------------------------------------+----------------
                 | initial stack                                | g [ last | cur
  .              | dup                                          | g [ l | c | c
  2$             | copy 3rd down                                | g [ l | c | c | l
  -              | sub. This is the current gap, cur-last       | g [ l | c | c-l
  .              | dup                                          | g [ l | c | c-l | c-l
  4$             | copy 4th down                                | g [ l | c | c-l | c-l | g
  >              | is cur gap > max gap so far?                 | g [ l | c | c-l | c-l>g
  {#1}{#2}if..   | #1 if c-l > g, #2 otherwise, and do ".." in  | ... | g [ c | c | c
                 | either situation                             | 

두 가지 경로 : 예와 아니오. 예인 경우 ( if스택에서 최상위 값 을 소비 함)

 Command         | explanation                                  | stack
-----------------+----------------------------------------------+----------------
                 | initial stack. note that now the old `g` is  | XX [ l | c | g
                 | garbage and `c-l` is the new `g`.            |
 ]               | close the array                              | XX [l, c, g]
 .p              | duplicate it and print it, consuming the dup | XX [l, c, g]
 ~               | pump array back onto the stack. Note now the | XX | l | c | j
                 | array marker [ is gone.                      | 
 \               | swap.                                        | XX | l | g | c                         
 [               | mark the array                               | XX | l | g | c [
 .               | this is the part after the if. dups the top, | XX | l | g [ c | c
                 | but it does this in two steps, first popping | 
                 | c then putting two copies on top, so the     | 
                 | array marker moves                           | 
 .               | dup again                                    | XX | l | g [ c | c | c

그렇지 않은 경우 :

 Command         | explanation                                  | stack
-----------------+----------------------------------------------+----------------
                 | initial stack. In this case g is still the   | g [ l | c | c-l
                 | max gap so far                               | 
 ;\;             | dump top of stack, swap, and dump again      | g [ c
 ..              | the part after the if. dup twice             | g [ c | c | c

두 경우 모두 스택은 이제 형식 ... | g [ c | c | c입니다.

이제는 do스택에서 최상위 값을 팝하고 항상 c양수이면 루프합니다. c항상 증가 하기 때문에 이것은 항상 사실이므로 영원히 반복됩니다.

팝되면, 스택의 상단이되고 g [ c | c, 마지막으로 업데이트되었습니다하는 의미 c, 배열 마크는 같은 장소에서, 그리고 g우리가 그것을 기대하는 곳 아직도있다.

이것들은 복잡한 GolfScript 작업입니다. 나는 당신이 함께 따라 즐기기를 바랍니다!


1
탁월한 해명!
Jonathan Van Matre

1

루비, 110

다음 lazy방법 으로 인해 Ruby 2.0에만 해당됩니다 .

(2..1.0/0).lazy.select{|n|!(2...n).any?{|m|n%m==0}}.reduce([2,0]){|(l,t),c|d=c-l;p [l,c,d]if d>t;[c,d>t ?d:t]}

산출:

[2, 3, 1]
[3, 5, 2]
[7, 11, 4]
[23, 29, 6]
[89, 97, 8]
[113, 127, 14]
[523, 541, 18]
[887, 907, 20]
[1129, 1151, 22]
[1327, 1361, 34]
[9551, 9587, 36]
[15683, 15727, 44]
[19609, 19661, 52]
[31397, 31469, 72]
[155921, 156007, 86]
[360653, 360749, 96]
[370261, 370373, 112]
[492113, 492227, 114]
...

1

펄, 105 바이트

$p=2;$d=0;L:for($i=2;++$i>2;){!($i%$_)&&next L for 2..$i-1;if($i-$p>$d){$d=$i-$p;print"$p $i $d\n"}$p=$i}

언 골프 드 :

$p = 2;
$d = 0;
L: for ($i = 2; ++$i > 2; ){
    !($i % $_) && next L for 2..$i-1;
    if ($i - $p > $d) {
        $d = $i - $p;
        print "$p $i $d\n"
    }
    $p = $i
}  

알고리즘은 간단 $p하며 이전 소수를 기억합니다. 그런 다음 $ i 유형이 "나에게 실패"하거나 오버플로로 인해 음수가되면 위로 올라 $i갑니다 3. $i모든 제수를 2에서$i-1 . 현재 차이가 이전 인쇄 차이보다 큰 경우 선이 인쇄됩니다 $d.

더 많은 바이트를 사용하면 런타임을 향상시킬 수 있습니다.

$p = 2;
$d = 0;
L: for ($i=3; $i > 2; $i += 2){
    for ($j=3; $j <= sqrt($i); $j += 2){
        next L if !($i%$j)
    }
    if ($i - $p > $d) {
        $d = $i - $p;
        print "$p $i $d\n"
    }
    $p = $i
}

결과 로 시작

2 3 1
3 5 2
7 11 4
23 29 6
89 97 8
113 127 14
523 541 18
887 907 20
1129 1151 22
1327 1361 34
9551 9587 36
15683 15727 44
19609 19661 52
31397 31469 72
155921 156007 86
360653 360749 96
370261 370373 112
492113 492227 114
1349533 1349651 118
1357201 1357333 132
2010733 2010881 148
4652353 4652507 154
17051707 17051887 180
20831323 20831533 210
47326693 47326913 220
...

1
맞지 않습니다. 일련의 증가하는 격차를 찾아야합니다. 예상되는 출력에 대해서는 Ruby 또는 Matlab 답변을 참조하십시오.
mmumboss

1
@ mmumboss : 아, 나는 이것을 간과했습니다. 지금 수정했습니다.
Heiko Oberdiek 2014 년

모든 변수에 최소 2자가 필요한 언어에 적합합니다.
오리온

1

파이썬, 93 91 문자

순진한 프라임 검사 (2에서 n(로 미만의 문자 n/2) 로 나눌 수 있는지 확인 ) :

g=0;i=l=2
while 1:
 i+=1
 if all(i%x for x in range(2,i)):
    if i-l>g:g=i-l;print l,i,g
    l=i

들여 쓰기의 두 번째 수준은 하나의 탭 문자입니다.

산출:

2 3 1
5 7 2
7 11 4
23 29 6
89 97 8
113 127 14
523 541 18
...

니스, 나는 최대 n점검까지 그 범위를 잊었다n-1
Claudiu

1

프라임 정규식에 대한 Bash 및 일부 Perl ( 167157143112112 바이트)

n=2
c=2
while p=$c
do perl -e\(1x$[++n]')=~/^(11+?)\1+$/&&exit 1'&&c=$n
((c-p>g))&&g=$[c-p]&&echo $p $c $g
done

일부 출력 :

$./golfd.sh
2 3 1
3 5 2
7 11 4
23 29 6
89 97 8
113 127 14
523 541 18
887 907 20
1129 1151 22

정규식의 NP 역 추적을 사용하여 루프와 제어 구조를 완전히 우회하는 것은 완벽한 완벽입니다. 그러나 test시위는 상당히 많으며 나에게는 효과가 없습니다. 당신은 또한 몇 가지를 사용할 수 있습니다 let n++let f=c-p및 교체 test와 함께 [. 또는 (())필요하지 않은 곳 $이나 공백 이 있는지 테스트 하십시오.
오리온

test -n $d빈 문자열에 대해 true를 반환했습니다. test -n "$d"괜찮 았지만 더 길었습니다. 그러나 매뉴얼 페이지에 -n은 선택 사항이며 문제가 없음 test $d을 나타냅니다 . 따라서 [ $d ]도 마찬가지입니다. 그리고 g = 0을 초기화해야했습니다.
오리온

@ orion, 죄송합니다 어떤 이유로 그것은 지금 한 번 작동 내 컴퓨터에서 고장난 것 같아요, 나는 그것을 167으로 되돌 렸습니다. 나는 당신의 다른 제안을 추가하려고 노력할 것입니다
Newbrict

환경에 사전 정의 된 변수가있을 수 있습니다.
오리온

@orion 어떤 이유로 편집이 거부 되었습니까? 다시 편집 할 수 있습니까?
Newbrict

1

95 90 바이트

for($n=$c=2;$p=$c;$c-$p>$g&&printf"$p $c %d\n",$g=$c-$p){$c=$n if(1x++$n)!~/^(11+?)\1+$/}

오래된 비 골프 버전 :

$n=$c=2;
while($p=$c){
    $c=$n if (1x++$n)!~/^(11+?)\1+$/;
    if ($c-$p>$g) {$g=$c-$p;print "$p $c $g\n"}
}

이것은 다른 제출물 인 sans bash와 비슷합니다.


나는 성 가시지 않다. 나는 이것이 얼마나 멀리 갈 수 있는지 알고 싶다. 여기서 :for($n=$c=2;$p=$c;$c-$p>$g&&printf"$p $c %d\n",$g=$c-$p){$c=$n if(1x++$n)!~/^(11+?)\1+$/}
오리온

루프 악용에 심각한 @orion 하하!
Newbrict

1

C (100)

내 자신의 공헌, 특별한 알고리즘, 골프 :

i,g,r,p=2;main(){for(;r=p;p-r>g?printf("%d %d %d\n",r,p,g=p-r):0)for(i=0;i-p;)for(i=1,++p;p%++i;);}

"소수없이 공백 만 인쇄하면 +10 자입니다." - 당신의 인쇄를 제거하는 경우 rp더 적은 문자를해야합니다 :) 보너스 점수
CompuChip

완성도 예쁘다 :)
오리온

1

하스켈, 134C

골프 :

c n=null[x|x<-[2..n-1],n`mod`x==0]&&n>1
p=filter c[1..]
g l(m:n:o)
 |(n-m)>l=do print(m,n,n-m);g(n-m)(n:o)
 |True=g l(n:o)
main=g 0 p

언 골프 드 :

-- c function checks if n is a prime number
c n=null[x|x<-[2..n-1],n`mod`x==0]&&n>1

-- p is an infinite list of primes
p=filter c[1..]

-- g function prints a list of primes and differences.
--   l is the maximum difference seen so far
--   (m:n:o) is the list of unprocessed primes
g l(m:n:o)
 |(n-m)>l=do print(m,n,n-m);g(n-m)(n:o)
 |True=g l(n:o)

-- main starts the ball rolling with a default max-seen value of 0
main=g 0 p

그 게으른 평가를 사랑하십시오!
Jonathan Van Matre

1

C : 493 302 272 246

int e(int j){for(int i=2;i<j;i++)if(j%i<1)return 0;return 1;}void f(int a,int b,int c){if(e(a)&e(b))if(c<b-a){printf("%d %d %d\n",a,b,b-a);f(a+1,b+1,b-a);}else f(a+1,b+1,c);if(e(b))f(a+1,b,c);if(e(a))f(a,b+1,c);f(a+1,b+1,c);}int main(){f(2,3,0);}

나는하지의 일반적인 루프를 재귀를 사용 for하거나 while.

int isPrime(int num){
    for( int i=2; i<num; i++ )
        if(num%i < 0) return 0;
    return 1;
}
void fun(int n1, int n2, int gap){
   if( isPrime(n1) & isPrime(n2) ){
        if( gap < n2-n1 ){
           printf("%d %d %d\n", n1, n2, n2-n1);
           fun(n1+1, n2+1, n2-n1);
        }else{
           fun(n1+1, n2+1, gap);
        }
   }
   if( isPrime(n2) ){
       fun(n1+1, n2, gap);
   }
   if( isPrime(n1) ){
       fun(n1, n2+1, gap);
   }
   fun(n1+1, n2+1, gap);
}

int main(){
   fun(2,3,0);
}

산출:

2 3 1
3 5 2
7 11 4
23 29 6
89 97 8
113 127 14
523 541 18
887 907 20
1129 1151 22
1327 1361 34
9551 9587 36
15683 15727 44
19609 19661 52

작동하지 않습니다. true / false는 정의되어 있지 않지만이를 수정하더라도 잘못된 차이를보고합니다. 예를 들어, 25219와 43237 사이에 많은 소수가 leaking있습니다. isPrime (n2)을 테스트하지 않기 때문에 재귀가 맨 위에 있습니다. n1과 n2 사이에 소수를 허용합니다. 그리고 소수를 충족시키지 않고 n2를 증가시킬 수 없기 때문에 이것은 실제로 고칠 수 없습니다.
오리온

당신이 맞아요! 그건 틀렸어! 내 생각은 처음부터 틀렸다.
Loukas

1
이제 더 낫습니다 .. :)
Loukas

+1 이제 수정되었습니다. 마음에 들지 않습니다 (비효율적이지만). 당신은 그것을 많이 골프 수 있습니다. return메인으로 건너 뜁니다 . 마지막을 건너 뜁니다 else. 교체 &&-> &num%i==0함께 num%i<1. 그리고 고대 c 표준 (경고가있을 것입니다)에 따르면 void 및 int 함수에 대한 반환 값을 지정할 필요가 없습니다 (인수의 기본값은 int입니다).
오리온

나는 한 번의 무조건 재귀 호출, 단 하나의 유형 지정자 ( int) 및 크게 줄어든 주요 테스트 기능을 사용 하여 조금 연주하고 151 자로 줄었습니다. e(j,i){while(j%++i);return i==j;}f(a,b,c){int A=e(a,1),B=e(b,1);if(A&B&&c<b-a)printf("%d %d %d\n",a,b,c=b-a);f(a+(B|!A),b+(A|!B),c);}main(){f(2,3,0);}
orion

1

오라클 SQL, 216 (202) 196 172 + 10 = 182

질문에서 이것을 발견했습니다.

캐릭터 수가 가장 적습니다. 소수없이 공백 만 인쇄하는 경우 +10 자

이것이 SQL이고 키워드가 너무 길기 때문에 실제로 다음과 같이 패널티를 취하는 것이 좋습니다. 원본과 같은 생각입니다.

with c as(select level+1n from dual connect by level<1e124)select lead(n)over(order by n) from(select*from c a where not exists(select*from c where n<a.n and mod(a.n,n)=0))

다음과 같이

with c as ( 
 select level + 1 n 
   from dual 
connect by level < 1e124
        )
select lead(n) over ( order by n ) 
  from ( select *
           from c a 
          where not exists( select * 
                              from c 
                             where n < a.n 
                               and mod(a.n, n) = 0
                                   )
                )

옛 대답 (196)

with c as(select level+1n from dual connect by level<1e124)select n,p,p-n from(select n,lead(n)over(order by n)p from(select*from c a where not exists(select*from c where n<a.n and mod(a.n,n)=0)))

그리고 읽을 수있는 형식으로 :

with c as ( 
 select level + 1 n 
   from dual 
connect by level < 1e124
        )
select n, p, p-n 
  from ( select n, lead(n) over ( order by n ) p 
           from ( select * 
                    from c a 
                   where not exists (
                                select * 
                                  from c
                                 where n < a.n 
                                   and mod(a.n, n) = 0
                                       )
                         )
                )

이것은 숫자 생성기를 만듭니다 c 내부 , 가장 안쪽의 하위 선택은 에라토스테네스의 체 (Sieve of Eratosthenes)를 사용하여 소수를 생성하고, 외부는 이전 소수를 계산하고 마지막으로 마지막 선택을 서로 빼냅니다.

1 x 10 124 재귀 쿼리를 수행하기 때문에 아무것도 반환하지 않습니다 . 따라서이 숫자를 합리적인 것으로 낮추려면 작동합니다.


이와 같은 도전에 관해서는 SQL이 Turing-complete가 아니라 Turing-obstinate라고 생각합니다.
Jonathan Van Matre

그러나 됩니다 돌리면 완성 @ 조나단을, 때로는 :-) "재미"가 그것을 받고 있지만?
Ben

그것이 Turing-complete 인 것을 알고, 나는 농담하는 것을 목표로하고 있었다. 분명히 마크를 놓쳤다. :) 어쨌든 내 프로필에는 여러 가지 T-SQL 답변이 있습니다 ... 오라클을 가져와 결투를하십시오!
Jonathan Van Matre

0

D-153 + 10 = 163

나는 여기에 +10의 페널티를 기꺼이 받는다. 왜냐하면 소수는 내가 소수를 인쇄했을 때보 다 여전히 적기 때문이다.

골프 :

import std.stdio;bool p(int l){int n;foreach(i;1..l+1)n+=l%i==0?1:0;return n==2;}void main(){int g;foreach(l;0..int.max)if(l.p){if(g>0)(l-g).write;g=l;}}

읽을 수있는 버전 :

import std.stdio;

bool prime( int number )
{
    int divisors;

    foreach( i; 1 .. number + 1 )
        divisors += number % i == 0 ? 1 : 0;

    return divisors == 2;
}

void main()
{
    int lastPrime;

    foreach( number; 0 .. int.max )
        if( number.prime )
        {
            if( lastPrime > 0 )
                ( number - lastPrime ).write;

            lastPrime = number;
        }
}

0

자바 174 문자

var p=[2],l=2,g=0;
for(var n=3;n>0;n+=2){
  var o=0;
  for(var t=0;t<p.length;++t){
    if(n/p[t] == parseInt(n/p[t])){
      o=1;
    }
  }
  if(o==0){
    p.push(n);
    if(n-l>g){
      g=n-l;
      console.log(l,n,g);
    }
    l=n;
  }
}

짧은 버전 :

var p=[2],l=2,g=0;for(var n=3;n>0;n+=2){var o=0;for(var t=0;t<p.length;++t){if(n/p[t] == parseInt(n/p[t])){o=1;}}if(o==0){p.push(n);if(n-l>g){g=n-l;console.log(l,n,g);}l=n;}}

0

자바 스크립트 138

for(var a=2,b=0,c=0;a++;){var d;a:{for(var e=a,f=2;f<e;f++)if(0==e%f){d=!1;break a}d=!0}d&&(0!=b&&a-b>c&&(c=a-b,console.log(b,a,c)),b=a)}

이 코드를 브라우저 콘솔에 복사하십시오. 최대 숫자가 주변에 있기 때문에 영원히 좋아할 것 1.79*10^308입니다.

언 골프 드 :

var number = 2;
var lastPrime = 0;
var gap = 0;

while(number++)
{
    if (isPrime(number)) {
        if (lastPrime != 0) {            
            if (number - lastPrime > gap)
            {
                gap = number - lastPrime;
                console.log(lastPrime, number, gap);
            }
        }

        lastPrime = number;
    }
}

function isPrime(n){
    for (var i = 2; i < n; i++) {
        if (n % i == 0)
            return false;
    }
    return true;
}

0

C 번호 162 161 문자

151 자 + 페널티 문자 10 = 161 자

짧은 버전 :

using System;class P{static void Main(){int p=2,g=0;for(int i=3;;i++){for(int j=2;j<i;j++)if(i%j==0)goto e;if(i-p>g)Console.WriteLine(g=i-p);p=i;e:;}}}

긴 버전 :

using System;

class PrimeGaps
{
    private static void Main()
    {
        int lastPrime = 2;
        int largestGap = 0;

        for (int i = 3; true; i++)
        {
            // Prime test
            for (int j = 2; j < i; j++)
                if (i%j == 0)
                    goto nextI; // Skip to next iteration of i

            // Largest gap check
            if (i - lastPrime > largestGap)
            {
                largestGap = i - lastPrime;
                Console.WriteLine(largestGap);
            }

            // Remember last prime
            lastPrime = i;

            nextI:
                ; // Do nothing
        }
    }
}

실제로는 10 문자 페널티를받는 것이 더 낫습니다. 왜냐하면 g페널티가 p+" "+i+" "+g없는 13 문자 보다 쓰기가 짧기 때문 입니다.


0

루비 90 86 84 83 자

r,i,g=2,2,0;while i+=1 do(2...i).all?{|j|i%j>0}&&((i-r<=g||p([r,i,g=i-r]))&&r=i)end

부울 단락, 표현 평가 남용 등


0

C 248

코드는 연속 소수 a, b를 비교 한 다음 간격이 g보다 큰지 확인한 후 다음 소수 쌍을 찾습니다.

#include <cstdio>
void f(int* a, int* b){*a =*b;int t=1;while (*b += 2){t=1;for(int i=3;i<*b;i+=2){if(*b%i==0){t=0; break;}}if(t)break;}}
int main(){int a=2,b=3,g=0;do{(b-a>g)?printf("%d %d %d\n",a,b,(g=b-a)): f(&a,&b);} while(b>=0);return 0;}

이것은 C ++입니다. 그렇지 않습니까?
Zacharý

0

하스켈 154 144 137 123

프라임 p은 에라 스토 텐의 체를 사용하여 생성 된 #후를 사용하여 여과하고 인쇄 %합니다.

p=2:3#1
n#m|all((>0).mod n)$take m p=n:(n+1)#(m+1)|1<2=(n+1)#m
(l:u@(o:_))%k|o-l>k=print(l,o,o-l)>>u%(o-l)|1<2=u%k
main=p%0

출력은 다음과 같습니다

(2,3,1)
(3,5,2)
(7,11,4)
(23,29,6)
(89,97,8)

내가 바라는 것은 괜찮습니다.


0

게임 메이커 언어, 85

초기화되지 않은 모든 변수를 다음과 같이 가정합니다 0(일부 버전의 Game Maker에서는 기본값 임).

a=2b=2for(d=2;b++;1)for(c<b-a;b mod --d;1)d<3&&(c=b-a&&show_message_ext("",a,b,c)a=b)

0

게임 메이커 언어, 74 + 55 = 129

초기화되지 않은 모든 변수를 다음과 같이 가정합니다 0(일부 버전의 Game Maker에서는 기본값 임).

n=2while(n++){if p(n){if l{if n-l>g{g=n-l;show_message_ext("",l,n,g)}}l=n}

스크립트 p는 다음과 같습니다.

r=1a=argument0for(i=2i<a;i++){if a mod i=0r=0}return r}

0

Perl, 87 바이트 ( 모듈 사용 )

use Math::Prime::Util":all";$l=2;forprimes{if($_-$l>$m){say"$l $_ ",$m=$_-$l}$l=$_}1e14

모듈을 작성했지만 탈리에 565,000자를 추가해야합니다. 대부분 재미를 위해 게시하지만 내장 기능을 사용하여 지금까지 볼 수 없으므로 성능 대안을 제공합니다. 1e9까지 갭은 4.6 초, 1e10까지 갭은 36 초, 1e11은 6.5 분.

Pari / GP 2.8은 기본적으로 동일한 방식으로 수행 할 수 있지만 2 배 이상 느립니다.

l=2;m=0;forprime(p=2,1e14,if(p-l>m,print(l," ",p," ",m=p-l));l=p)

-1

펄 153

짧은 코드:

$i=$a=2;while($a=$i++){if(p($i)){if($m<$m2=$i-$a){$m=$m2;print"$a $i $m$/"}}}sub p{$d=2;$s=sqrt$_[0];while(){return 0if!($_[0]%$d);return 1if$d>$s;$d++}}

읽기 쉬운:

$i=$a=2;
while($a=$i++){
  if(p($i)){
    if($m<$m2=$i-$a){
      $m=$m2;
      print"$a $i $m$/"
    }
  }
}
sub p {
  $d=2;
  $s=sqrt$_[0];
  while(){
    return 0if!($_[0]%$d);
    return 1if$d>$s;
    $d++;
  }
}

이것은 지금까지 가장 큰 것이 아니라 모든 격차를 산출합니다.
오리온
당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.