Giriş

Gijswijt dizisi ( A090822 ) gerçekten gerçekten, gerçekten yavaş. Örneklemek gerekirse:

• İlk 3, 9. dönemde (tamam) görünür.
• İlk 4, 220. dönemde (çok uzakta, ancak uygulanabilir) görünür.
• İlk 5 (yaklaşık) 10 ^ (10 ^ 23). Terimde (sadece hayır) görünür .
• Kimse ilk 6'nın nerede olduğunu bile bilmiyor ...

  2 ^ (2 ^ (3 ^ (4 ^ 5))) terim.

İki basamaklı bir sayıyla uğraşmak zorunda kalmayacağınızı varsayabilirsiniz.

Dizi şöyle üretilir:

1. İlk terim 1'dir.
2. Bundan sonraki her terim, önceki yinelenen "blokların" miktarıdır (birden fazla yinelenen "blok" varsa, en fazla yinelenen blok kullanılır).

Açıklığa kavuşturmak için, ilk birkaç terim burada.

1 -> 1, 1(bir yinelenen blok ( 1), böylece kaydedilen rakam 1)

1, 1 -> 1, 1, 2(iki yinelenen blok ( 1), böylece kaydedilen rakam 2)

1, 1, 2 -> 1, 1, 2, 1(bir yinelenen blok ( 2veya 1, 1, 2), böylece kaydedilen rakam 1)

1, 1, 2, 1 -> 1, 1, 2, 1, 1 (kaptın bu işi)

1, 1, 2, 1, 1 -> 1, 1, 2, 1, 1, 2

1, 1, 2, 1, 1, 2 -> 1, 1, 2, 1, 1, 2, 2(iki yinelenen blok ( 1, 1, 2), böylece kaydedilen rakam 2)

Görev

Göreviniz, soruda belirtildiği gibi, Gijswijt dizisinin n hanesini oluşturmaktır.

Talimatlar

• Giriş bir tamsayı olacaktır n.
• Kodunuz rakamları herhangi bir biçimde (bir liste, birden çok çıktı vb.) Çıktılayabilir.

Bu kod golf, bayt en kısa kod kazanır.

Pyth, 25 22 21 bayt

t_u+eSmtfxG*Td1._GGQN

OP, yalnızca tek haneli sayıları ele almamız gerektiğini doğruladı. Bu listenin bir rakam dizesi olarak saklanmasına izin verdi. -> Kaydedilen 3 bayt

Çevrimiçi deneyin: Gösteri

Açıklama:

t_u+...GQN      implicit: Q = input number
         N      start with the string G = '"'
  u     Q       do the following Q times:
    ...            generate the next number
   +   G           and prepend it to G
 _              print reversed string at the end
t               remove the first char (the '"')

Ve bir sonraki sayıyı nasıl üreteceğim:

eSmtfxG*Td1._G
           ._G    generate all prefixes of G
  m               map each prefix d to:
    f     1          find the first number T >= 1, so that:
       *Td              d repeated T times
     xG                 occurs at the beginning of G
 S                  sort all numbers
e                   take the last one (maximum)   

Listeli 21 bayt

_u+eSmhhrcGd8SlGGtQ]1

Çevrimiçi deneyin: Gösteri

Martin ve Peter'ın aynı fikirlerini kullanır. Her adımda ipi uzunluk 1, uzunluk 2, parçalara böldüm ... Sonra onları uzunluk-uzunluk olarak kodladım ve bir sonraki sayı olarak maksimum çalışmayı kullandım.

Dizeli 20 bayt

t_u+eSmhhrcGd8SlGGQN

Çevrimiçi deneyin: Gösteri

Yukarıdaki iki kodun fikirlerini birleştirir.

CJam, 33 31 30 27 bayt

1 bayt kaydettiği için Peter Taylor'a teşekkürler.

1sri({),:)1$W%f/:e`$W=sc+}

Burada test edin.

açıklama

1s      e# Initialise the sequence as "1".
ri(     e# Read input N and decrement.
{       e# For each I from 0 to N-1...
  )     e#   Increment to get I from 1 to N.
  ,     e#   Turn into a range [0 1 ... I-1].
  :)    e#   Increment each element to get [1 2 ... I].
  1$    e#   Copy sequence so far.
  W%    e#   Reverse the copy.
  f/    e#   For each element x in [1 2 ... I], split the (reversed) sequence
        e#   into (non-overlapping) chunks of length x. These are the potentially
        e#   repeated blocks we're looking for. We now want to find the splitting
        e#   which starts with the largest number of equal blocks.
  :e`   e#   To do that, we run-length encode each list blocks.
  $     e#   Then we sort the list of run-length encoded splittings, which primarily
        e#   sorts them by the length of the first run.
  W=    e#   We extract the last splitting which starts with the longest run.
  sc    e#   And then we extract the length of the first run by flattening
        e#   the list into a string and retrieving the first character.
  +     e#   This is the new element of the sequence, so we append it.
}/

