Визначення

Визначте n- ^й масив послідовності CURR наступним чином.

1. Почніть з однотонного масиву A = [n] .

2. Для кожного цілого k в A замініть запис 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

Пітон, 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.
}*

Математика, 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

Завдяки nimi за збереження байта.

Точкова версія довша (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]`)

Порт відповіді Python @ xnor.

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

Швидкий 3, 58 байт

Мається на увазі бігати прямо на ігровому майданчику, з n встановленим на вході:

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

Безумовно, із самим коротким позначенням руки відмінено:

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 байти завдяки @ Dennis ♦.

Утиліти 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);

У кожному циклі ітерації через масив збільшується індекс на попереднє число та замінюється кожен індексований елемент діапазоном