คำนวณช่องว่างที่สำคัญ


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 เช่นกัน แต่นั่นเป็นข่าวเก่าเราไม่สนใจอีกต่อไป เฉพาะเมื่อคุณเห็นช่องว่างที่ใหญ่ที่สุดใหม่คุณรายงาน สิ่งนี้สะท้อนให้เห็นว่าจำนวนเฉพาะเริ่มน้อยลงหรือน้อยลงอย่างไรเมื่อช่องว่างกว้างขึ้นและกว้างขึ้น


แก้ไข : คำตอบส่วนใหญ่ยอดเยี่ยมและสมควรได้รับการยอมรับมากขึ้น อย่างไรก็ตามจนถึงตอนนี้รายการ GolfScript ที่มี 48 ตัวอักษรนั้นสั้นที่สุด


1
ในตัวอย่างที่ 3 ของคุณคือจุดสิ้นสุดของคู่และจุดเริ่มต้นของคู่ถัดไปในขณะที่นี่ไม่ใช่กรณีของตัวเลขอื่น ๆ คุณต้องการอะไร?
mmumboss

ไม่เป็นไรฉันเข้าใจแล้ว
mmumboss

คุณอาจต้องการเขียนกฎของคุณใหม่เป็น "ไม่มีฟังก์ชันในตัวสำหรับการทดสอบที่สำคัญการคำนวณที่สำคัญหรือช่องว่างที่สำคัญ" มิฉะนั้นทางออกที่ชัดเจนจะใช้ฟังก์ชั่นที่ส่งกลับค่านายกลำดับที่nจากนั้นเพิ่มค่าnเรียกใช้ฟังก์ชันอีกครั้งและค้นหาความแตกต่าง
user12205

2
Aww ฉันรัก OEIS
TheDoctor

ฉันมีข้อสงสัยเช่นเดียวกับ @mmumboss คุณช่วย xplain ได้ไหม
ไคลด์ Lobo

คำตอบ:


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 ดังนั้นสิ่งนี้อาจจะลงไปไกลกว่านี้ UPDATE: ฉันไม่คิดว่าสิ่งนี้จะสามารถเล่นกอล์ฟได้มากขึ้นโดยไม่ต้องเปลี่ยนอัลกอริทึมอย่างใด

พิมพ์สองสามบรรทัดแรก (หากคุณไม่ชอบการพิมพ์ "" คุณสามารถเพิ่มได้ที่จุดเริ่มต้นของสคริปต์ แต่จะเพิ่มได้ถึง 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

Python, 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

ครั้งแรกที่ฉันพยายามตอบที่นี่ฉันหวังว่าฉันจะทำถูกต้อง ... ไม่แน่ใจว่าฉันจะนับตัวละครที่ถูกต้อง

อืมฉันสามารถบันทึกตัวละครอื่นในการพิมพ์โดยการลดระดับเป็น Python 2.x ...


121 chars, ตั้งชื่อหัวเรื่องด้วย#, คุณไม่นับ chars ด้วยมือจริง ๆ ไหม? javascriptkit.com/script/script2/charcount.shtml
80551

ไม่ฉันไม่ได้นับด้วยมือ :) แต่ฉันเห็นคำตอบของ 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] ไปด้านหน้าเหมือนที่ระบุไว้
orion

4

JavaScript, 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

Mathematica, 114 108

ช่วยให้การส่งออกไม่มีที่สิ้นสุดแม้ว่าหลังจากจุดที่แน่นอนในลำดับแฟนหมุนขึ้นและคุณเริ่มสงสัยว่า CPU ของคุณกำลังเล่น Freecell ในขณะที่ทำมันให้ดีที่สุดเพื่อดูยุ่ง

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}

รหัสไม่ได้รับการตอบกลับ:

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

จำนวนตัวอักษรถ้าคุณทำใช้ Mathematica ของในตัวฟังก์ชั่นนายกรัฐมนตรี?
Michael Stern