CJam ( 30 29 27 24 bayt)

'1ri{{)W$W%/e`sc}%$W>+}/

Çevrimiçi demo

Bu Martin ile ortak bir çaba.

• e`Tekrarları tanımlamak için çalışma uzunluğu kodlamasının ( ) akıllı kullanımı Martin
• Kullanımı da W$ yığın yönetimini kolaylaştırmak için
• $W>+Aşağıdaki diseksiyonda açıklandığı gibi, özel kasa kullanarak birkaç arttırma / azaltma işlemini ortadan kaldırdım

İlk 30 bayt yaklaşımım:

1ari{,1$f{W%0+_@)</{}#}$W>+}/`

Çevrimiçi demo

teşrih

1a        e# Special-case the first term
ri{       e# Read int n and iterate for i=0 to n-1
  ,1$f{   e#   Iterate for j=0 to i-1 a map with extra parameter of the sequence so far
    W%0+  e#     Reverse and append 0 to ensure a non-trivial non-repeating tail
    _@)</ e#     Take the first j+1 elements and split around them
    {}#   e#     Find the index of the first non-empty part from the split
          e#     That's equivalent to the number of times the initial word repeats
  }
  $W>+    e#   Add the maximal value to the sequence
          e#   NB Special case: if i=0 then we're taking the last term of an empty array
          e#   and nothing is appended - hence the 1a at the start of the program
}/
`         e# Format for pretty printing

Haskell, 97 bayt

f 1=[1]
f n|x<-f$n-1=last[k|k<-[1..n],p<-[1..n],k*p<n,take(k*p)x==([1..k]>>take p x)]:x
reverse.f

Üçüncü satır, bir tamsayı alan ve bir tamsayı listesi döndüren anonim bir işlevi tanımlar. Hareket halinde görün.

açıklama

Yardımcı fonksiyon f, önceki sekansın tekrarlanan bir blokla başlayıp başlamadığını tekrar tekrar kontrol ederek sekansı tersine yapılandırır. ktekrar sayısıdır pve bloğun uzunluğudur.

f 1=[1]                                   -- Base case: return [1]
f n|x<-f$n-1=                             -- Recursive case; bind f(n-1) to x.
  last[k|k<-[1..n],                       -- Find the greatest element k of [1..n] such that
  p<-[1..n],                              -- there exists a block length p such that
  k*p<n,                                  -- k*p is at most the length of x, and
  take(k*p)x                              -- the prefix of x of length p*k
    ==                                    -- is equal to
  ([1..k]>>take p x)                      -- the prefix of length p repeated k times.
  ]:x                                     -- Insert that k to x, and return the result.
reverse.f                                 -- Composition of reverse and f.

Pyth, 41 38 bayt

J]1VSQ=J+h.MZmh+fn@c+J0dT<JdSNZSNJ;P_J

Çevrimiçi deneyin!

Retina , 66 60 bayt

+1`((\d+)?(?<1>\2)*(?<!\3(?>(?<-1>\3)*)(?!.*\2)(.+)))!
$1$#1

Girdi, kullanarak tekli bir tam sayıdır ! basamak olarak (ancak sayısal olmayan herhangi bir karakterle değiştirilebilir). Çıktı basitçe bir rakam dizisidir.

Çevrimiçi deneyin! (Alternatif olarak, kolaylık sağlamak için ondalık girdi alan bir sürüm. )

Test amacıyla, bu, giriş 220'nin bir dakikadan kısa sürede test edilmesine izin veren küçük bir modifikasyonla çok hızlandırılabilir :

