Вот как определяется последовательность Колакоски (OEIS A000002 ):

Последовательность Колакоски представляет собой последовательность, которая содержит 1и 2, а nth-й элемент последовательности является длиной nth-й группы равных элементов (прогона) в самой последовательности. Первые 20 членов последовательности и соответствующие длины:

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

По сути, длинами групп равных элементов последовательности Колакоски является сама последовательность Колакоски.

Пока все хорошо, но почему мы должны ограничивать себя 1и 2? Мы не собираемся! При наличии двух входных данных, массива натуральных чисел Aи целого числа N, возвращаются первые Nчлены последовательности, подобной Колакоски, определенной циклически A. Чтобы лучше понять это, вот рабочий пример с длинами вновь добавленных групп в скобках:

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 ]

Вот еще один проработанный пример с ведущим 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 ]

Как вы можете видеть выше, окончательный результат был разрезан на N = 10элементы. Элемент nth должен указывать длину группы nравных элементов, даже если сам элемент принадлежит к той группе, к которой он относится. Как и в приведенном выше случае, первая 1относится к первой такой группе, которая является именно этим 1, а первая 2относится ко второй такой группе, которая начинается с нее.

правила

• Вы можете предположить, что Aникогда не будет иметь два или более последовательных равных элемента. Aможет содержать целое число более одного раза, но первый и последний элементы не будут равны и Aбудут содержать как минимум 2 элемента (например [1, 2, 2, 3], [2, 4, 3, 1, 2]и [3]не будут даны). Это потому, что если бы были последовательные равные элементы, конечный результат был бы недопустимым префиксом для такой последовательности.
• Вы можете предположить, что Aсодержит только положительные целые числа (так как в противном случае последовательность была бы неопределенной).
• Вы можете предположить, Nчто это неотрицательное целое число ( N >= 0).
• Вы не можете вернуть больше условий, чем запрошено.
• Использование любой из стандартных лазеек строго запрещено.
• Вы можете использовать любой разумный метод ввода / вывода .
• Ваш ответ не должен работать за пределами естественного языка, но теоретически ваш алгоритм должен работать для произвольно больших входных данных и целых чисел .
• Это код-гольф , поэтому выигрывает самый короткий ответ.

Контрольные примеры

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

Шелуха , 8 байт

Ṡωȯ↑⁰`Ṙ¢

Принимает сначала длину, затем список. Попробуйте онлайн!

объяснение

Ṡωȯ↑⁰`Ṙ¢  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 байт

u<s*V]M*QlGGvz

Попробуйте онлайн: демонстрация или тестовый набор

Объяснение:

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 байт

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

Попробуйте онлайн!

R , 120 114 108 байт

-6 байт благодаря планнапу

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

Попробуйте онлайн!

Анонимная функция; последовательно инвертирует RLE, заменяя длины a[[1]]с перевернутой RLE, а значения a[[2]]с Aреплицируются на длину , равные a$l.

Haskell , 68 байт

Большое спасибо Лайкони и Flawr за их помощь в отладке и игре в гольф этот ответ в чате PPCG Haskell, Of Monads and Men . Предложения по игре в гольф приветствуются! Попробуйте онлайн!

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

Первая строка - анонимная функция. Вторая строка - это представление о бесконечном списке, которое порождает нашу последовательность в стиле Колакоски.

объяснение

Во-первых, мы определяем zкак глава aс a@(z:_). Затем мы инициализируем последовательность с помощью (z<$[1..z]).

Затем, начиная с этого 1момента, do i<-[1..]мы добавляем следующее к последовательности:, cycle a!!i<$[1..f a!!i]которая является i-ым членом a(циклически неопределенного) добавленного f a!!iвремени.

Наконец, анонимная функция просто берет первые nчлены нашей последовательности, подобной Коласкоски.

Python 2 , 123 байта

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]

Попробуйте онлайн!