งานของคุณคือการใช้ลำดับจำนวนเต็มA130826 :

_nเป็นจำนวนเต็มบวกที่เล็กที่สุดเช่นว่า_n - nเป็นหลายทั้ง3และครั้งที่สองจำนวนหารของ(ก_n - n) / 3ให้n ^THระยะในความแตกต่างครั้งแรกของลำดับที่ผลิตโดยฟลาเวีย ตะแกรงฟัส

ลืมไปหรือยัง จริง ๆ แล้วมันค่อนข้างง่าย

ฟลาเวียฟัตะแกรงกำหนดลำดับจำนวนเต็มดังต่อไปนี้

1. เริ่มต้นด้วยการลำดับของจำนวนเต็มบวกและการตั้งค่าk = 2

2. ลบทุกk ^THจำนวนเต็มของลำดับเริ่มต้นด้วยk TH

3. เพิ่มค่าkแล้วย้อนกลับไปขั้นตอนที่ 2

ฉ_nเป็นn ^THจำนวนเต็ม (1 จัดทำดัชนี) ที่ไม่เคยได้รับการถอดออก

ถ้า - ตามปกติ - σ ₀ (k)หมายถึงจำนวนหารบวกของจำนวนเต็มที่kเราสามารถกำหนด_nเป็นเลขที่เล็กที่สุดบวกดังกล่าวว่า2σ ₀ ((เป็น_n - n) / 3) f = _{1 + n} - ฉ n

ท้าทาย

เขียนโปรแกรมหรือฟังก์ชั่นที่ใช้เป็นจำนวนเต็มบวกnเป็น input และพิมพ์หรือส่งกลับn

ใช้กฎมาตรฐานของกอล์ฟ รหัสที่สั้นที่สุดอาจชนะ!

ทำงานตัวอย่าง

หากเราลบองค์ประกอบที่สองของจำนวนเต็มบวกเราก็จะเหลือ

 1  3  5  7  9 11 13 15 17 19 21 23 25 27 29 31 33 35 37 39 ...

หลังจากลบองค์ประกอบที่สามทุกส่วนที่เหลือเราจะได้รับ

 1  3  7  9 13 15 19 21 25 27 31 33 37 39 ...

ตอนนี้ลบทุก ๆ สี่ส่วนจากห้าส่วนองค์ประกอบที่หกทำให้เราได้

 1  3  7 13 15 19 25 27 31 37 39 ...
 1  3  7 13 19 25 27 31 39 ...
 1  3  7 13 19 27 31 39 ...
 1  3  7 13 19 27 39 ...

แถวสุดท้ายแสดงให้เห็นว่าข้อตกลงเอฟ₁ที่จะฉ 7

ความแตกต่างขององค์ประกอบที่ต่อเนื่องกันของข้อกำหนดเหล่านี้คือ

 2  4  6  6  8 12

หารความแตกต่างไปข้างหน้าด้วย2เราได้

 1  2  3  3  4  6 

นี่คือตัวนับเป้าหมาย

• 4เป็นครั้งแรกจำนวนเต็มkดังกล่าวว่าσ ₀ ((k - 1) / 3) = 1 ในความเป็นจริงσ ₀ (1) = 1
• 8เป็นครั้งแรกจำนวนเต็มkดังกล่าวว่าσ ₀ ((k - 2) / 3) = 2 ในความเป็นจริงσ ₀ (2) = 2
• 15เป็นครั้งแรกจำนวนเต็มkดังกล่าวว่าσ ₀ ((k - 3) / 3) = 3 ในความเป็นจริงσ ₀ (4) = 3
• 16เป็นครั้งแรกจำนวนเต็มkดังกล่าวว่าσ ₀ ((k - 4) / 3) = 3 ในความเป็นจริงσ ₀ (4) = 3
• 23เป็นครั้งแรกจำนวนเต็มkดังกล่าวว่าσ ₀ ((k - 5) / 3) = 4 ในความเป็นจริงσ ₀ (6) = 4
• 42เป็นครั้งแรกจำนวนเต็มkดังกล่าวว่าσ ₀ ((k - 6) / 3) = 6 ในความเป็นจริงσ ₀ (12) = 6

