Ecco come viene definita la sequenza di Kolakoski (OEIS A000002 ):

La sequenza di Kolakoski è una sequenza che contiene 1e 2, e il nth elemento della sequenza è la lunghezza del nth gruppo di elementi uguali (corsa) nella sequenza stessa. I primi 20 termini della sequenza e le rispettive lunghezze sono:

1 2 2 1 1 2 1 2 2 1 2 2 1 1 2 1 1 2 2 1
- --- --- - - --- - --- --- - --- --- -
1  2   2  1 1  2  1  2   2  1  2   2  1

In sostanza, la lunghezza dei gruppi di elementi uguali della sequenza di Kolakoski è la stessa sequenza di Kolakoski.

Fin qui tutto bene, ma questo perché dovremmo limitarci a 1e 2? Non lo faremo! Dati due input, una matrice di numeri interi positivi Ae un numero intero N, restituiscono i primi Ntermini della sequenza simile a Kolakoski definita scorrendo ciclicamente A. Per comprenderlo meglio, ecco un esempio funzionante con le lunghezze dei gruppi appena aggiunti tra parentesi:

A = [2, 3, 1]
N = 25

2: [[2], 2 ]
3: [ 2 ,[2], 3 , 3 ]
1: [ 2 , 2 ,[3], 3 , 1 , 1 , 1 ]
2: [ 2 , 2 , 3 ,[3], 1 , 1 , 1 , 2 , 2 , 2 ]
3: [ 2 , 2 , 3 , 3 ,[1], 1 , 1 , 2 , 2 , 2 , 3 ]
1: [ 2 , 2 , 3 , 3 , 1 ,[1], 1 , 2 , 2 , 2 , 3 , 1 ]
2: [ 2 , 2 , 3 , 3 , 1 , 1 ,[1], 2 , 2 , 2 , 3 , 1 , 2 ]
3: [ 2 , 2 , 3 , 3 , 1 , 1 , 1 ,[2], 2 , 2 , 3 , 1 , 2 , 3 , 3 ]
1: [ 2 , 2 , 3 , 3 , 1 , 1 , 1 , 2 ,[2], 2 , 3 , 1 , 2 , 3 , 3 , 1 , 1 ]
2: [ 2 , 2 , 3 , 3 , 1 , 1 , 1 , 2 , 2 ,[2], 3 , 1 , 2 , 3 , 3 , 1 , 1 , 2 , 2 ]
3: [ 2 , 2 , 3 , 3 , 1 , 1 , 1 , 2 , 2 , 2 ,[3], 1 , 2 , 3 , 3 , 1 , 1 , 2 , 2 , 3 , 3 , 3 ]
1: [ 2 , 2 , 3 , 3 , 1 , 1 , 1 , 2 , 2 , 2 , 3 ,[1], 2 , 3 , 3 , 1 , 1 , 2 , 2 , 3 , 3 , 3 , 1 ]
2: [ 2 , 2 , 3 , 3 , 1 , 1 , 1 , 2 , 2 , 2 , 3 , 1 ,[2], 3 , 3 , 1 , 1 , 2 , 2 , 3 , 3 , 3 , 1 , 2 , 2 ]
C: [ 2 , 2 , 3 , 3 , 1 , 1 , 1 , 2 , 2 , 2 , 3 , 1 , 2 , 3 , 3 , 1 , 1 , 2 , 2 , 3 , 3 , 3 , 1 , 2 , 2 ]

Ecco un altro esempio lavorato con un leader 1:

A = [1, 2, 3]
N = 10

1: [[1]]
2: [ 1 ,[2], 2 ]
3: [ 1 , 2 ,[2], 3 , 3 ]
1: [ 1 , 2 , 2 ,[3], 3 , 1 , 1 , 1 ]
2: [ 1 , 2 , 2 , 3 ,[3], 1 , 1 , 1 , 2 , 2 , 2 ]
C: [ 1 , 2 , 2 , 3 , 3 , 1 , 1 , 1 , 2 , 2 ]

Come puoi vedere sopra, il risultato finale è stato tagliato in N = 10elementi. L' nelemento th dovrebbe essere quanto è lungo il ngruppo degli elementi uguali, anche se l'elemento stesso appartiene al gruppo a cui si riferisce. Come nel caso precedente, il primo si 1riferisce al primo di questi gruppi che è proprio quello 1, e il primo si 2riferisce al secondo di questi gruppi, che inizia con esso.

Regole

• Si può presumere che Anon avranno mai due o più elementi uguali consecutivi. Apuò contenere un numero intero più di una volta, ma il primo e l'ultimo elemento non saranno uguali e Aconterranno almeno 2 elementi (ad esempio [1, 2, 2, 3], [2, 4, 3, 1, 2]e [3]non verranno forniti). Questo perché se ci fossero elementi uguali consecutivi, il risultato finale sarebbe stato un prefisso non valido per tale sequenza.
• Si può presumere Ache contenga solo numeri interi positivi (poiché una sequenza del genere non sarebbe altrimenti definita).
• Si può presumere che Nsia un numero intero non negativo ( N >= 0).
• Non puoi restituire più termini di quelli richiesti.
• L'uso di una qualsiasi delle lacune standard è severamente vietato.
• È possibile utilizzare qualsiasi metodo I / O ragionevole .
• La tua risposta non deve funzionare oltre i limiti del linguaggio naturale, ma in teoria il tuo algoritmo dovrebbe funzionare per input e interi arbitrariamente grandi .
• Questo è code-golf , quindi vince la risposta più breve.

