OEIS bir varyasyonunu sahip üzerinde (A111439) Golomb sekansının . Golomb'un dizisinde olduğu gibi dizide A(n)ne sıklıkta ngöründüğünü açıklar . Ancak ek olarak, iki ardışık sayı aynı olamaz. Diziyi oluştururken A(n), her zaman bu iki özelliği ihlal etmeyen en küçük pozitif tam sayı olarak seçilir. İzin verilmeyen ardışık aynı sayılar nedeniyle, dizi büyüdükçe hafifçe yukarı ve aşağı sallanır. İşte ilk 100 terim:

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

İlk 10.000 sayının tam listesi OEIS'te bulunabilir .

Buradaki zorluk A(n)verilen hesaplayan bir program veya fonksiyon yazmaktır n. nolan 1kendini açıklayan özelliği çalıştığından emin olmak için tabanlı.

kurallar

Bir program veya fonksiyon yazabilir ve standart girdi alma ve çıktı alma yöntemlerimizden herhangi birini kullanabilirsiniz .

Herhangi bir programlama dilini kullanabilirsiniz , ancak bu boşlukların varsayılan olarak yasak olduğunu unutmayın .

Bu kod-golf , yani en kısa geçerli cevap - bayt olarak ölçülen - kazanır.

Test Kılıfları

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

Haskell , 67 bayt

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

Bir fonksiyon tanımlar f. Çevrimiçi deneyin! Çok yavaş, f 15TIO'da hesaplama zamanları doldu.

açıklama

Sadece tanımla devam edin: her aşamada, nkısıtlamaları karşılayan en küçük pozitif sayıyı seçin (önceki girişe eşit değil ve f nhenüz zamanlamadı).

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 bayt

Martin Ender'e benim için ekstra-1 bayt bulduğu için teşekkürler!

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

Adsız işlev n, giriş olarak pozitif bir tamsayı alarak pozitif bir tamsayı döndürür. nBu dizinin ilk elemanlarının tam listesini yaparız , sonra Lastelemanı alırız. Liste, boş listeyle başlayarak {}ve nbir sırada (üzerinden Nest) fonksiyon zamanları ile çalıştırılarak oluşturulur .

Söz konusu fonksiyon, {##&@@#,1//.x_/;x==Last@#||#~Count~x==#[[x]]->x+1}&kısmi bir sıra değer listesi (esas olarak ##&@@#) alır ve bir sonraki değeri buna ekler. Bir sonraki değer, başlayarak x=1, ardından koşul yerine xgetirildiği x+1sürece art arda değiştirilerek hesaplanır x==Last@#||#~Count~x==#[[x]]- başka bir deyişle, ya xönceki öğe ise, ya da xzaten listede doğru sayıda varsa zaten. Bu işlev bazı hataları yayar, çünkü (örneğin) xilk listenin th öğesini çağırmamamız gerekir {}; ancak, değerlerin hepsi doğrudur.

Python 2, 99 86 bayt

Toplam 13 bayt olan çeşitli geliştirmeler için @Dennis'e teşekkürler!

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]

Program oldukça naif bir şekilde ilerliyor: Şimdiye kadar belirlenen değerlerin listesini takip ediyor ve bir sonraki değeri eklemek istiyor. 1Yapabiliyorsa listenin sonuna bir a eklemeye çalışır ; eğer değilse, o zaman bir 2şeye izin verilinceye kadar böyle devam eder.