+1`((\d+)?(?<1>\2)*(?=!)(?<!\3(?>(?<-1>\3)*)(?!.*\2)(.+)))!
$1$#1

Çevrimiçi deneyin! ( Ondalık sürüm. )

Daha büyük sayıları test etmek istiyorsanız, en iyisi onu büyük bir girdi beslemek ve ilkinden :sonra bir koymaktır +. Bu, Retina'nın yeni bir basamak hesaplamayı bitirdiğinde (tüm rakamlar tek tek olacak şekilde) geçerli diziyi yazdırmasını sağlar.

açıklama

Çözüm, sonuç değişmeyi durdurana kadar girişe tekrar tekrar uygulanan tek bir normal ifade ikamesinden oluşur, bu durumda normal ifade artık eşleşmediği için olur. +Başında bu döngü tanıtır. Bu 1, Retina'ya yalnızca ilk eşleşmeyi değiştirmesini söyleyen bir sınırdır (bu sadece ilk yineleme için geçerlidir). Her yinelemede, sahne bir !(soldan) dizinin sonraki basamağıyla değiştirilir.

Her zamanki gibi, dengeleme gruplarında bir astar gerekiyorsa, sizi SO cevabına yönlendiriyorum .

İşte normal ifadenin açıklamalı sürümü. Hedefin, gruptaki tekrarlanan blokların maksimum sayısını yakalamak olduğunu unutmayın 1.

(                 # Group 1, this will contain some repeated block at the end
                  # of the existing sequence. We mainly need this so we can
                  # write it back in the substitution. We're also abusing it
                  # for the actual counting but I'll explain that below.
  (\d+)?          # If possible (that is except on the first iteration) capture
                  # one of more digits into group 2. This is a candidate block
                  # which we're checking for maximum repetitions. Note that this
                  # will match the *first* occurrence of the block.
  (?<1>\2)*       # Now we capture as many copies of that block as possible
                  # into group 1. The reason we use group 1 is that this captures
                  # one repetition less than there is in total (because the first
                  # repetition is group 2 itself). Together with the outer
                  # (unrelated) capture of the actual group one, we fix this
                  # off-by-one error. More importantly, this additional capture
                  # from the outer group isn't added until later, such that the
                  # lookbehind which comes next doesn't see it yet, which is
                  # actually very useful.
                  # Before we go into the lookbehind note that at the end of the
                  # regex there's a '!' to ensure that we can actually reach the
                  # end of the string with this repetition of blocks. While this 
                  # isn't actually checked until later, we can essentially assume
                  # that the lookbehind is only relevant if we've actually counted
                  # repetitions of a block at the end of the current sequence.

  (?<!            # We now use a lookbehind to ensure that this is actually the
                  # largest number of repetitions possible. We do this by ensuring
                  # that there is no shorter block which can be matched more
                  # often from the end than the current one. The first time this
                  # is true (since, due to the regex engine's backtracking rules,
                  # we start from longer blocks and move to shorter blocks later),
                  # we know we've found the maximum number of repetitions.
                  # Remember that lookbehinds are matched right-to-left, so
                  # you should read the explanation of the lookbehind from
                  # bottom to top.
    \3            # Try to match *another* occurrence of block 3. If this works,
                  # then this block can be used more often than the current one
                  # and we haven't found the maximum number of repetitions yet.
    (?>           # An atomic group to ensure that we're actually using up all
                  # repetitions from group 1, and don't backtrack.
      (?<-1>\3)*  # For each repetition in group 1, try to match block 3 again.
    )
    (?!.*\2)      # We ensure that this block isn't longer than the candidate
                  # block, by checking that the candidate block doesn't appear
                  # right of it.
    (.+)          # We capture a block from the end into group 3.
  )               # Lookbehind explanation starts here. Read upwards.
)
!                 # As I said above, this ensures that our block actually reaches
                  # the end of the string.

Son olarak, tüm bunlar yapıldıktan sonra , gruptaki maksimum tekrar sayısına karşılık gelen yakalama sayısını yanı sıra $1(böylece silinerek !) geri yazıyoruz $#1.

Ruby, 84 bayt

Retina yanıtı, bir dizideki sekansları bir şekilde saymak yerine en iyi sekansı bulmak için regex tabanlı bir çözüm yapmam için bana ilham verdi, ancak daha az dehayla (nicelleştiricilere sahip negatif bakışlar Ruby'de izin verilmiyor gibi görünüyor, bu yüzden şüpheliyim Retina'nın cevabını doğrudan yine de taşıyabilirim)

->n{s='';n.times{s+=(1..n).map{|i|s=~/(\d{#{i}})\1+$/?$&.size/i: 1}.max.to_s};s[-1]}

Zaten oluşturulan dizisi göz önüne alındığında s, her şey bitti eşleyen igelen 1etmek s.length( nçünkü bayt kaydetmek için bu durumda kullanılan n>=s.length) ve daha sonra yardım olarak hesaplanması uzunluğunda bir alt dizisinin tekrar sayısını bu regex kullanır i:

/(.{#{i}})\1+$/
/(                 # Assign the following to group 1
  .{#{i}}          # Match `i` number of characters
         )         # End group 1
          \1+      # Match 1 or more repetitions of group 1
             $/    # Match the end of string

Bir eşleşme bu uzunluktaki bulunursa, bu verilen maç uzunluğu bölünerek tekrar sayısını hesaplar $&ile ialt dizisinin uzunluğu; hiçbir eşleşme bulunamazsa, olarak kabul edilir 1. İşlev daha sonra bu eşlemeden maksimum tekrar sayısını bulur ve bu sayıyı dizenin sonuna ekler.