Определение

Определите n- ^й массив последовательности CURR следующим образом.

1. Начните с одноэлементного массива A = [n] .

2. Для каждого целого к в А , заменить запись K с K натуральных чисел, подсчитывая от 1 до K .

3. Повторите предыдущий шаг n - еще 1 раз.

Например, если n = 3 , мы начинаем с массива [3] .

Заменим 3 на 1, 2, 3 , получив [1, 2, 3] .

Теперь мы заменим 1 , 2 и 3 на 1 ; 1, 2 и 1, 2, 3 (соотв.), Получая [1, 1, 2, 1, 2, 3] .

Наконец, мы выполняем те же замены, что и на предыдущем шаге, для всех шести целых чисел в массиве, получая [1, 1, 1, 2, 1, 1, 2, 1, 2, 3] . Это третий массив CURR.

задача

Напишите программу функции, которая, учитывая строго положительное целое число n в качестве входных данных, вычисляет n- ^й массив CURR.

Выходными данными должен быть какой-то плоский список (и массив, возвращаемый функцией, строковое представление синтаксиса массива вашего языка, разделенных пробелами и т. Д.).

Это код-гольф . Пусть победит самый короткий код в байтах!

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

 1 -> [1]
 2 -> [1, 1, 2]
 3 -> [1, 1, 1, 2, 1, 1, 2, 1, 2, 3]
 4 -> [1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4]
 5 -> [1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 2, 3, 4, 5]
 6 -> [1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 2, 3, 4, 5, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 2, 3, 4, 5, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 2, 3, 4, 5, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 2, 3, 4, 5, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 6]

Желе, 3 байта

R¡F

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

объяснение

R¡F    Argument n

R      Yield range [1..n]
 ¡     Repeat n times
  F    Flatten the result

Python, 50 байт

lambda i:eval("[i "+"for i in range(1,i+1)"*i+"]")

Сфера злоупотребления! Например, для i=3строки, которая должна быть оценена, расширяется до.

[i for i in range(1,i+1)for i in range(1,i+1)for i in range(1,i+1)]

Каким-то образом, несмотря на использование входной переменной функции iдля всего, Python различает каждый индекс итерации как принадлежащий отдельной области видимости, как если бы выражение было

[l for j in range(1,i+1)for k in range(1,j+1)for l in range(1,k+1)]

с iвходом в функцию.

05AB1E, 6 3 байта

DFL

Разъяснения

D     # duplicate input
 F    # input times do
  L   # range(1,N)

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

Сохранено 3 байта благодаря @Adnan

Сетчатка , 33 байта

