Trình tự lắc lư của Golomb


21

OEIS có một biến thể (A111439) trên chuỗi của Golomb . Như trong chuỗi của Golomb, A(n)mô tả mức độ thường xuyên nxuất hiện trong chuỗi. Nhưng ngoài ra, không có hai số liên tiếp có thể giống hệt nhau. Trong khi xây dựng chuỗi, A(n)luôn được chọn là số nguyên dương nhỏ nhất không vi phạm hai thuộc tính này. Do các số giống hệt nhau không được phép, chuỗi này lắc lư lên xuống một chút khi nó lớn lên. Dưới đây là 100 điều khoản đầu tiên:

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

Danh sách đầy đủ của 10.000 số đầu tiên có thể được tìm thấy trên OEIS .

Thách thức là viết một chương trình hoặc hàm tính toán A(n), đưa ra n. nđược 1dựa trên cơ sở để đảm bảo rằng tài sản tự mô tả hoạt động.

Quy tắc

Bạn có thể viết chương trình hoặc chức năng và sử dụng bất kỳ phương pháp tiêu chuẩn nào để nhận đầu vào và cung cấp đầu ra.

Bạn có thể sử dụng bất kỳ ngôn ngữ lập trình nào , nhưng lưu ý rằng các lỗ hổng này bị cấm theo mặc định.

Đây là , vì vậy câu trả lời hợp lệ ngắn nhất - được đo bằng byte - thắng.

Các trường hợp thử nghiệm

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


3
Tôi tò mò vì vậy tôi đã vẽ biểu đồ nó . Neato.
Kỹ sư Toast

4
@EngineerToast Biểu đồ cũng có trên OEIS. Tôi đã xem xét thời gian "chạy" mà bạn nhìn thấy trong biểu đồ của bạn điều đó thực sự kỳ lạ . (Biểu đồ này cho thấy mức độ thường xuyên Nxuất hiện sau lần xuất hiện cuối cùng trong N-1đó đo số lần lắc lư xuống N.)
Martin Ender

Câu trả lời:


5

Haskell , 67 byte

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

Xác định một hàm f. Hãy thử trực tuyến! Nó rất chậm, f 15thời gian tính toán trên TIO.

Giải trình

Chỉ cần đi với định nghĩa: ở mọi giai đoạn, chọn số dương tối thiểu nthỏa mãn các ràng buộc (không bằng mục trước và chưa xảy ra f nlần nào).

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.

5

Toán học, 69 68 byte

Cảm ơn Martin Ender vì đã tìm thêm byte byte1 cho tôi!

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

Hàm không tên lấy một số nguyên dương nlàm đầu vào và trả về một số nguyên dương. Chúng tôi xây dựng toàn bộ danh sách các nphần tử đầu tiên của chuỗi này, sau đó lấy Lastphần tử. Danh sách này được xây dựng bằng cách bắt đầu với danh sách trống {}và vận hành trên đó với nthời gian chức năng liên tiếp (thông qua Nest).

Hàm trong câu hỏi là {##&@@#,1//.x_/;x==Last@#||#~Count~x==#[[x]]->x+1}&, lấy một danh sách một phần các giá trị chuỗi (về cơ bản ##&@@#) và nối thêm giá trị tiếp theo vào nó. Giá trị tiếp theo được tính bằng cách bắt đầu với x=1, sau đó liên tục thay thế xbởi x+1chừng nào điều kiện x==Last@#||#~Count~x==#[[x]]được đáp ứng-nói cách khác, nếu một trong hai xlà yếu tố trước đó, nếu không xlà đã có trong danh sách chính xác số lần. Hàm này phát sinh một số lỗi, vì (ví dụ) chúng ta không nên gọi xphần tử thứ của danh sách ban đầu {}; tuy nhiên, các giá trị đều đúng


4

Python 2, 99 86 byte

Cảm ơn @Dennis vì một số cải tiến với tổng số 13 byte!

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]

Chương trình tiến hành khá ngây thơ: Nó theo dõi danh sách các giá trị mà nó đã xác định cho đến nay và dường như sẽ nối thêm giá trị tiếp theo. Nó cố gắng nối thêm 1vào cuối danh sách nếu có thể; nếu không, sau đó nó cố gắng 2và cứ thế cho đến khi một cái gì đó được cho phép.

Bây giờ, chúng ta bắt đầu bằng cách gieo hạt các kết quả cho 1,2,3được 1,2,3. Điều này được thực hiện để tránh bất kỳ vấn đề nào với danh sách các giá trị đã được tính toán quá ngắn: Tôi phỏng đoán rằng nếu nít nhất 4thì a(n)nó hoàn toàn ít hơn n. (Trong chương trình này, s[n]bằng với a(n). Danh sách của chúng tôi thực sự được khởi tạo là [0,1,2,3]do các danh sách được tạo 0bằng Python. Vì vậy, ví dụ a(1)=s[1]=1, và a(2)=s[2]=2.)

Vì vậy, giả sử chúng tôi đang cố gắng xác định s[m], có nghĩa là danh sách của chúng tôi đã bao gồm s[0], s[1], ..., s[m-1]. Chúng ta sẽ bắt đầu t=1và cố gắng thiết lập s[m]=1. Khi nó không hoạt động, chúng tôi đi đến t=2và cố gắng thiết lập s[m]=2. Mỗi lần chúng tôi tăng lên t, chúng tôi sẽ kiểm tra xem s.count(t)==s[t]... nhưng phía bên tay phải sẽ không gây ra lỗi miễn là chúng tôi không bao giờ phải tăng cao như vậy t=m. Phỏng đoán nói rằng chúng ta không bao giờ phải làm thế, vì giá trị đầu tiên chúng ta tính toán thực sự là s[4].