กรณีทดสอบ

   n     a(n)

   1        4
   2        8
   3       15
   4       16
   5       23
   6       42
   7       55
   8      200
   9       81
  10       46
  11      119
  12      192
  13      205
  14   196622
  15    12303
  16       88
  17      449
  18      558
  19      127
  20     1748
  21   786453
  22       58
  23     2183
  24     3096
  25     1105
  26   786458
  27 12582939
  28      568
  29     2189
  30     2730

เยลลี่, 30 29 27 25 ไบต์

บันทึก 2 ไบต์ขอบคุณ @Dennis ที่แจ้งให้ฉันทราบÆdและอีก 2 ไบต์สำหรับการรวมทั้งสองเชน

RUð÷‘Ċ×µ/
‘Ç_ÇH0Æd=¥1#×3+

ลองออนไลน์!

นี่อาจสนุกที่สุดที่ฉันเคยมีกับ Jelly ฉันเริ่มจากบรรทัดที่สองซึ่งคำนวณf _nจากnโดยใช้สูตรบน OEIS และค่อนข้างสวยงาม

คำอธิบาย

RUD ÷ 'C ×μ / การเชื่อมโยงตัวช่วยในการคำนวณ F n อาร์กิวเมนต์: n
R รับตัวเลข [1..n]
 คุณกลับ
        / ลดโดย "ปัดเศษขึ้นเป็นทวีคูณ 2 ถัดไป":
   ÷หารด้วยหมายเลขถัดไป
    'เพิ่มขึ้นเพื่อข้ามหลายรายการ
     Ċ Ceil (ปัดเศษขึ้น)
      ×คูณด้วยหมายเลขถัดไป

'Ç_ÇH0Æd = ¥ 1 # × 3 + ลิงก์หลัก อาร์กิวเมนต์: n
'เพิ่ม n
 Çคำนวณ F n + 1 
   Çคำนวณ F n
  _ ลบ
    H หารด้วย 2
     0 1 # เริ่มต้นจาก 0 ค้นหาผู้สมัครคนแรกสำหรับ (a - n) / 3
                   ที่น่าพอใจ ...
      Ædσ 0 (( n -n) / 3)
        = = (F n + 1 -F n ) / 2
            คูณ 3 คูณ 3 เพื่อเปลี่ยน (a - n) / 3 เป็นn -n
              + เพิ่ม n จะเปิดn -n เป็นn

Python 2 , 121 119 118 ไบต์

n=input();r=range(1,4**n);d=s,=r*1,
for k in r:del s[k::k+1];d+=sum(k%j<1for j in r)*2,
print d.index(s[n]-s[n-1])*3+n

เวลาที่ใช้ควรจะประมาณO (16 ⁿ )ด้วยการใช้หน่วยความจำO (4 ⁿ ) การแทนที่4**nด้วย5<<n- ซึ่งฉันคิดว่าเพียงพอ - จะปรับปรุงสิ่งนี้ได้อย่างมาก แต่ฉันไม่เชื่อว่ามันจะทำงานได้ดีกับค่าn ที่มากโดยพลการ

ลองออนไลน์!

พฤติกรรมเชิงเส้นประสาทและขอบเขตบนของ_n

กําหนดข_nเป็น(เป็น_n - n) / 3คือมีขนาดเล็กที่สุดจำนวนเต็มบวกkดังกล่าวว่าσ ₀ (k) = ½ (ฉ_{1 + n} - ฉ_n )

ตามที่ระบุไว้ใน OEIS หน้าฉ_n ~ ¼πn ²ดังนั้นฉ_{1 + n} - ฉ_n ~ ¼π (n + 1) ² - ¼πn ² = ¼π (2n + 1) ~ ½πn

วิธีนี้½ (ฉ_{1 + n} - ฉ_n ) ~ ¼πn ถ้าจำนวนที่เกิดขึ้นจริงเป็นนายกพี , จำนวนเต็มบวกที่เล็กที่สุดกับหน้าตัวหารเป็น2 ^P-1ดังนั้นข_nสามารถห้วง2 ^ค_nที่ค_n ~ ¼πn