$
$.`$*0
+%(M!&`1.*(?=0)|^.+
O`.+

Ввод и вывод в одинарный.

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

Несмотря на то, что я не использовал закрытую форму для связанной задачи, адаптация этого ответа была на удивление хитрой.

Python 2, 82 байта

lambda n:[1+bin(i)[::-1].find('1')for i in range(1<<2*n-1)if bin(i).count('1')==n]

Это не самое короткое решение, но оно иллюстрирует интересный метод:

• Запишите первые 2^(2*n-1)числа в двоичном виде
• Держите те именно с nних
• Для каждого числа посчитайте количество конечных нулей и добавьте 1.

На самом деле, 9 байтов

;#@`♂RΣ`n

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

Объяснение:

;#@`♂RΣ`n
;#@        dupe n, make a singleton list, swap with n
   `♂RΣ`n  call the following function n times:
    ♂R       range(1, k+1) for k in list
      Σ      concatenate the ranges

Спасибо Leaky Nun за байт и вдохновение за еще 2 байта.

C #, 128 байт

List<int>j(int n){var l=new List<int>(){n};for(;n>0;n--)l=l.Select(p=>Enumerable.Range(1,p)).SelectMany(m=>m).ToList();return l;

APL, 11 байт

{∊⍳¨∘∊⍣⍵+⍵}

Тестовое задание:

      {∊⍳¨∘∊⍣⍵+⍵} 3
1 1 1 2 1 1 2 1 2 3

Объяснение:

• +⍵: начиная с ⍵ ,
• ⍣⍵: сделайте следующее ⍵ время:
  • ⍳¨∘∊: выровнять вход, а затем сгенерировать список [1..N] для каждого N на входе
• ∊: сгладить результат этого

CJam, 14 байтов

{_a\{:,:~:)}*}

Проверьте это здесь.

объяснение

_a   e# Duplicate N and wrap it in an array.
\    e# Swap with other copy of N.
{    e# Do this N times...
  :, e#   Turn each x into [0 1 ... x-1].
  :~ e#   Unwrap each of those arrays.
  :) e#   Increment each element.
}*

Mathematica, 27 26 байтов

1 байт сохранен с вдохновением от ответа Эссари.

Flatten@Nest[Range,{#},#]&

Довольно просто: для ввода xмы начинаем с, {x}а затем применяем Rangeк нему xвремя ( Rangeэто Listableозначает, что оно автоматически применяется к целым числам внутри произвольно вложенных списков). В итоге Flattenрезультат.

Clojure, 59 байт

(fn[n](nth(iterate #(mapcat(fn[x](range 1(inc x)))%)[n])n))

Объяснение:

Действительно прямой путь решения проблемы. Работаем изнутри:

(1) (fn[x](range 1(inc x))) ;; return a list from 1 to x
(2) #(mapcat (1) %)         ;; map (1) over each item in list and flatten result
(3) (iterate (2) [n])       ;; call (2) repeatedly e.g. (f (f (f [n])))
(4) (nth (3) n))            ;; return the nth value of the iteration

Python 3, 75 74 байта

def f(k):N=[k];exec('A=N;N=[]\nfor i in A:N+=range(1,i+1)\n'*k+'print(N)')

Это просто прямой перевод описания проблемы в код.

Изменить: Сохраненный один байт благодаря @Dennis.

R, 60 49 байтов

Довольно простое использование unlistи sapply.

y=x=scan();for(i in 1:x)y=unlist(sapply(y,seq));y

Спасибо @MickyT за сохранение 11 байтов

php 121

На самом деле не так уж много хитростей за этим. Сглаживание массива в php не короткое, поэтому необходимо сначала построить его массив

<?php for($a=[$b=$argv[1]];$b--;)$a=array_reduce($a,function($r,$v){return array_merge($r,range(1,$v));},[]);print_r($a);

Haskell, 33 байта

f n=iterate(>>= \a->[1..a])[n]!!n

Спасибо Ними за сохранение байта.

Бессмысленная версия длиннее (35 байт):

(!!)=<<iterate(>>= \a->[1..a]).pure

JavaScript (Firefox 30-57), 63 60 байт

f=n=>eval(`[${`for(n of Array(n+1).keys())`.repeat(n--)}n+1]`)

Порт ответа @ xnor на Python.

J, 18 байт

([:;<@(1+i.)"0)^:]

Прямой подход, основанный на процессе, описанном в задаче.

использование

   f =: ([:;<@(1+i.)"0)^:]
   f 1
1
   f 2
1 1 2
   f 3
1 1 1 2 1 1 2 1 2 3
   f 4
1 1 1 1 2 1 1 1 2 1 1 2 1 2 3 1 1 1 2 1 1 2 1 2 3 1 1 2 1 2 3 1 2 3 4

объяснение

([:;<@(1+i.)"0)^:]  Input: n
                 ]  Identity function, gets the value n
(     ...     )^:   Repeat the following n times with an initial value [n]
      (    )"0        Means rank 0, or to operate on each atom in the list
         i.           Create a range from 0 to that value, exclusive
       1+             Add 1 to each to make the range from 1 to that value
    <@                Box the value
 [:;                  Combine the boxes and unbox them to make a list and return
                    Return the final result after n iterations

Pyth, 8 байт

usSMGQ]Q

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

usSMGQ]Q   input as Q

u    Q     repeat for Q times,
      ]Q   starting as [Q]:

  SMG          convert each number in the array to its range
 s             flatten

           then implicitly prints the result.

Желе, 7 байт

Быстро, прежде чем Деннис отвечает (JK)

WR€F$³¡

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

WR€F$³¡  Main monadic chain. Argument: z

W        Yield [z].
     ³¡  Repeat the following z times:
 R€          Convert each number in the array to the corresponding range.
   F         Flatten the array.

F #, 63 байта

fun n->Seq.fold(fun A _->List.collect(fun k->[1..k])A)[n]{1..n}

Возвращает анонимную функцию, принимающую n в качестве входных данных.

Заменяет каждую запись k в A на [1..k], повторяет процесс n раз, начиная с A = [n].

Swift 3, 58 байт

Предназначен для запуска прямо на игровой площадке, где n установлено на входе:

var x=[n];for i in 0..<n{x=x.reduce([]){$0+[Int](1...$1)}}

Ungolfed, с самой короткой нотацией стороны возвращены:

let n = 3 //input

var x: Array<Int> = [n]
for i in 0..<n {
    x = x.reduce(Array<Int>[], combine: { accumulator, element in
        accumulator + Array<Int>(1...element)
    })
}

Java, 159 байт

Процедура

int[] q(int y){int z[]=new int[]{y};for(int i=0;i<y;i++){int d=0,a=0;for(int c:z)d+=c;int[]r=new int[d];for(int c:z)for(int j=0;j<c;)r[a++]=++j;z=r;}return z;}

использование

public static void main(String[] args){String out = "["; int [] b = q(6);for(int c:b)out+=c+", ";System.out.println(out+"]");}

public static int[] q(int y){int z[]=new int[]{y};for(int i=0;i<y;i++){int d=0,a=0;for(int c:z)d+=c;int[]r=new int[d];for(int c:z)for(int j=0;j<c;)r[a++]=++j;z=r;}return z;}

Пример вывода:

[1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 2, 3, 4, 5, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 2, 3, 4, 5, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 2, 3, 4, 5, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 2, 3, 4, 5, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 6, ]

Python 2, 69 68 66 байт

def f(n):a=[n];exec'a=sum([range(1,i+1)for i in a],[]);'*n;print a

Редактировать: 1 байт сохранен благодаря @xnor. Сохранено 2 байта благодаря @ Деннис ♦.

Утилиты Bash + GNU, 49

• 1 байт сохранен благодаря @Dennis.

Трубная рекурсивная функция FTW!

f()((($1))&&xargs -l seq|f $[$1-1]||dd)
f $1<<<$1

nпередается в командной строке. Вывод через новую строку

Использование ddприводит к отправке статистики в STDERR. Я думаю, что это нормально, но если нет, то ddможет быть заменено catна 1 дополнительный байт.

Perl 5, 53 байта

Подпрограмма:

{($i)=@_;for(1..$i){my@c;push@c,1..$_ for@_;@_=@c}@_}

Увидеть это в действии как

perl -e'print "$_ " for sub{($i)=@_;for(1..$i){my@c;push@c,1..$_ for@_;@_=@c}@_}->(3)'

Рубин, 61 байт

def f(n);a=[n];n.times{a=a.map{|i|(1..i).to_a}.flatten};a;end

PHP, 100 98 байт

Беги с php -r '<code>' <n>.

for($a=[$n=$argv[1]];$n--;$a=$b)for($b=[],$k=0;$c=$a[$k++];)for($i=0;$i++<$c;)$b[]=$i;print_r($a);

В каждой итерации создайте временную копию цикла с 1 .. (первое значение удалено), пока не $aстанет пустым.

Эти два все еще и, вероятно, останутся в 100 байтах:

for($a=[$n=$argv[1]];$n--;)for($i=count($a);$i--;)array_splice($a,$i,1,range(1,$a[$i]));print_r($a);

В каждом цикле итерации в обратном порядке через массив заменяя каждое число диапазоном.

for($a=[$n=$argv[1]];$n--;)for($i=$c=0;$c=$a[$i+=$c];)array_splice($a,$i,1,range(1,$c));print_r($a);

В каждом цикле итерации через массив увеличивайте индекс на предыдущее число и заменяйте каждый индексированный элемент диапазоном