76. เนื่องจากนิยาม p @ x_ ทั้งหมดเป็นเพียงการนำมาใช้ใหม่ของ NextPrime จึงสามารถแทนที่ด้วย p = NextPrime;
Jonathan Van Matre

3

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

ฉันใช้งานได้octaveและinfสิ่งนี้ไม่ทำงาน (และการพิมพ์จะถูกเลื่อนออกไปจนกว่าลูปจะสิ้นสุด) matlab มีการประเมินช่วงที่ขี้เกียจหรือไม่?
orion

Matlab พิมพ์เรียลไทม์การวนซ้ำแต่ละครั้ง เมื่อฉันเริ่มโปรแกรมฉันได้รับคำเตือนว่าดัชนีสูงสุดคือ 2147483647 และจากนั้นก็จะเริ่ม อีกทางหนึ่งฉันสามารถแทนที่ inf ด้วย intmax แต่นั่นคือสามตัวอักษรมากขึ้น
mmumboss


2

Golfscript, 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

สำหรับ Ruby 2.0 เท่านั้นเนื่องจากlazyวิธีการ:

(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

Perl, 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}

Ungolfed:

$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ไปจาก3ถึงเมื่อพิมพ์ $ i "ล้มเหลวกับฉัน" หรือกลายเป็นเชิงลบเพราะล้น $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

เหมาะสำหรับภาษาที่ตัวแปรทั้งหมดต้องการอักขระอย่างน้อย 2 ตัว
orion

1

Python, 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 บางตัวสำหรับนายก regex ( 167 157 143 112 ไบต์)

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 ของ regex เพื่อหลีกเลี่ยงลูปและโครงสร้างการควบคุมอย่างสมบูรณ์นั้นสมบูรณ์แบบที่สุด อย่างไรก็ตามtestการประท้วงค่อนข้างมากและมันไม่ได้ผลสำหรับฉัน นอกจากนี้คุณยังสามารถใช้บางlet n++และlet f=c-pและแทนที่ด้วยtest [หรืออาจทดสอบใน(())ที่ที่คุณไม่ต้องการ$หรือเว้นวรรค
orion

test -n $dคืนค่าจริงสำหรับสตริงว่าง test -n "$d"ดี แต่อีกต่อไป อย่างไรก็ตาม man page ระบุว่า -n เป็นทางเลือกและปรากฏว่าไม่test $dเป็นไร และดังนั้น[ $d ]ด้วย และ g = 0 ต้องเริ่มต้นใหม่
orion

@orion ขอโทษด้วยเหตุผลบางอย่างที่ดูเหมือนว่ามันจะทำงานเมื่อตอนนี้มันทำลายเครื่องของฉันด้วยฉันเปลี่ยนมันกลับเป็น 167 ฉันจะพยายามเพิ่มคำแนะนำอื่น ๆ ของคุณ
Newbrict

สภาพแวดล้อมของคุณอาจมีตัวแปรที่กำหนดไว้ล่วงหน้า
orion

@orion ด้วยเหตุผลบางอย่างที่การแก้ไขของคุณถูกปฏิเสธคุณสามารถแก้ไขอีกครั้งได้ไหม
Newbrict

1

Perl 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 ทุบตี


ฉันไม่น่ารำคาญฉันแค่อยากจะดูว่ามันจะไปได้ไกลแค่ไหน ที่นี่: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

@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 อักขระถ้าคุณพิมพ์ช่องว่างโดยไม่ต้องกำหนด" - ถ้าคุณลบการพิมพ์rและpคุณจะมีตัวละครน้อยลงและให้คะแนนโบนัส :)
CompuChip

ความสมบูรณ์ค่อนข้างดี :)
orion

1

Haskell, 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

Ungolfed:

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

ผมใช้เรียกซ้ำไม่ห่วงปกติหรือforwhile

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

