Definição

Definir o n ^th matriz da sequência CORR como se segue.

1. Comece com a matriz singleton A = [n] .

2. Para cada número inteiro k em A , substitua a entrada k por k números naturais, contando de 1 a k .

3. Repita o passo anterior n - 1 mais vezes.

Por exemplo, se n = 3 , começamos com a matriz [3] .

Substituímos 3 por 1, 2, 3 , produzindo [1, 2, 3] .

Agora substituímos 1 , 2 e 3 por 1 ; 1, 2 e 1, 2, 3 (resp.), Produzindo [1, 1, 2, 1, 2, 3] .

Finalmente, realizamos as mesmas substituições que na etapa anterior para todos os seis números inteiros na matriz, produzindo [1, 1, 1, 2, 1, 1, 2, 1, 2, 3] . Esta é a terceira matriz CURR.

Tarefa

Escrever um programa de uma função que, dado um número inteiro estritamente positivo n como entrada, calcula o n ^th matriz Curr.

A saída deve ser uma lista simples de algum tipo (e a matriz retornada de uma função, uma representação em cadeia da sintaxe da matriz da sua linguagem, separada por espaços em branco, etc.).

Isso é código-golfe . Que ganhe o código mais curto em bytes!

Casos de teste

 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]

Geléia, 3 bytes

R¡F

Experimente online

Explicação

R¡F    Argument n

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

Python, 50 bytes

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

Abuso de escopo! Por exemplo, para i=3, a sequência a ser avaliada se expande para.

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

De alguma forma, apesar de usar a variável de entrada da função ipara tudo, o Python distingue cada índice de iteração como pertencendo a um escopo separado, como se a expressão fosse

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

com ia entrada para a função.

05AB1E, 6 3 bytes

DFL

Explicado

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

Experimente online

Guardado 3 bytes graças a @Adnan

Retina , 33 bytes

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

Entrada e saída em unário.

Experimente online!

Embora eu não tenha usado o formulário fechado para o desafio relacionado, adaptar essa resposta foi surpreendentemente complicado.

Python 2, 82 bytes

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

Esta não é a solução mais curta, mas ilustra um método interessante:

• Anote os primeiros 2^(2*n-1)números em binário
• Mantenha aqueles com exatamente nos
• Para cada número, conte o número de zeros à direita e adicione 1.

Na verdade, 9 bytes

;#@`♂RΣ`n

Experimente online!

Explicação:

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

Agradecimentos a Leaky Nun por um byte e inspiração por mais 2 bytes.

C #, 128 bytes

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 bytes

{∊⍳¨∘∊⍣⍵+⍵}

Teste:

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

Explicação:

• +⍵: começando com ⍵,
• ⍣⍵: faça os seguintes ⍵horários:
  • ⍳¨∘∊: achatar a entrada e gerar uma lista [1..N] para cada N na entrada
• ∊: achatar o resultado disso

CJam, 14 bytes

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

Teste aqui.

Explicação

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

1 byte economizado com alguma inspiração da resposta de Essari.

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

Bastante simples: para entrada xcomeçamos com {x}e, em seguida, aplicar o Rangea ele xvezes ( Rangeé Listableo que significa que se aplica automaticamente para os inteiros dentro listas arbitrariamente aninhados). No final, Flatteno resultado.

Clojure, 59 bytes

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

Explicação:

Realmente maneira direta de resolver o problema. Trabalhando de dentro para fora:

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

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

Esta é apenas uma tradução direta da descrição do problema no código.

Editar: salvou um byte graças a @Dennis.

R, 60 49 bytes

Uso bastante direto de unliste sapply.

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

Obrigado a @MickyT por salvar 11 bytes

php 121

Não é realmente muita coisa por trás de truques por trás deste. Achatar uma matriz em php não é curto, por isso é necessário construí-la plana em primeiro lugar

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

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

Obrigado a nimi por salvar um byte.

Uma versão sem ponto é mais longa (35 bytes):

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

JavaScript (Firefox 30-57), 63 60 bytes

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

Porta da resposta Python do @ xnor.

J, 18 bytes

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

Abordagem direta com base no processo descrito no desafio.

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

Explicação

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

Pitão, 8 bytes

usSMGQ]Q

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

Geléia, 7 bytes

Rápido, antes de Dennis responder (jk)

WR€F$³¡

Experimente 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 bytes

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

Retorna uma função anônima, tendo n como entrada.

Substitui todas as entradas k em A por [1..k], repete o processo n vezes, começando com A = [n].

Swift 3, 58 bytes

Era para ser executado diretamente no playground, com n definido para a entrada:

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

Sem Golfe, com a menor notação manual revertida:

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 bytes

Procedimento

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

Saída de amostra:

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

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

Editar: salvou 1 byte graças a @xnor. Economizou 2 bytes graças a @ Dennis ♦.

Utilitários Bash + GNU, 49

• 1 byte salvo graças a @Dennis.

Funções recursivas canalizadas FTW!

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

né passado na linha de comando. A saída é separada por nova linha.

O uso de ddestatísticas de causas é enviado para STDERR. Eu acho que isso é bom, mas se não, ddpode ser substituído por catum custo de 1 byte extra.

Perl 5, 53 bytes

Uma sub-rotina:

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

Veja em ação como

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

Ruby, 61 bytes

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

PHP, 100 98 bytes

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

Em cada iteração, crie uma cópia temporária em loop de 1 .. (primeiro valor removido) até $aficar vazio.

Esses dois ainda estão e provavelmente permanecerão em 100 bytes:

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

Em cada iteração, retrocede através da matriz, substituindo cada número por um intervalo.

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

Em cada iteração, faça um loop através da matriz, aumentando o índice pelo número anterior e substituindo cada elemento indexado por um intervalo