É assim que a sequência de Kolakoski (OEIS A000002 ) é definida:

A sequência de Kolakoski é uma sequência que contém 1e 2, e o nth elemento da sequência é o comprimento do nth grupo de elementos iguais (execução) na própria sequência. Os primeiros 20 termos da sequência e os respectivos comprimentos são:

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

Essencialmente, os comprimentos dos grupos de elementos iguais da sequência Kolakoski é a própria sequência Kolakoski.

Tão longe, tão bom, mas que por que devemos nos restringir 1e 2? Nós não vamos! Dadas duas entradas, uma matriz de números inteiros positivos Ae um número inteiro N, retornam os primeiros Ntermos da sequência tipo Kolakoski definida por meio de ciclo A. Para entender melhor, aqui está um exemplo trabalhado com os comprimentos dos grupos recém-adicionados entre colchetes:

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 ]

Aqui está outro exemplo trabalhado com um líder 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 ]

Como você pode ver acima, o resultado final foi cortado em N = 10elementos. O nelemento th deve ter a duração do grupo nth de elementos iguais, mesmo que o próprio elemento pertença ao grupo ao qual se refere. Como no caso acima, o primeiro 1se refere ao primeiro grupo desse tipo que é exatamente isso 1, e o primeiro 2se refere ao segundo grupo desse tipo, que começa com ele.

Regras

• Você pode assumir que Anunca terá dois ou mais elementos iguais consecutivos. Apode conter um número inteiro mais de uma vez, mas o primeiro e o último elementos não serão iguais e Aconterão pelo menos 2 elementos (por exemplo [1, 2, 2, 3], [2, 4, 3, 1, 2]e [3]não serão fornecidos). Isso porque se houvesse elementos iguais consecutivos, o resultado final teria sido um prefixo inválido para essa sequência.
• Você pode presumir que Acontém apenas números inteiros positivos (pois, de outra forma, uma sequência não seria definida).
• Você pode assumir que Né um número inteiro não negativo ( N >= 0).
• Você não pode retornar mais termos do que o solicitado.
• É estritamente proibido usar qualquer uma das brechas padrão .
• Você pode usar qualquer método de I / O razoável .
• Sua resposta não precisa ir além dos limites da linguagem natural, mas em teoria seu algoritmo deve funcionar para entradas e números arbitrariamente grandes .
• Isso é código-golfe , então a resposta mais curta vence.

Casos de teste

[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]

Casca , 8 bytes

Ṡωȯ↑⁰`Ṙ¢

Toma primeiro o comprimento, depois a lista. Experimente online!

Explicação

Ṡωȯ↑⁰`Ṙ¢  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.

Pitão, 14 bytes

u<s*V]M*QlGGvz

Experimente online: demonstração ou teste

Explicação:

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 bytes

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;}

Experimente online!

R , 120 114 108 bytes

-6 bytes graças ao 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]}

Experimente online!

Função anônima; sucessivamente inverte a RLE, substituindo os comprimentos a[[1]]com o RLE invertido, e os valores a[[2]]com Areplicados para um comprimento igual ao da a$l.

Haskell , 68 bytes

Muito obrigado a Laikoni e flawr por sua ajuda na depuração e golfe desta resposta na sala de chat do PPCG Haskell, Of Monads and Men . Sugestões de golfe são bem-vindas! Experimente online!

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

A primeira linha é uma função anônima. A segunda linha é a compreensão infinita da lista que produz nossa sequência tipo Kolakoski.

Explicação

Primeiro, definimos zcomo o chefe de acom a@(z:_). Em seguida, inicializamos a sequência com(z<$[1..z]) .

A partir 1de então, do i<-[1..]anexamos o seguinte à sequência :, cycle a!!i<$[1..f a!!i]que é o i-ésimo membro dos tempos aanexados (ciclados indefinidamente) f a!!i.

Por fim, a função anônima simplesmente aceita os primeiros ntermos de nossa sequência semelhante a Kolaskoski.

Python 2 , 123 bytes

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]

Experimente online!