Definición

Definir el n ^º matriz de la secuencia de CURR como sigue.

1. Comience con la matriz singleton A = [n] .

2. Para cada número entero k en A , reemplace la entrada k con k números naturales, contando desde 1 hasta k .

3. Repita el paso anterior n - 1 veces más.

Por ejemplo, si n = 3 , comenzamos con la matriz [3] .

Reemplazamos 3 con 1, 2, 3 , produciendo [1, 2, 3] .

Ahora reemplazamos 1 , 2 y 3 con 1 ; 1, 2 y 1, 2, 3 (resp.), Produciendo [1, 1, 2, 1, 2, 3] .

Finalmente, realizamos los mismos reemplazos que en el paso anterior para los seis enteros en la matriz, produciendo [1, 1, 1, 2, 1, 1, 2, 1, 2, 3] . Esta es la tercera matriz CURR.

Tarea

Escribir un programa de una función que, dado un número entero estrictamente positivo n como entrada, calcula el n ^º array CURR.

El resultado debe ser una lista plana de algún tipo (y la matriz devuelta por una función, una representación de cadena de la sintaxis de la matriz de su idioma, separados por espacios en blanco, etc.).

Este es el código de golf . ¡Que gane el código más corto en bytes!

Casos de prueba

 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]

Jalea, 3 bytes

R¡F

Pruébalo en línea

Explicación

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 alcance! Por ejemplo, para i=3, la cadena a evaluar se expande a.

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

De alguna manera, a pesar de usar la variable de entrada de función ipara todo, Python distingue cada índice de iteración como perteneciente a un ámbito separado como si la expresión fuera

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

con ila entrada a la función.

05AB1E, 6 3 bytes

DFL

Explicado

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

Pruébalo en línea

Guardado 3 bytes gracias a @Adnan

Retina , 33 bytes

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

Entrada y salida en unario.

Pruébalo en línea!

Aunque no utilicé el formulario cerrado para el desafío relacionado, adaptar esta respuesta fue sorprendentemente 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 no es la solución más corta, pero ilustra un método interesante:

• Escribe los primeros 2^(2*n-1)números en binario
• Mantener los que tienen exactamente nlas
• Para cada número, cuente el número de ceros finales y agregue 1.

En realidad, 9 bytes

;#@`♂RΣ`n

Pruébalo en línea!

Explicació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

Gracias a Leaky Nun por un byte e inspiración para otros 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

{∊⍳¨∘∊⍣⍵+⍵}

Prueba:

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

Explicación:

• +⍵: comenzando con ⍵,
• ⍣⍵: hacer los siguientes ⍵horarios:
  • ⍳¨∘∊: aplanar la entrada y luego generar una lista [1..N] para cada N en la entrada
• ∊: aplanar el resultado de eso

CJam, 14 bytes

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

Pruébalo aquí.

Explicación

_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 guardado con algo de inspiración de la respuesta de Essari.

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

Bastante sencillo: para la entrada xpartimos {x}y luego aplicar el Rangea ella xveces ( Rangees Listablelo que significa que se aplica automáticamente a los números enteros dentro enumera arbitrariamente anidados). Al final Flattenel resultado.

Clojure, 59 bytes

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

Explicación:

Manera realmente directa para resolver el problema. Trabajando de adentro hacia afuera:

(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 es solo una traducción directa de la descripción del problema al código.

Editar: guardado un byte gracias a @Dennis.

R, 60 49 bytes

Uso bastante directo de unlisty sapply.

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

Gracias a @MickyT por guardar 11 bytes

php 121

Realmente no hay muchos trucos detrás de este. Acoplar una matriz en php no es corta, por lo que es necesario construirla plana en primer 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

Gracias a nimi por guardar un byte.

Una versión sin puntos es más larga (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]`)

Puerto de la respuesta Python de @ xnor.

J, 18 bytes

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

Enfoque directo basado en el proceso descrito en el desafío.

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

Explicación

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

usSMGQ]Q

Pruébalo en línea!

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.

Jalea, 7 bytes

Rápido, antes de que Dennis responda (jk)

WR€F$³¡

Pruébalo en línea!

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}

Devuelve una función anónima que toma n como entrada.

Reemplaza cada entrada k en A con [1..k], repite el proceso n veces, comenzando con A = [n].

Swift 3, 58 Bytes

Destinado a correr directamente en el patio de recreo, con n configurado en la entrada:

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

Sin golf, con la mayoría de las anotaciones de manos cortas revertidas:

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

Procedimiento

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

Salida de muestra:

[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: Guardado 1 byte gracias a @xnor. Guardado 2 bytes gracias a @ Dennis ♦.

Bash + utilidades GNU, 49

• 1 byte guardado gracias a @Dennis.

Funciones recursivas canalizadas FTW!

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

nse pasa en la línea de comandos. La salida está separada por una nueva línea.

El uso de ddestadísticas de causas se enviará a STDERR. Creo que esto está bien, pero si no, ddse puede reemplazar con catun costo de 1 byte adicional.

Perl 5, 53 bytes

Una subrutina:

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

Véalo en acción 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

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

En cada iteración, cree una copia temporal en bucle desde 1 .. (primer valor eliminado) hasta $a esté vacío.

Estos dos están quietos y probablemente permanecerán en 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);

En cada iteración, haga un bucle hacia atrás a través de la matriz reemplazando cada número con un rango.

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

En cada ciclo de iteración a través de la matriz, aumentar el índice por número anterior y reemplazar cada elemento indexado con un rango