OEIS มีการเปลี่ยนแปลง (A111439) ในลำดับ Golomb ของ เช่นเดียวกับในลำดับของ Golomb A(n)อธิบายความถี่ที่nปรากฏในลำดับ แต่นอกจากนี้ตัวเลขสองตัวที่ต่อกันอาจไม่เหมือนกัน ในขณะที่สร้างลำดับนั้นA(n)จะถูกเลือกให้เป็นจำนวนเต็มบวกที่เล็กที่สุดที่ไม่ละเมิดคุณสมบัติทั้งสองนี้ เนื่องจากตัวเลขที่เหมือนกันไม่ได้รับอนุญาตติดต่อจึงทำให้ชุดโยกเยกขึ้นและลงเล็กน้อยเมื่อโตขึ้น นี่คือ 100 คำแรก:

1, 2, 3, 2, 3, 4, 3, 4, 5, 6, 5, 6, 5, 6, 7, 6, 7, 8, 7, 8, 9, 8, 9, 8, 9, 
10, 9, 10, 9, 10, 11, 10, 11, 10, 11, 10, 11, 12, 11, 12, 13, 12, 13, 12, 
13, 12, 13, 12, 13, 14, 15, 14, 15, 14, 15, 14, 15, 14, 15, 14, 15, 16, 15, 
16, 17, 16, 17, 16, 17, 16, 17, 16, 17, 18, 17, 18, 17, 18, 19, 18, 19, 18, 
19, 18, 19, 18, 19, 18, 19, 20, 19, 20, 21, 20, 21, 20, 21, 20, 21, 20

รายการเต็มรูปแบบของตัวเลข 10,000 คนแรกที่สามารถพบได้ใน OEIS

ความท้าทายคือการเขียนโปรแกรมหรือฟังก์ชั่นซึ่งคำนวณให้A(n) เป็นพื้นฐานเพื่อให้แน่ใจว่าคุณสมบัติการอธิบายตนเองทำงานได้nn1

กฎระเบียบ

คุณสามารถเขียนโปรแกรมหรือฟังก์ชั่นและใช้วิธีการมาตรฐานของเราในการรับอินพุตและให้เอาต์พุต

คุณอาจใช้ภาษาการเขียนโปรแกรมใด ๆแต่โปรดทราบว่าช่องโหว่เหล่านี้เป็นสิ่งต้องห้ามตามค่าเริ่มต้น

นี่คือรหัสกอล์ฟดังนั้นคำตอบที่สั้นที่สุดที่ถูกต้อง - วัดเป็นไบต์ - ชนะ

กรณีทดสอบ

n     A(n)
1     1
4     2
10    6
26    10
100   20
1000  86
1257  100
10000 358

Haskell , 67 ไบต์

f k|k<4=k|p<-k-1=[n|n<-[1..],n/=f p,sum[1|a<-[1..p],f a==n]<f n]!!0

fกำหนดฟังก์ชั่น ลองออนไลน์! มันช้ามากการคำนวณf 15ไทม์เอาต์บน TIO

คำอธิบาย

เพียงแค่ไปกับคำจำกัดความ: ในทุกขั้นตอนเลือกจำนวนบวกน้อยที่สุดnที่สอดคล้องกับข้อ จำกัด (ไม่เท่ากับรายการก่อนหน้านี้และยังไม่เกิดขึ้นf nครั้ง)

f k             -- Define f k:
 |k<4=k         -- If k < 4, it's k.
 |p<-k-1=       -- Otherwise, bind k-1 to p,
  [n|           -- compute the list of numbers n where
   n<-[1..],    -- n is drawn from [1,2,3,...],
   n/=f p,      -- n is not equal to f p, and
   sum[1|       -- the number of
    a<-[1..p],  -- those elements of [1,2,3,...,p]
    f a==n]     -- whose f-image equals n
   <f n]        -- is less than f n,
  !!0           -- and take the first element of that list.

Mathematica, 69 68 ไบต์

ขอบคุณ Martin Ender สำหรับการค้นหา –1 ไบต์พิเศษสำหรับฉัน!