Việc thực hiện này tính toán thêm 3 giá trị của chuỗi hơn mức cần thiết. Ví dụ: nếu n8, nó sẽ tính toán s[11]trước khi trả về giá trị của s[8].

Tôi rất vui khi thấy một bằng chứng về sự phỏng đoán. Tôi tin rằng nó có thể được chứng minh bằng cảm ứng (mạnh?).

Chỉnh sửa: Đây là một bằng chứng của phỏng đoán . Chúng tôi thực sự chứng minh một hình thức mạnh mẽ hơn một chút của tuyên bố, vì nó không liên quan đến công việc làm thêm.

Định lý: Đối với tất cả nlớn hơn hoặc bằng 4, số hạng a(n)nhỏ hơn hoặc bằng (n-2).

Bằng chứng (bởi cảm ứng mạnh): (Cơ sở n=4): Câu lệnh đúng với n=4, kể từ đó a(4) = 2 = 4-2.

Bây giờ giả định a(k)là ít hơn hoặc bằng k-2với tất cả ktừ 4thông qua n, bao gồm (và giả định nlà ít nhất 4). Đặc biệt, điều này có nghĩa là tất cả các điều khoản trước đó của chuỗi là nhiều nhất (n-2). Chúng tôi cần chứng minh rằng a(n+1)sẽ có nhiều nhất (n-1). Bây giờ, theo định nghĩa, a(n)là số nguyên dương nhỏ nhất không vi phạm bất kỳ điều kiện nào, vì vậy chúng ta chỉ cần chứng minh rằng giá trị (n-1)sẽ không vi phạm bất kỳ điều kiện nào.

Giá trị (n-1)sẽ không vi phạm điều kiện "không lặp lại liên tiếp", bởi vì theo giả thuyết cảm ứng, mục nhập trước đó nhiều nhất là (n-2). Và nó sẽ không vi phạm điều kiện " a(m)là số lần mxuất hiện", trừ khi (n-1)đã đạt đến số a(n-1)lần. Nhưng theo giả định cảm ứng mạnh, (n-1)trước đây đã đạt được 0thời gian và a(n-1)không bằng 0a(m)nó là tích cực cho tất cả m.

Do đó a(n+1)là ít hơn hoặc bằng n-1 = (n+1)-2, như mong muốn. QED.


3

Thạch , 17 byte

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

Ba trường hợp thử nghiệm cuối cùng là quá nhiều cho TIO. Tôi đã xác minh 10001257 tại địa phương.

Hãy thử trực tuyến! hoặc xác minh 100 điều khoản đầu tiên .

Làm thế nào nó hoạt động

⁸Ç¡Ṫ          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.

3

Python 2 , 77 74 byte

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)

Đây là một triển khai đệ quy của thuật toán @ mathmandan .

Việc thực hiện là O (mất trí) : đầu vào 9 mất 2 giây cục bộ, đầu vào 10 52 giây và đầu vào 11 17 phút và 28 giây. Tuy nhiên, nếu được khai báo là một hàm thông thường chứ không phải là lambda, việc ghi nhớ có thể được sử dụng để xác minh các trường hợp kiểm tra.

Hãy thử trực tuyến!

Lưu ý rằng ngay cả khi ghi nhớ, TIO không thể tính f (1257) hoặc f (10000) (cả hai được xác minh cục bộ).


2

05AB1E , 32 31 byte

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

Hãy thử trực tuyến!

Giải trình

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

Về mặt kỹ thuật, chúng tôi đang trong vòng lặp Gkhi chúng tôi thêm N vào danh sách toàn cầu, nhưng tất cả các vòng lặp trong 05AB1E sử dụng cùng một biến N là chỉ mục, vì vậy vòng lặp bên trong [...]đã ghi đè lên NG nghĩa của chúng tôi có thể thêm nó bên ngoài vòng lặp.

Các vấn đề với các vòng lặp lồng nhau và các điều kiện ngăn cản chúng ta thực hiện điều này bên trong vòng lặp.


2

Befunge, 141 136 byte

<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

Hãy thử trực tuyến!

Do các giới hạn bộ nhớ của Befunge, việc theo dõi tất cả các mục nhập trước đó trong chuỗi là không thực tế, vì vậy giải pháp này sử dụng thuật toán có dung lượng bộ nhớ thấp hơn để tính toán các giá trị trực tiếp hơn.

Điều đó nói rằng, chúng tôi vẫn bị giới hạn bởi kích thước ô, trong trình thông dịch tham chiếu Befunge-93 là giá trị 8 bit đã ký, vì vậy số chẵn được hỗ trợ cao nhất trong chuỗi là A(1876) = 126và số lẻ được hỗ trợ cao nhất là A(1915) = 127.

Nếu bạn muốn kiểm tra các giá trị lớn hơn, bạn sẽ cần sử dụng trình thông dịch có kích thước ô lớn hơn. Điều đó sẽ bao gồm hầu hết các triển khai Befunge-98 ( Hãy thử trực tuyến! ).


0

Python 2, 117 byte

Meh. Không phải là ngắn. Các giải pháp lặp đơn giản.

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]

Dùng thử trực tuyến

Đây là một nỗ lực thực sự tồi tệ đối với một giải pháp đệ quy (129 byte):

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)

Đã sửa. Tôi nghĩ rằng tôi có thể sử dụng -1thay vì n-1để lưu một byte, tôi đoán là không.
mbomb007
Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.