Casi test

[5, 1, 2], 0 -> []
[2, 3, 1], 25 -> [2, 2, 3, 3, 1, 1, 1, 2, 2, 2, 3, 1, 2, 3, 3, 1, 1, 2, 2, 3, 3, 3, 1, 2, 2]
[1, 2, 3], 10 -> [1, 2, 2, 3, 3, 1, 1, 1, 2, 2]
[1, 2], 20 -> [1, 2, 2, 1, 1, 2, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 1, 2, 2, 1]
[1, 3], 20 -> [1, 3, 3, 3, 1, 1, 1, 3, 3, 3, 1, 3, 1, 3, 3, 3, 1, 1, 1, 3]
[2, 3], 50 -> [2, 2, 3, 3, 2, 2, 2, 3, 3, 3, 2, 2, 3, 3, 2, 2, 3, 3, 3, 2, 2, 2, 3, 3, 3, 2, 2, 3, 3, 2, 2, 2, 3, 3, 3, 2, 2, 3, 3, 2, 2, 2, 3, 3, 3, 2, 2, 2, 3, 3]
[7, 4], 99 -> [7, 7, 7, 7, 7, 7, 7, 4, 4, 4, 4, 4, 4, 4, 7, 7, 7, 7, 7, 7, 7, 4, 4, 4, 4, 4, 4, 4, 7, 7, 7, 7, 7, 7, 7, 4, 4, 4, 4, 4, 4, 4, 7, 7, 7, 7, 7, 7, 7, 4, 4, 4, 4, 7, 7, 7, 7, 4, 4, 4, 4, 7, 7, 7, 7, 4, 4, 4, 4, 7, 7, 7, 7, 4, 4, 4, 4, 7, 7, 7, 7, 7, 7, 7, 4, 4, 4, 4, 4, 4, 4, 7, 7, 7, 7, 7, 7, 7, 4]
[1, 2, 3], 5 -> [1, 2, 2, 3, 3]
[2, 1, 3, 1], 2 -> [2, 2]
[1, 3, 5], 2 -> [1, 3]
[2, 3, 2, 4], 10 -> [2, 2, 3, 3, 2, 2, 2, 4, 4, 4]

buccia , 8 byte

Ṡωȯ↑⁰`Ṙ¢

Prende prima la lunghezza, quindi l'elenco. Provalo online!

Spiegazione

Ṡωȯ↑⁰`Ṙ¢  Inputs: n=9 and x=[2,1,3]
Ṡωȯ       Apply the following function to x until a fixed point is reached:
           Argument is a list, say y=[2,2,1,3,3,3]
       ¢   Cycle x: [2,1,3,2,1,3..
     `Ṙ    Replicate to lengths in y: [2,2,1,1,3,2,2,2,1,1,1,3,3,3]
   ↑⁰      Take first n elements: [2,2,1,1,3,2,2,2,1]
          Final result is [2,2,1,1,3,2,1,1,1], print implicitly.

Pyth, 14 byte

u<s*V]M*QlGGvz

Provalo online: dimostrazione o suite di test

Spiegazione:

u                 start with G = input array
       *QlG       repeat input array
     ]M           put every element into its own list
   *V      G      repeat every list vectorized by the counts in G
  s               flatten
 <          vz    take the first (second input line) numbers
                  and assign them to G until you reach fixed point

Java 8, 151 + 19 119 115 byte

a->n->{int c=0,l[]=new int[n],i=0,j;for(;i<n;i++)for(j=0;j<(c==i?a[i]:l[i])&c<n;j++)l[c++]=a[i%a.length];return l;}

Provalo online!

R , 120 114 108 byte

-6 byte grazie a plannapus

function(A,N){i=inverse.rle
w=length
a=rle(A)
while(w(a$l)<N){a[[1]]=i(a)
a[[2]]=rep(A,l=w(a$l))}
i(a)[0:N]}

Provalo online!

Funzione anonima; inverte successivamente l'RLE, sostituendo le lunghezze a[[1]]con l'RLE invertito e i valori a[[2]]con Areplicati a una lunghezza uguale a quella di a$l.

Haskell , 68 byte

Mille grazie a Laikoni e Flawr per il loro aiuto nel debug e nel golf questa risposta nella chat room di PPCG Haskell, Of Monads and Men . Suggerimenti di golf benvenuti! Provalo online!

(.f).take
f a@(z:_)=(z<$[1..z])++do i<-[1..];cycle a!!i<$[1..f a!!i]

La prima riga è una funzione anonima. La seconda riga è la comprensione infinita dell'elenco che produce la nostra sequenza simile a Kolakoski.

Spiegazione

Innanzitutto, definiamo zil capo di acona@(z:_) . Quindi inizializziamo la sequenza con (z<$[1..z]).

Quindi, da allora in 1poi, do i<-[1..]aggiungiamo quanto segue alla sequenza :, cycle a!!i<$[1..f a!!i]che è il i-th membro di a(ciclato indefinitamente) aggiuntof a!!i .

Infine, la funzione anonima prende semplicemente i primi ntermini della nostra sequenza simile a Kolaskoski.

Python 2 , 123 byte

x,y=input()
k=x[0]
t,j=[],0
if k==1:t,j=[k]+x[1]*[x[1]],2
while len(t)<y:t+=(j and t[j]or k)*[x[j%len(x)]];j+=1
print t[:y]

Provalo online!