Definizione

Definire il n ^° matrice della sequenza CURR come segue.

1. Inizia con l'array singleton A = [n] .

2. Per ogni intero k in A , sostituisci la voce k con k numeri naturali, contando da 1 a k .

3. Ripetere il passaggio precedente n - 1 più volte.

Ad esempio, se n = 3 , iniziamo con l'array [3] .

Sostituiamo 3 con 1, 2, 3 , dando [1, 2, 3] .

Sostituiamo ora 1 , 2 e 3 con 1 ; 1, 2 e 1, 2, 3 (risp.), Dando [1, 1, 2, 1, 2, 3] .

Infine, eseguiamo le stesse sostituzioni del passaggio precedente per tutti e sei i numeri interi nell'array, producendo [1, 1, 1, 2, 1, 1, 2, 1, 2, 3] . Questo è il terzo array CURR.

Compito

Scrivi un programma di una funzione che, dato un intero n strettamente positivo come input, calcola l' n- ^esimo array CURR.

L'uscita deve essere un piatto elenco di qualche tipo (e matrice restituita da una funzione, una rappresentazione di stringa di sintassi di matrice del linguaggio, separate da spazi, ecc).

Questo è code-golf . Che vinca il codice più breve in byte!

Casi test

 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]

Gelatina, 3 byte

R¡F

Provalo online

Spiegazione

R¡F    Argument n

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

Python, 50 byte

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

Abuso di portata! Ad esempio, per i=3, la stringa da valutare si espande.

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

In qualche modo, nonostante utilizzi la variabile di input della funzione iper tutto, Python distingue ogni indice di iterazione come appartenente a un ambito separato come se l'espressione fosse

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

con il'ingresso alla funzione.

05AB1E, 6 3 byte

DFL

spiegato

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

Provalo online

Salvato 3 byte grazie a @Adnan

Retina , 33 byte

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

Input e output in unario.

Provalo online!

Anche se non ho usato il modulo chiuso per la relativa sfida, l'adattamento di questa risposta è stato sorprendentemente complicato.

Python 2, 82 byte

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

Questa non è la soluzione più breve, ma illustra un metodo interessante:

• Scrivi il primo 2^(2*n-1) numeri in binario
• Mantieni quelli con esattamente n quelli
• Per ogni numero, contare il numero di zero finali e aggiungere 1.

In realtà, 9 byte

;#@`♂RΣ`n

Provalo online!

Spiegazione:

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

Grazie a Leaky Nun per un byte e ispirazione per altri 2 byte.

C #, 128 byte

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 byte

{∊⍳¨∘∊⍣⍵+⍵}

Test:

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

Spiegazione:

• +⍵: a partire da ⍵,
• ⍣⍵: eseguire le seguenti ⍵volte:
  • ⍳¨∘∊: appiattisce l'input, quindi genera un elenco [1..N] per ogni N nell'input
• ∊: appiattire il risultato di quello

CJam, 14 byte

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

Provalo qui.

Spiegazione

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

1 byte salvato con un po 'di ispirazione dalla risposta di Essari.

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

Abbastanza semplice: per l'input xiniziamo con {x}e poi applichiamo i tempi Rangead esso x( Rangeè il Listableche significa che si applica automaticamente agli interi all'interno di elenchi arbitrariamente nidificati). Alla fine Flattenil risultato.

Clojure, 59 byte

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

Spiegazione:

Modo davvero diretto per risolvere il problema. Lavorando da dentro e fuori:

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

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

Questa è solo una traduzione semplice della descrizione del problema in codice.

Modifica: salvato un byte grazie a @Dennis.

R, 60 49 byte

Uso abbastanza semplice di unliste sapply.

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

Grazie a @MickyT per aver salvato 11 byte

php 121

Non molto in termini di trucchi dietro questo. L'appiattimento di un array in php non è breve, quindi è necessario costruirlo piatto in primo luogo

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

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

Grazie a nimi per aver salvato un byte.

Una versione senza punti è più lunga (35 byte):

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

JavaScript (Firefox 30-57), 63 60 byte

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

Port of @ xnor's Python answer.

J, 18 byte

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

Approccio diretto basato sul processo descritto nella sfida.

uso

   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

Spiegazione

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

usSMGQ]Q

Provalo online!

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.

Gelatina, 7 byte

Presto, prima che Dennis risponda (jk)

WR€F$³¡

Provalo online!

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 byte

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

Restituisce una funzione anonima che accetta n come input.

Sostituisce ogni voce k in A con [1..k], ripete il processo n volte, iniziando con A = [n].

Swift 3, 58 byte

Avrebbe funzionato direttamente nel parco giochi, con n impostato sull'input:

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

Ungolfed, con la notazione più breve ripristinata:

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 byte

Procedura

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

uso

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

Uscita campione:

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

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

Modifica: salvato 1 byte grazie a @xnor. Salvato 2 byte grazie a @ Dennis ♦.

Utilità Bash + GNU, 49

• 1 byte salvato grazie a @Dennis.

Funzioni ricorsive convogliate FTW!

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

nviene passato dalla riga di comando. L'output è separato da una nuova riga.

L'uso delle ddstatistiche causa l'invio a STDERR. Penso che sia OK, ma in caso contrario, ddpuò essere sostituito con catun costo di 1 byte extra.

Perl 5, 53 byte

Una subroutine:

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

Guardalo in azione come

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

Rubino, 61 byte

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

PHP, 100 98 byte

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

In ogni iterazione creare un ciclo temporaneo di copia da 1 .. (primo valore rimosso) fino a quando non $aè vuoto.

Questi due sono ancora e probabilmente rimarranno a 100 byte:

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

In ogni ciclo di iterazione all'indietro attraverso l'array sostituisce ogni numero con un intervallo.

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

In ogni ciclo di iterazione attraverso l'array aumenta l'indice del numero precedente e sostituisce ogni elemento indicizzato con un intervallo