Last@Nest[{##&@@#,1//.x_/;x==Last@#||#~Count~x==#[[x]]->x+1}&,{},#]&

ฟังก์ชั่นที่ไม่มีชื่อการใช้จำนวนเต็มบวกnเป็นอินพุตและส่งคืนจำนวนเต็มบวก เราสร้างรายการทั้งหมดของรายการแรกnองค์ประกอบของลำดับนี้แล้วนำLastองค์ประกอบ รายการนี้สร้างขึ้นโดยเริ่มจากรายการว่าง{}และดำเนินการกับnเวลาในแถว (ผ่านNest)

ฟังก์ชันที่เป็นปัญหา{##&@@#,1//.x_/;x==Last@#||#~Count~x==#[[x]]->x+1}&ซึ่งรับรายการบางส่วนของค่าลำดับ (เป็นหลัก##&@@#) และต่อท้ายค่าถัดไป มูลค่าต่อไปคือการคำนวณโดยเริ่มต้นด้วยx=1แล้วซ้ำ ๆ แทนที่xโดยx+1ตราบใดที่อยู่ในสภาพที่x==Last@#||#~Count~x==#[[x]]จะพบในคำอื่น ๆ ถ้าอย่างใดอย่างหนึ่งxเป็นองค์ประกอบก่อนหน้านี้หรืออื่น ๆ ที่xมีอยู่แล้วในรายการหมายเลขที่ถูกต้องครั้ง ฟังก์ชั่นนี้ถ่มน้ำลายข้อผิดพลาดบางตั้งแต่ (ตัวอย่าง) เราไม่ควรที่จะเรียกxองค์ประกอบ TH ของรายการเริ่มต้น{}; อย่างไรก็ตามค่าทั้งหมดนั้นถูกต้อง

Python 2, 99 86 ไบต์

ขอบคุณ @Dennis สำหรับการปรับปรุงหลายประการรวมเป็น 13 ไบต์!

s=0,1,2,3
exec't=1\nwhile t==s[-1]or s.count(t)/s[t]:t+=1\ns+=t,;'*input()
print s[-4]

โปรแกรมดำเนินไปอย่างไร้เดียงสา: คอยติดตามรายการค่าที่กำหนดไว้จนถึงตอนนี้และดูเหมือนจะผนวกค่าถัดไป มันพยายามที่จะผนวก1ท้ายของรายการถ้ามันสามารถ; หากไม่เป็นเช่นนั้นก็จะพยายาม2จนกว่าจะมีบางสิ่งบางอย่างได้รับอนุญาต

ตอนนี้เราเริ่มต้นด้วยการเพาะผลสำหรับที่จะเป็น1,2,3 1,2,3นี้จะทำเพื่อหลีกเลี่ยงปัญหาใด ๆ กับรายการของค่าแล้วคำนวณเป็นสั้นเกินไป: ผมคาดเดาว่าถ้าnเป็นอย่างน้อย4แล้วเป็นอย่างเคร่งครัดน้อยกว่าa(n) n(ในโปรแกรมs[n]นี้เท่ากับa(n)รายชื่อของเราจริง ๆ แล้วเริ่มต้นได้[0,1,2,3]เนื่องจากรายการมี0-indexed ใน Python ดังนั้นตัวอย่างa(1)=s[1]=1และa(2)=s[2]=2.)

ดังนั้นขอบอกว่าเรากำลังพยายามที่จะตรวจสอบความหมายว่ารายการของเราอยู่แล้วรวมถึงs[m] s[0], s[1], ..., s[m-1]เราจะเริ่มต้นที่และพยายามที่จะตั้งค่าt=1 s[m]=1เมื่อที่ไม่ได้ทำงานที่เราจะไปและพยายามที่จะตั้งค่าt=2 s[m]=2ทุกครั้งที่เราเพิ่มขึ้นtเราตรวจสอบว่าs.count(t)==s[t]... t=mแต่ด้านขวามือจะไม่สร้างข้อผิดพลาดดังนั้นตราบใดที่เราไม่ต้องไปสูงถึง s[4]การคาดคะเนบอกว่าเราไม่เคยต้องเนื่องจากค่าแรกเราคำนวณเป็นจริง

การใช้งานนี้คำนวณลำดับของค่าได้มากกว่า 3 ค่า ตัวอย่างเช่นถ้าnเป็น8ก็จะคำนวณผ่านก่อนที่จะส่งกลับค่าของs[11]s[8]

ฉันยินดีที่จะดูหลักฐานการคาดเดา ฉันเชื่อว่าสามารถพิสูจน์ได้ด้วยการเหนี่ยวนำ (แข็งแรง?)

แก้ไข: นี่คือหลักฐานการคาดเดา จริง ๆ แล้วเราพิสูจน์รูปแบบของคำแถลงที่แข็งแกร่งขึ้นเล็กน้อยเนื่องจากไม่เกี่ยวข้องกับงานพิเศษ

ทฤษฎีบท:สำหรับทั้งหมดที่nมากกว่าหรือเท่ากับ4ระยะที่น้อยกว่าหรือเท่ากับa(n)(n-2)

หลักฐาน (โดยการเหนี่ยวนำที่แข็งแกร่ง): (ฐานn=4): คำสั่งที่เป็นจริงสำหรับตั้งแต่n=4a(4) = 2 = 4-2

ตอนนี้สมมติว่าa(k)น้อยกว่าหรือเท่ากับk-2สำหรับทั้งหมดkจาก4ถึงnรวม (และถือว่าnอย่างน้อย4) (n-2)โดยเฉพาะอย่างยิ่งที่นี้หมายถึงว่าคำก่อนหน้านี้ทั้งหมดของลำดับเป็นที่มากที่สุด เราจำเป็นต้องแสดงให้เห็นว่าจะเป็นที่มากที่สุดa(n+1) (n-1)ตอนนี้ตามคำจำกัดความa(n)เป็นจำนวนเต็มบวกที่เล็กที่สุดที่ไม่ได้ละเมิดเงื่อนไขใด ๆ ดังนั้นเราแค่ต้องแสดงให้เห็นว่าค่า(n-1)จะไม่ละเมิดเงื่อนไขใด ๆ

ค่าที่(n-1)จะไม่ละเมิด "ไม่ซ้ำติดต่อกัน" (n-2)สภาพเพราะโดยสมมติฐานเหนี่ยวนำรายการก่อนหน้านี้ที่มากที่สุด และจะไม่ละเมิดเงื่อนไข " a(m)เป็นจำนวนครั้งที่mปรากฏ" เว้นแต่ว่า(n-1)ได้มาถึงa(n-1)แล้ว แต่โดยสมมติฐานเหนี่ยวนำที่แข็งแกร่ง(n-1)ได้รับก่อนหน้านี้ถึง0เวลาและa(n-1)ไม่เท่ากับ0ตั้งแต่เป็นบวกทั้งหมดa(m)m

ดังนั้นa(n+1)น้อยกว่าหรือเท่ากับn-1 = (n+1)-2ตามที่ต้องการ QED

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

Ṭ€S<;1Tḟ®Ḣ©ṭ
⁸Ç¡Ṫ

กรณีทดสอบสามครั้งล่าสุดนั้นมีมากเกินไปสำหรับ TIO ฉันได้ตรวจสอบ1,000และ1257ในพื้นที่แล้ว

ลองออนไลน์! หรือตรวจสอบ 100 คำแรก

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

⁸Ç¡Ṫ          Main link. No arguments.

⁸             Yield [].
 Ç¡           Execute the helper link n times (where n is an integer read from
              STDIN), initially with argument [], then with the previous return
              value as argument. Yield the last return value.
              Tail; yield the last element of the result.


Ṭ€S<;1Tḟ®Ḣ©ṭ  Helper link. Argument: A (array)

Ṭ€            Untruth each convert each k into an array of k-1 zeroes and one 1.
  S           Sum; column-wise reduce by +, counting the occurrences of all
              between 1 and max(A).
   <          Compare the count of k with A[k] (1-indexed), yielding 1 for all
              integers that still have to appear once or more times.
    ;1        Append a 1 (needed in case the previous result is all zeroes).
      T       Truth; find all indices of ones.
       ḟ®     Filter-false register; remove the value of the register (initially 0)
              from the previous result.
         Ḣ©   Head copy; yield the first (smallest) value of the result and save
              it in the register.
           ṭ  Tack; append the result to A.

Python 2 , 77 74 ไบต์

f=lambda n,k=1:n*(n<4)or map(f,range(n)+k*[n-1]).count(k)<f(k)or-~f(n,k+1)

นี่คือการดำเนินการ recursive ของอัลกอริทึมของ @ mathmandan

การใช้งานคือO (บ้า) : อินพุต9ใช้เวลา 2 วินาทีภายในเครื่องอินพุต10 52 วินาทีและอินพุต11 17 นาทีและ 28 วินาที อย่างไรก็ตามหากประกาศเป็นฟังก์ชั่นปกติแทนที่จะเป็นแลมบ์ดาคุณสามารถใช้การบันทึกช่วยจำเพื่อตรวจสอบกรณีทดสอบได้

ลองออนไลน์!

โปรดทราบว่าแม้จะมีการบันทึกช่วยจำ TIO ไม่สามารถคำนวณf (1257)หรือf (10,000) (ทั้งคู่ได้รับการตรวจสอบในเครื่อง)

05AB1E , 32 31 ไบต์

XˆXˆG[N¯2(è<›¯¤NÊsN¢¯Nè‹&&#]N.ˆ

ลองออนไลน์!

คำอธิบาย

XˆXˆ                             # initialize global list as [1,1]
    G                            # input-1 times do:
     [                    #]     # loop until expression is true     
      N¯2(è<›                    # n > list[-2]-1
             ¯¤NÊ                # list[-1] != N
                 sN¢¯Nè‹         # count(list, N) < list[N]
                        &&       # logical AND of the 3 expressions
                            N.ˆ  # add N to global list 
                                   and output last value in list and end of program

เรามีเทคนิคในการวนซ้ำGเมื่อเราเพิ่มNลงในรายการส่วนกลาง แต่ลูปทั้งหมดใน 05AB1E ใช้ตัวแปรเดียวกับNเป็นดัชนีดังนั้นวงภายใน[...]ได้เขียนทับNของGความหมายที่เราสามารถเพิ่มไว้นอกวงได้

ปัญหาของลูปซ้อนและเงื่อนไขทำให้เราไม่สามารถทำสิ่งนี้ได้

Befunge, 141 136 ไบต์

<v9\0:p8\2:*2:-1<9
v>p1+:3\8p0\9p:#^_&
>1-:#v_1.@>$8g.@
*+2%\>1-:!|>$!:::9g!\!9g!*\:8g\!8g`
9\+1g9::< \|`g9\g8+2::p
g2+\8p2+^:<>:0\9p::8

ลองออนไลน์!

เนื่องจากข้อ จำกัด ของหน่วยความจำของ Befunge จึงไม่เป็นประโยชน์ในการติดตามรายการก่อนหน้าทั้งหมดตามลำดับดังนั้นโซลูชันนี้ใช้อัลกอริทึมที่มีหน่วยความจำต่ำกว่าซึ่งคำนวณค่าได้โดยตรงมากขึ้น

ที่กล่าวว่าเรายังคง จำกัด ด้วยขนาดของเซลล์ซึ่งในการอ้างอิงล่าม Befunge-93 เป็นค่าเซ็นสัญญา 8 บิตเพื่อให้ได้รับการสนับสนุนจำนวนคู่ที่สูงที่สุดในลำดับและได้รับการสนับสนุนเลขคี่ที่สูงที่สุดคือA(1876) = 126A(1915) = 127

หากคุณต้องการทดสอบค่าที่มากขึ้นคุณจะต้องใช้ล่ามที่มีขนาดเซลล์ที่ใหญ่กว่า ซึ่งควรรวมถึงการใช้งาน Befunge-98 ส่วนใหญ่ ( ลองออนไลน์! )

Python 2, 117 ไบต์

Meh ไม่สั้น วิธีแก้ปัญหาซ้ำง่าย

L=[1,2,3]
n=input()
while len(L)<n:
 for i in range(2,n):
    if L.count(i)<L[i-1]and L[-1]!=i:L+=[i];break
print L[n-1]

ลองออนไลน์

นี่เป็นความพยายามที่ไม่ดีจริงๆสำหรับโซลูชันแบบเรียกซ้ำ (129 ไบต์):

def f(n,L=[1,2,3]):
 if len(L)>=n:print L[n-1];exit(0)
 for i in range(2,n):
    if L.count(i)<L[i-1]and L[-1]!=i:f(n,L+[i])
 f(n,L)