ดังนั้นb _n <4 ⁿจะเก็บไว้สำหรับn ที่มีขนาดใหญ่พอและให้ที่2 ^¼πn <2 ⁿ << (2 ⁿ ) ² = 4 ⁿฉันมั่นใจว่าไม่มีตัวอย่าง

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

n=input();r=range(1,4**n);d=s,=r*1,

สิ่งนี้ตั้งค่าการอ้างอิงบางอย่างสำหรับกระบวนการวนซ้ำของเรา

• nคืออินพุตของผู้ใช้: จำนวนเต็มบวก

• Rคือรายการ[1, ... , 4 ⁿ - 1]

• sเป็นสำเนาของR

  การทำซ้ำรายการครั้งกับr*1สร้างสำเนาตื้นดังนั้นการปรับเปลี่ยนsจะไม่ปรับเปลี่ยนR

• dจะเริ่มต้นเป็น tuple (s)

  ค่าแรกนี้ไม่สำคัญ คนอื่น ๆ ทั้งหมดจะถือจำนวนตัวหารของจำนวนเต็มบวก

for k in r:del s[k::k+1];d+=sum(k%j<1for j in r)*2,

สำหรับแต่ละจำนวนเต็มkจาก1ถึง4 ⁿ - 1เราทำดังต่อไปนี้

• del s[k::k+1]ใช้เวลาทุก(k + 1) ^THจำนวนเต็มในs - เริ่มต้นด้วย(k + 1) ^TH - และลบที่ชิ้นจากs

  นี้เป็นวิธีที่ตรงไปตรงมาในการจัดเก็บช่วงเวลาเริ่มต้นของฟลาเวียฟัตะแกรงในs มันจะคำนวณมากกว่าข้อกำหนดเริ่มต้นn + 1 ที่ต้องการแต่การใช้forลูปเดี่ยวเพื่ออัปเดตทั้งsและdจะบันทึกบางไบต์

• d+=sum(k%j<1for j in r)*2,นับว่าหลายองค์ประกอบของRแบ่งkอย่างสม่ำเสมอและผนวก2σ ₀ (k)เพื่อd

  ตั้งแต่งได้รับการเริ่มต้นเป็น tuple เดี่ยว, 2σ ₀ (k)จะถูกเก็บไว้ที่ดัชนีk

print d.index(s[n]-s[n-1])*3+n

พบนี้ดัชนีแรกของF _{1 + n} - ฉ_nในdซึ่งเป็นที่เล็กที่สุดkดังกล่าวว่า2σ ₀ (k) = f _{1 + n} - ฉ_nแล้วคำนวณ_nเป็น3k + 1และพิมพ์ผล

Java 8, 336 , 305 , 303 , 287 , 283 279 ไบต์

ลบแล้ว 57 ไบต์โดย Kritixi Lithos

แข็งแรงเล่นกอล์ฟ

class f{static int g(int s,int N){return s<1?N+1:g(s-1,N+N/s);}static int h(int k){int u=0,t=1,i;for(;u!=(g(k,k)-g(k,k-1))/2;t++)for(i=1,u=0;i<=t;)if(t%i++<1)u++;return 3*t-3+k;}public static void main(String[]a){System.out.print(h(new java.util.Scanner(System.in).nextInt()));}}

Ungolfed

class f {
    static int g(int s,int N){return s < 1 ? N + 1 : g(s - 1, N + N / s);}

    static int h(int k) {
        int u = 0, t = 1, i;
        // get the first number with v divisors
        while(u != (g(k, k) - g(k, k - 1))/2){
            u = 0;
            for (i = 1; i <= t; i++)
                if (t % i < 1) u++;
            t++;
        }
        // 3*(t-1)+k = 3*t+k-3
        return 3 * t + k - 3;
    }

    public static void main(String[] a) {
        System.out.print(h(new java.util.Scanner(System.in).nextInt()));
    }
}

Mathematica, 130 116 106 103 ไบต์