มันใช้งานไม่ได้ จริง / เท็จไม่ได้ถูกกำหนด แต่แม้ว่าเราจะแก้ไขมันก็รายงานช่องว่างที่ไม่ถูกต้อง ตัวอย่างเช่นมีช่วงเวลามากมายระหว่าง 25219 ถึง 43237 การเรียกซ้ำของคุณอยู่leakingที่ด้านบนเนื่องจากคุณไม่ได้ทดสอบ isPrime (n2) คุณจะปล่อยช่วงเวลาระหว่าง n1 ถึง n2 และสิ่งนี้ไม่สามารถแก้ไขได้จริงๆเพราะคุณไม่สามารถเพิ่ม n2 ได้หากไม่มีการประชุม
orion

คุณพูดถูก! มันผิด! ความคิดของฉันผิดไปตั้งแต่แรก
Loukas

1
ตอนนี้มันดีกว่า .. :)
Loukas

+1 ตอนนี้มันคงที่แล้วฉันชอบมัน - มันแปลกมาก (แม้ว่าจะไม่ได้ผล) คุณสามารถตีมันลงได้มาก ข้ามreturnเข้าหลัก Skip elseสุดท้าย แทนที่&&-> &และมีnum%i==0 num%i<1และตามมาตรฐาน c โบราณ (จะมีคำเตือน) คุณไม่จำเป็นต้องระบุค่าที่ส่งคืนสำหรับฟังก์ชัน void และ int (อาร์กิวเมนต์เหล่านี้จะมีค่าเริ่มต้นเป็น int)
orion

ฉันกำลังเล่นอยู่นิดหน่อยและทำให้มันลดลงเหลือ 151 ตัวอักษรด้วยการเรียกซ้ำแบบไม่มีเงื่อนไขเพียงหนึ่งตัวระบุประเภท ( int) และฟังก์ชั่นการทดสอบที่ลดลงมาก: 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

Oracle 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 นั้นไม่ใช่ทัวริงที่สมบูรณ์มาก แต่ทัวริงดื้อรั้น
Jonathan Van Matre

แต่มันเป็น Turning-complete @Jonathan แม้ว่าการทำให้มันมีบางครั้ง "น่าสนใจ" :-)?
Ben

ฉันรู้ว่ามันเป็นทัวริงสมบูรณ์ พลาดเครื่องหมาย :) อย่างไรก็ตามมีคำตอบ T-SQL หลายคำในโปรไฟล์ของฉัน ... นำออราเคิลของคุณมาต่อสู้กัน!
Jonathan Van Matre

0

D - 153 + 10 = 163

ฉันเต็มใจรับโทษ +10 ที่นี่เพราะจำนวนถ่านยังคงต่ำกว่าที่ควรจะเป็นหากฉันพิมพ์จำนวนเฉพาะด้วย

Golfed :

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

JAVASCRIPT 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

Javascript 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มันจะเหมือนตลอดไปเป็นจำนวนสูงสุดเป็นสิ่งที่อยู่รอบ ๆ

Ungolfed:

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(11 ตัวอักษรด้วยการลงโทษ) กว่าp+" "+i+" "+g(13 ตัวอักษรโดยไม่ต้องลงโทษ)


0

Ruby 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

Haskell, 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

Game Maker Language, 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

Game Maker Language, 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 ตัวลงไปในบัญชี โพสต์เพื่อความสนุกเป็นส่วนใหญ่ แต่ยังให้ทางเลือกในการแสดงเนื่องจากฉันไม่เห็นตัวเองในตัวเลย 4.6s สำหรับช่องว่างไปยัง 1e9, 36s สำหรับช่องว่างไปยัง 1e10, 6.5 นาทีสำหรับ 1e11

Pari / GP 2.8 สามารถทำได้โดยทั่วไปในลักษณะเดียวกันแม้ว่าจะช้ากว่า 2x:

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

-1

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

สิ่งนี้ส่งผลให้เกิดช่องว่างทั้งหมดไม่ใช่แค่ขนาดที่ใหญ่ที่สุด
orion
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.