สมมติว่าเราเริ่มต้นด้วยรายการหมายเลขเฉพาะที่ไม่สิ้นสุด:

[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, ...

จากนั้นเรานำความแตกต่างที่แน่นอนระหว่างตัวเลขแต่ละคู่ซ้ำ ๆ กัน:

[1, 2, 2, 4, 2, 4, 2, 4, 6, 2, 6, 4, 2, 4, 6, 6, 2, 6, 4, ...
[1, 0, 2, 2, 2, 2, 2, 2, 4, 4, 2, 2, 2, 2, 0, 4, 4, 2, ...
[1, 2, 0, 0, 0, 0, 0, 2, 0, 2, 0, 0, 0, 2, 4, 0, 2, ...
[1, 2, 0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 2, 2, 4, 2, ...

ขอให้สังเกตว่าหมายเลขนำคือ 1 ทุกครั้ง การคาดเดาของ Gilbreath เป็นการคาดการณ์ว่าสิ่งนี้จะเป็นเช่นนี้ตลอดไป

วิธีเดียวที่หมายเลขนำหน้าจะหยุดการเป็น 1 คือถ้าหมายเลขถัดไปหลังจากที่ไม่ใช่ 0 หรือ 2 วิธีเดียวที่หมายเลขที่สองจะไม่ใช่ 0 หรือ 2 คือถ้าหมายเลขหลังจากนั้นไม่ใช่ 0 หรือ 2 และอื่น ๆ

ดัชนีของตัวเลขที่เก่าที่สุดนอกเหนือจากอันดับ 1 ซึ่งไม่ใช่ 0 หรือ 2 ไม่สามารถลงไปมากกว่า 1 ระหว่างลำดับที่ต่อเนื่องกัน ความจริงนี้ถูกนำมาใช้เพื่อใส่ขอบเขตล่างที่แข็งแกร่งมากเมื่อใดก็ตามลำดับอาจจะไม่ได้มี 1 เป็นองค์ประกอบแรก

ในการท้าทายนี้คุณจะได้รับดัชนีของลำดับและคุณต้องส่งออกดัชนีของตัวเลขแรกในลำดับนั้นซึ่งไม่ใช่อันดับ 1 และไม่ใช่ 0 หรือ 2

ตัวอย่างเช่นในลำดับความแตกต่างสัมบูรณ์อันดับ 4 ด้านบน:

[1, 2, 0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 2, 2, 4, 2, ...

รายการแรกที่ไม่ใช่ศูนย์หรือสองรายการนอกเหนือจากรายการแรกคืออันดับที่ 15 ซึ่งมีการจัดทำดัชนี 14 ศูนย์ ดังนั้นถ้าอินพุตเท่ากับ 4 คุณจะได้ผลลัพธ์ 14

สำหรับอินพุตจาก 1 ถึง 30 เอาต์พุตควรเป็น:

[3, 8, 14, 14, 25, 24, 23, 22, 25, 59, 98, 97, 98, 97, 174, 176, 176, 176, 176, 291, 290, 289, 740, 874, 873, 872, 873, 872, 871, 870]

นี่คือOEIS A000232

นี่คือสมมุติว่าคุณมีอินพุต 1 ดัชนีและ 0 ดัชนีผลลัพธ์ คุณสามารถทำดัชนีอินพุตและเอาต์พุตของคุณเริ่มต้นที่จำนวนเต็มคงที่ตราบใดที่คุณสามารถยอมรับช่วงของอินพุตที่สอดคล้องกับลำดับทั้งหมด

ข้อกำหนด: โซลูชันของคุณจะต้องทำงานในเวลาไม่เกิน 1 นาทีโดยป้อนข้อมูลได้สูงสุด 30 นาทีหากใกล้พอที่จะขึ้นอยู่กับข้อกำหนดของคอมพิวเตอร์อนุญาตให้ทำได้

รหัสที่สั้นที่สุดชนะ

เยลลี่ขนาด 17 ไบต์

ÆNạ2\Ḋ¿Ḣ’Ị
R‘ÇпL

ลองออนไลน์!

อินพุตคือการสร้างดัชนี 2 รายการ เอาท์พุทคือการจัดทำดัชนี 1

บน TIO ผลการทดสอบทั้งหมดใช้เวลา 22.309 วิ

Mathematica, 66 ไบต์

(For[z=1,Last@Nest[Abs@*Differences,Array[Prime,z+#],#]<3,z++];z)&

ฟังก์ชั่นแท้รับจำนวนเต็มบวกเป็นอาร์กิวเมนต์และกลับจำนวนเต็ม 1 ดัชนี Nest[Abs@*Differences,Array[Prime,z+#],#]คำนวณ#รายการผลต่างสัมบูรณ์ซ้ำแล้วซ้ำอีกของรายการของz+#ช่วงเวลาแรก For[z=1,Last@...<3,z++]วนรอบการคำนวณนี้จนกว่าองค์ประกอบสุดท้ายของรายการผลลัพธ์จะเป็นอย่างน้อยที่สุด3จากนั้นzเป็นผลลัพธ์ (โปรดทราบว่าความถูกต้องของอัลกอริทึมจะถือว่าการคาดเดาของ Gilbreath!)

Pyth , 32 ไบต์

-l.W>3h.WtHaVZtZ>QH+ZfP_TheZ.fP_

ลองออนไลน์!

ใช้การจัดทำดัชนี 2 รายการ

MATL , 18 ไบต์

`@:YqG:"d|]3<A}@G-

อินพุตและเอาต์พุตเป็นพื้นฐาน 1 ใช้เวลาน้อยกว่า 40 วินาทีใน TIO สำหรับแต่ละกรณีทดสอบ

ลองออนไลน์!

คำอธิบาย

2นี้ช่วยให้พยายามลำดับเริ่มต้นอีกต่อไปของจำนวนเฉพาะจนกระทั่งความแตกต่างแน่นอนซ้ำติดต่อกันให้ค่าอย่างน้อยหนึ่งเกิน

`        % Do... while loop
  @:Yq   %   Array of first k primes, where k is iteration index
  G:"    %   Do this as many times as the input
    d|   %     Absolute value of consecutive differences
  ]      %   End
  3<A    %   Are they all less than 3? This is the loop condition
}        % Finally (execute before exiting loop)
  @G-    %   Push last iteration index minus input. This is the output
         % End (implicit). Continue with next iteration if top of stack is true
         % Display (implicit)

Perl 6 , 136 120 bytes

{->\i,\n{i??&?BLOCK(i-1,lazy
n.rotor(2=>-1).map: {abs .[1]-.[0]})!!1+n.skip.first:
:k,none 0,2}($_,grep &is-prime,2..*)}

Ungolfed:

{   # Anonymous function with argument in $_
    sub f(\i, \n) {  # Recursive helper function
        if i != 0 {  # If we're not done,
            # Recurse on the absolute differences between adjacent entries:
            f(i - 1, lazy n.rotor(2 => -1).map: { abs .[1] - .[0] });
        } else {
            # Otherwise, return the first index after 0
            # where the value is neither 0 nor 2.
            1 + n.skip.first: :k, none 0, 2;
        }
    }
    # Call the helper function with the argument passed to the top-level
    # anonymous function (the recursion depth), and with the prime numbers
    # as the initial (infinite, lazy) list:
    f($_, grep &is-prime, 2 .. *);
}

ด้วยอินพุต 30 ฟังก์ชั่นนี้จะทำงานในเวลาประมาณสี่วินาทีบนแล็ปท็อปขนาดเล็กของฉัน

... ซึ่งกลายเป็น 1.4 วินาทีหลังจากอัปเกรดการติดตั้ง Perl 6 อายุเจ็ดเดือนของฉัน (ซึ่งให้skipวิธีการที่ช่วยให้ฉันสามารถกำจัดหลายไบต์จากโซลูชันแรกของฉัน) กรณีทดสอบทั้งหมดตั้งแต่ 1 ถึง 30 ใช้เวลาประมาณสิบวินาที

Haskell , 94 ไบต์

f(a:b:r)=abs(a-b):f(b:r)
length.fst.span(<3).(iterate f[n|n<-[2..],all((>0).mod n)[2..n-1]]!!)

ลองออนไลน์! บรรทัดสุดท้ายเป็นฟังก์ชั่นนิรนาม เชื่อมโยงกับเช่นและโทรเช่นg g 4กรณีทดสอบทั้งหมดรวมกันใช้เวลาน้อยกว่า 2 วินาทีใน TIO

มันทำงานอย่างไร

[n|n<-[2..],all((>0).mod n)[2..n-1]]สร้างรายการเฉพาะของอนันต์
f(a:b:r)=abs(a-b):f(b:r)เป็นฟังก์ชั่นที่ให้ความแตกต่างที่แน่นอนขององค์ประกอบของรายการที่ไม่สิ้นสุด กำหนดตัวเลขnให้(iterate f[n|n<-[2..],all((>0).mod n)[2..n-1]]!!)ใช้f nเวลากับรายการช่วงเวลา length.fst.span(<3)คำนวณความยาวของส่วนนำหน้าของรายการผลลัพธ์ที่องค์ประกอบมีขนาดเล็กลง 3

ความจริง 289 ไบต์

g(n:PI):PI==(k:=n*10;c:List NNI:=[i for i in 1..(k quo 2)|prime?(i)];repeat(a:=concat(c,[i for i in (k quo 2+1)..k|prime?(i)]);j:=0;c:=a;repeat(j=n=>break;j:=j+1;b:=a;a:=[abs(b.(i+1)-b.i)for i in 1..(#b-1)]);j:=2;repeat(j>#a=>break;a.j~=2 and a.j~=1 and a.j~=0=>return j-1;j:=j+1);k:=k*2))

ถอดและทดสอบ

f(n:PI):PI==
  k:=n*10
  c:List NNI:=[i for i in 1..(k quo 2)|prime?(i)]
  repeat
    a:=concat(c,[i for i in (k quo 2+1)..k|prime?(i)])
    j:=0;c:=a
    repeat
       j=n=>break
       j:=j+1
       b:=a
       a:=[abs(b.(i+1)-b.i)  for i in 1..(#b-1)]
    j:=2
    repeat
       j>#a=>break
       a.j~=2 and a.j~=1 and a.j~=0 => return j-1
       j:=j+1
    k:=k*2

(4) -> [g(i)  for i in 1..30]
   (4)
   [3, 8, 14, 14, 25, 24, 23, 22, 25, 59, 98, 97, 98, 97, 174, 176, 176, 176,
    176, 291, 290, 289, 740, 874, 873, 872, 873, 872, 871, 870]

หากไม่พบวิธีแก้ไขให้ขยายรายการหลักของ 2 * x ในลูปและคำนวณรายการที่เหลือทั้งหมดอีกครั้ง 3 วินาทีสำหรับ find g (30)