3Catch@Do[f=#2⌈#/#2+1⌉&~Fold~Reverse@Range@#&;If[Tr[2+0Divisors@k]==f[#+1]-f@#,Throw@k],{k,∞}]+#&

หรือ

3Catch@Do[f=#2⌈#/#2+1⌉&~Fold~Reverse@Range@#&;If[2DivisorSum[k,1&]==f[#+1]-f@#,Throw@k],{k,∞}]+#&

ท้ายที่สุดก็เกือบจะเหมือนกับรหัส Jelly ของ @ Pietu1998 ...

คำอธิบาย

Catch@

Catchสิ่งที่เป็นThrow-ed (โยน)

Do[ ... ,{k,∞}]

วนไม่มีสิ้นสุด; kเริ่มต้นจาก1และเพิ่มขึ้นทุกการทำซ้ำ

f= ...

กำหนดf:

Reverse@Range@#

{1, 2, ... , n}พบ ย้อนกลับ

#2⌈#/#2+1⌉&

ฟังก์ชั่นที่ส่งออก ceil (n1 / n2 + 1) * n2

f= ... ~Fold~ ... &

กำหนดfฟังก์ชันที่ใช้ฟังก์ชันข้างต้นซ้ำกับรายการจากสองขั้นตอนด้านบนโดยใช้แต่ละเอาต์พุตเป็นอินพุตแรกและแต่ละองค์ประกอบของรายการเป็นอินพุตที่สอง "ผลลัพธ์" เริ่มต้น (อินพุตแรก) เป็นองค์ประกอบแรกของรายการ

Tr[2+0Divisors@k]==f[#+1]-f@#

ตรวจสอบว่าจำนวนตัวหารของสองkเท่าเท่ากับ f (n + 1) - f (n)

If[ ... ,Throw@k]

ถ้าเงื่อนไขเป็นTrue, ค่าของThrow kถ้าไม่ทำต่อให้วนซ้ำ

3 ... +#&

คูณผลลัพธ์ด้วย 3 และเพิ่ม n

รุ่น 130 ไบต์

Catch@Do[s=#+1;a=k-#;If[3∣a&&2DivisorSigma[0,a/3]==Differences[Nest[i=1;Drop[#,++i;;;;i]&,Range[s^2],s]][[#]],Throw@k],{k,∞}]&

Perl 6 , 154 149 136 107 ไบต์

->\n{n+3*first ->\o{([-] ->\m{m??&?BLOCK(m-1).rotor(m+0=>1).flat!!1..*}(n)[n,n-1])/2==grep o%%*,1..o},^Inf}

Ungolfed:

-> \n {                    # Anonymous sub taking argument n
  n + 3 * first -> \o {    # n plus thrice the first integer satisfying:
    (                      #
      [-]                  #
      -> \m {              # Compute nth sieve iteration:
        m                  # If m is nonzero,
          ?? &?BLOCK(m-1).rotor(m+0=>1).flat # then recurse and remove every (m+1)-th element;
          !! 1..*          # the base case is all of the positive integers
      }                    #
      (n)                  # Get the nth sieve
      [n,n-1]              # Get the difference between the nth and (n-1)th elements (via the [-] reduction operator above)
    ) / 2                  # and divide by 2;
    ==                     # We want the number that equals
    grep o %% *, 1..o      # the number of divisors of o.
  }
  ,^Inf
}

05AB1E ,35 34 39 ไบต์

1Qi4ë[N3*¹+NÑg·¹D>‚vyy<LRvy/>îy*}}‚Æ(Q#

มันดูน่ากลัวดังนั้นประสิทธิภาพของรันไทม์ก็คือ ใช้เวลาหลายวินาทีสำหรับอินพุตที่ให้ค่าน้อย อย่าลองตัวเลขอย่างเช่น 14; ในที่สุดจะพบผลลัพธ์ แต่จะใช้เวลานาน

คำอธิบาย

มันทำงานเป็น 2 โปรแกรมที่เรียกตามลำดับ คนแรกที่คำนวณF _{1 + n} - F _nและสองกำหนด_nขึ้นอยู่กับความหมายของการใช้วิธีการ Bruteforce

F _{n + 1} - F _nได้รับการประเมินสำหรับการวนซ้ำแต่ละครั้งถึงแม้ว่าจะเป็นการวนซ้ำไม่แน่นอน มันทำให้รหัสไม่มีประสิทธิภาพเวลา แต่มันทำให้รหัสสั้นลง

ลองออนไลน์!