Şimdi, sonuçları ekim başlamak 1,2,3olmaya 1,2,3. Ben: Bu çok kısa olduğuna zaten hesaplanmış değerlerin listesini içeren herhangi bir sorun önlemek için yapılır varsayım eğer nen azından bir 4sonra a(n)kesinlikle daha az olduğunu n. (Bu programda s[n]eşittir a(n). Listemiz aslında başlatıldı [0,1,2,3]çünkü listeler 0Python'da -dekslenmiş durumda. Öyleyse a(1)=s[1]=1, ve a(2)=s[2]=2.)

Diyelim s[m]ki listemizin zaten içerdiği anlamını belirlemeye çalışıyoruz s[0], s[1], ..., s[m-1]. Biz de başlayacağız t=1ve set deneyin s[m]=1. Bu işe yaramazsa biz gider t=2ve ayarlamaya çalışırız s[m]=2. Her artış tyaptığımızda, kontrol edip edemeyeceğimizi kontrol ederiz s.count(t)==s[t]... ama sağ taraf asla asla olduğu kadar yükseğe çıkmamız gerekmediği sürece hata üretmez t=m. Tahmin, hesaplamamızın gerekmediğini, hesapladığımız ilk değerin aslında olduğunu söylüyor s[4].

Bu uygulama, dizinin gerekenden daha fazla 3 değerini hesaplar. Örneğin nolduğunu 8, içinden yukarı hesaplamak gerekir s[11]bunun değerini verir önce s[8].

Varsayımın bir kanıtını gördüğüm için mutlu olurum. Ben (güçlü?) İndüksiyonla kanıtlanabileceğine inanıyorum.

Düzenleme: İşte varsayım ispatı . Aslında ek bir çalışma gerektirmediğinden, ifadenin biraz daha güçlü bir biçimini kanıtlıyoruz.

Teorem:n Büyük veya eşittir büyük herkes için 4, terim a(n)büyük veya eşittir (n-2).

İspat (Strong Induction): (Base n=4): İfade n=4, o zamandan beri doğrudur a(4) = 2 = 4-2.

Şimdi varsayalım a(k)için eşit veya daha az olan k-2herkes için kgelen 4aracılığıyla ndahil, (ve farz nen azından bir 4). Özellikle, bu, dizinin önceki tüm terimlerinin en fazla olduğu anlamına gelir (n-2). a(n+1)Bunun en fazla olacağını göstermemiz gerek (n-1). Şimdi, tanım gereği, a(n)koşulların hiçbirini ihlal etmeyen en küçük pozitif tamsayıdır, bu nedenle değerin (n-1)koşulların hiçbirini ihlal etmeyeceğini göstermemiz gerekir .

Değer (n-1), “ardışık tekrarlar yok” koşulunu ihlal etmeyecektir, çünkü indüksiyon hipotezi ile önceki giriş en fazladı (n-2). Ve daha önce ulaşılmadıkça , "beliren a(m)sayıdır m" koşulunu ihlal etmeyecektir . Ama güçlü indüksiyon varsayımı ile, daha önce varılan kez ve eşit değildir çünkü herkes için olumludur .(n-1)a(n-1)(n-1)0a(n-1)0a(m)m

Bu nedenle a(n+1), n-1 = (n+1)-2istenildiği gibi , daha küçük veya ona eşittir . QED.

Jöle , 17 bayt

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

Son üç test vakası TIO için çok fazla. Yerel olarak 1000 ve 1257’yi doğruladım .

Çevrimiçi deneyin! veya ilk 100 terimi doğrulayın .

Nasıl çalışır

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

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)

Bu, @ mathmandan'ın algoritmasının özyinelemeli bir uygulamasıdır .

Uygulama O (delilik) : giriş 9 yerel olarak 2 saniye sürer, giriş 10 52 saniye ve giriş 11 17 dakika 28 saniye. Bununla birlikte, lambda yerine normal bir işlev olarak bildirilirse, test durumlarını doğrulamak için notlama kullanılabilir.

Çevrimiçi deneyin!

Notlandırmaya rağmen, TIO'nun f (1257) veya f (10000) (her ikisinin de yerel olarak doğrulandığı ) hesaplayamadığını unutmayın .

05AB1E , 32 31 bayt

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

Çevrimiçi deneyin!

açıklama

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

Biz döngü içinde teknik olarak Gbiz eklediğinizde N küresel listeye ancak 05AB1E tüm döngüler aynı değişken kullanmak N iç döngü böylece, endeks olarak [...]üzerine yazılır sahiptir N arasında Gbiz döngü dışında ekleyebilirsiniz anlamına gelir.

İç içe döngüler ve koşullayıcılarla ilgili sorunlar, bunu döngü içinde yapmamızı önler.

Befunge, 141 136 bayt

<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

Çevrimiçi deneyin!

Befunge'nin hafıza sınırlamaları nedeniyle, sıradaki önceki tüm girişleri takip etmek gerçekten pratik değildir, bu nedenle bu çözüm, değerleri daha doğrudan hesaplayan daha düşük bir hafıza ayak izine sahip bir algoritma kullanır.

Bununla birlikte, Befunge-93 referans yorumlayıcısının işaretli bir 8 bitlik değeri olan hücre büyüklüğü ile sınırlı olduğumuzu, bu nedenle dizideki A(1876) = 126desteklenen en yüksek çift sayısının olduğu ve desteklenen en yüksek tek sayı olduğu belirtildi A(1915) = 127.

Daha büyük değerleri test etmek istiyorsanız, daha büyük hücre boyutuna sahip bir tercüman kullanmanız gerekecektir. Bu, Befunge-98 uygulamalarının çoğunu içermelidir ( Çevrimiçi deneyin! ).

Python 2, 117 bayt

Meh. O kadar kısa değil. Basit yinelemeli çözüm.

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]

Çevrimiçi deneyin

Özyinelemeli bir çözümde çok kötü bir girişim: (129 bytes):

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)