Tanım

Tanımlama olarak N ^inci aşağıdaki gibi AKIM dizisinin dizisi.

1. A = [n] singleton dizisi ile başlayın .

2. Her bir tam sayı için k içinde A , giriş yerine k ile k kadar sayma, doğal sayılar 1 için k .

3. Önceki adım n - 1'i tekrarlayın.

Örneğin, n = 3 ise , [3] dizisiyle başlarız .

Biz yerine 3 ile 1, 2, 3 , elde [1, 2, 3] .

Şimdi yerine 1 , 2 ve 3 ile 1 ; 1, 2 ve 1, 2, 3 (sırasıyla), [1, 1, 2, 1, 2, 3] elde edilir .

Son olarak, dizideki altı tamsayı için de önceki adımdakiyle aynı değiştirmeleri gerçekleştiririz ve [1, 1, 1, 2, 1, 1, 2, 1, 2, 3] elde edilir . Bu üçüncü CURR dizisidir.

Görev

Kesinlikle pozitif tamsayı verilen bir fonksiyonun bir program yazınız n girdi, hesaplar olarak n ^inci AKIM dizisi.

Çıktı, bir tür düz bir liste olmalıdır (ve bir işlevden döndürülen dizi, dilinizin dizi sözdiziminin dize olarak temsil edilmesi, boşlukla ayrılmış vb.).

Bu kod golfü . Bayttaki en kısa kod kazanabilir!

Test senaryoları

 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]

Jöle, 3 bayt

R¡F

Çevrimiçi deneyin

açıklama

R¡F    Argument n

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

Python, 50 bayt

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

Kapsam kötüye kullanımı! Örneğin, i=3değerlendirilecek dize, olarak genişler.

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

Her nasılsa, işlev girdi değişkenini iher şey için kullanmasına rağmen , Python her bir yineleme dizinini, ifadeyi sanki ayrı bir kapsama ait olarak ayırıyor

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

ile iişlev giriş.

05AB1E, 6 3 bayt

DFL

Açıklaması

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

Çevrimiçi deneyin

@Adnan sayesinde 3 bayt kaydedildi

Retina , 33 bayt

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

Giriş ve çıkış tekli.

Çevrimiçi deneyin!

Kapalı formu ilgili zorluk için kullanmasam da, bu cevabı uyarlamak şaşırtıcı derecede zordu.

Python 2, 82 bayt

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

Bu en kısa çözüm değil, ancak ilginç bir yöntemi gösteriyor:

• İlk 2^(2*n-1)sayıları ikili dosyaya yazın
• Tam olarak nolanlar ile sakla
• Her sayı için, izleyen sıfır sayısını sayın ve 1 ekleyin.

Aslında 9 bayt

;#@`♂RΣ`n

Çevrimiçi deneyin!

Açıklama:

;#@`♂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

Bir bayt için Leaky Nun'e ve 2 baytlık ilham için teşekkürler.

C #, 128 Bayt

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 bayt

{∊⍳¨∘∊⍣⍵+⍵}

Ölçek:

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

Açıklama:

• +⍵: ile başlayarak ⍵,
• ⍣⍵: aşağıdaki ⍵zamanları yapın:
  • ⍳¨∘∊: girişi düzleştirin ve ardından girişteki her N için bir liste [1..N] oluşturun
• ∊: bunun sonucunu düzleştirin

CJam, 14 bayt

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

Burada test edin.

açıklama

_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 bayt

Essari'nin cevabından ilham alarak 1 bayt kurtardı.

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

Oldukça basit: girişi için xbiz ile başlamak {x}ve daha sonra uygulamak Rangekendisine xkez ( Rangebir Listableotomatik tamsayılar içeride keyfi iç içe listeler için geçerli olduğunu hangi araçlar). Sonunda Flattensonuç.

Clojure, 59 bayt

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

Açıklama:

Sorunu çözmek için gerçekten düz bir yol. İçten dışa doğru çalışma:

(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 bayt

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

Bu, sorun tanımının kodlara açık bir çevirisidir.

Düzenleme: @Dennis sayesinde bir bayt kaydedildi.

R, 60 49 bayt

Pretty basit kullanım unlistve sapply.

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

11 bayt kaydettiği için @MickyT sayesinde

php 121

Bunun arkasındaki hileler yolunda pek değil. Php bir dizi düzleştirmek kısa değil, bu yüzden ilk etapta düz inşa etmek gerekli

<?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 bayt

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

Bir baytı kaydettiği için nimi'ye teşekkürler.

Pointfree sürümü daha uzundur (35 bayt):

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

JavaScript (Firefox 30-57), 63 60 bayt

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

@ Xnor'ın Python cevabının portu.

J, 18 bayt

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

Meydan okumada açıklanan sürece dayalı, doğrudan ileri yaklaşım.

kullanım

   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

açıklama

([:;<@(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 bayt

usSMGQ]Q

Çevrimiçi deneyin!

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.

Jöle, 7 bayt

Hızlı, Dennis cevap vermeden önce (jk)

WR€F$³¡

Çevrimiçi deneyin!

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 bayt

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

N'yi girdi olarak alan anonim bir işlev döndürür.

A'daki her k girişini [1..k] ile değiştirir, A = [n] ile başlayarak işlemi n kez tekrarlar.

Swift 3, 58 Bayt

N, girişe ayarlanmış olarak, doğrudan bir oyun alanında çalışmak anlamına geliyordu:

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

Ungolfed, en kısa el gösterimi geri döndürüldü:

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 Bayt

prosedür

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

kullanım

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

Örnek çıktı:

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

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

Düzenleme: @xnor sayesinde 1 bayt kaydedildi. @ Dennis ♦ sayesinde 2 bayt tasarruf edildi.

Bash + GNU yardımcı programları, 49

• @Dennis sayesinde 1 bayt tasarruf edildi.

Borulu özyinelemeli fonksiyonlar FTW!

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

nkomut satırında iletilir. Çıktı satırsonu ile ayrılmıştır.

ddSTDERR'a gönderilecek neden istatistiklerinin kullanımı . Bence bu iyi, ama değilse , 1 ekstra bayt maliyetiyle dddeğiştirilebilir cat.

Perl 5, 53 bayt

Bir altyordam:

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

Hareket halindeyken görün

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

Ruby, 61 bayt

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

PHP, 100 98 bayt

İle çalıştırın 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);

Her yinelemede 1'den (ilk değer kaldırıldı) boşalana kadar döngü yapan geçici bir kopya oluşturun $a.

Bu ikisi hareketsizdir ve muhtemelen 100 baytta kalacaktır:

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

Her yineleme döngüsünde, her sayıyı bir aralıkla değiştirerek dizi boyunca geriye doğru döner.

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

Dizinin her bir yineleme döngüsünde dizini önceki sayıya göre artırmak ve dizine alınan her öğeyi bir aralıkla değiştirmek