So wird die Kolakoski-Sequenz (OEIS A000002 ) definiert:

Die Kolakoski-Folge ist eine Folge, die 1und enthält 2, und das ndritte Element der Folge ist die Länge der ndritten Gruppe gleicher Elemente (Lauf) in der Folge selbst. Die ersten 20 Terme der Sequenz und die jeweiligen Längen sind:

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

Im Wesentlichen ist die Länge der Gruppen gleicher Elemente der Kolakoski-Sequenz die Kolakoski-Sequenz selbst.

So weit, so gut, aber warum sollten wir uns auf 1und beschränken 2? Wir werden nicht! Bei zwei Eingaben, einer Reihe positiver Ganzzahlen Aund einer ganzen Zahl N, werden die ersten NTerme der Kolakoski-ähnlichen Sequenz zurückgegeben, die durch Durchlaufen definiert werden A. Um es besser zu verstehen, ist hier ein Beispiel mit den Längen der neu hinzugefügten Gruppen in Klammern:

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 ]

Hier ist ein weiteres Beispiel mit einem führenden 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 ]

Wie Sie oben sehen können, wurde das Endergebnis in N = 10Elemente geschnitten . Das nth-Element sollte sein, wie lang die nth-Equal-Element-Gruppe ist, auch wenn das Element selbst zu der Gruppe gehört, auf die es verweist. Wie im obigen Fall 1bezieht sich der erste auf die erste solche Gruppe, die genau das ist 1, und der erste 2bezieht sich auf die zweite solche Gruppe, die damit beginnt.

Regeln

• Sie können davon ausgehen, dass Aniemals zwei oder mehr aufeinanderfolgende gleiche Elemente vorhanden sind. Aenthalten kann , sobald eine ganze Zahl größer als, aber die ersten und letzten Elemente werden nicht gleich sein, und Amindestens 2 Elemente enthält ( zum Beispiel [1, 2, 2, 3], [2, 4, 3, 1, 2]und [3]sind nicht gegeben werde werden). Dies liegt daran, dass bei aufeinanderfolgenden gleichen Elementen das Endergebnis ein ungültiges Präfix für eine solche Sequenz gewesen wäre.
• Sie können davon ausgehen, dass Anur positive ganze Zahlen enthalten sind (da eine solche Sequenz ansonsten undefiniert wäre).
• Sie können davon ausgehen, dass Nes sich um eine nicht negative Ganzzahl ( N >= 0) handelt.
• Sie können nicht mehr Bedingungen als angefordert zurückgeben.
• Die Verwendung einer der Standardlücken ist strengstens untersagt.
• Sie können jede vernünftige E / A-Methode verwenden .
• Ihre Antwort muss nicht über die Grenzen der natürlichen Sprache hinaus funktionieren, theoretisch sollte Ihr Algorithmus jedoch für beliebig große Eingaben und ganze Zahlen funktionieren .
• Das ist Code-Golf , also gewinnt die kürzeste Antwort.

Testfälle

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

Schale , 8 Bytes

Ṡωȯ↑⁰`Ṙ¢

Nimmt zuerst die Länge, dann die Liste. Probieren Sie es online!

Erläuterung

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

u<s*V]M*QlGGvz

Probieren Sie es online aus: Demo oder Testsuite

Erläuterung:

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

Probieren Sie es online!

R , 120 114 108 Bytes

-6 Bytes dank 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]}

Probieren Sie es online!

Anonyme Funktion; a[[1]]Invertiert nacheinander den RLE, wobei die Längen durch den invertierten RLE ersetzt werden und die Werte a[[2]]mit Aauf eine Länge repliziert werden, die der von entspricht a$l.

Haskell , 68 Bytes

Vielen Dank an Laikoni und flawr für ihre Hilfe beim Debuggen und Golfen dieser Antwort im Chatroom von PPCG Haskell, Of Monads and Men . Golfvorschläge willkommen! Probieren Sie es online!

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

Die erste Zeile ist eine anonyme Funktion. Die zweite Zeile ist das unendliche Listenverständnis, das unsere Kolakoski-ähnliche Sequenz erzeugt.

Erläuterung

Zunächst definieren wir zals Kopf von amit a@(z:_). Dann initialisieren wir die Sequenz mit (z<$[1..z]).

Von nun 1an do i<-[1..]hängen wir Folgendes an die Sequenz an: Dies cycle a!!i<$[1..f a!!i]ist das i-te Mitglied der a(auf unbestimmte Zeit durchgeführten) angehängten f a!!iZeiten.

Schließlich übernimmt die anonyme Funktion einfach die ersten nTerme unserer Kolaskoski-ähnlichen Sequenz.

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]

Probieren Sie es online!