Définition

Définissez le n ^ème tableau de la séquence CURR comme suit.

1. Commencez par le tableau singleton A = [n] .

2. Pour chaque entier k dans A , remplacez l'entrée k par k nombres naturels, en comptant de 1 à k .

3. Répétez l'étape précédente n - 1 fois de plus.

Par exemple, si n = 3 , nous commençons par le tableau [3] .

Nous remplaçons 3 par 1, 2, 3 , ce qui donne [1, 2, 3] .

Nous remplaçons maintenant 1 , 2 et 3 par 1 ; 1, 2 et 1, 2, 3 (resp.), Donnant [1, 1, 2, 1, 2, 3] .

Enfin, nous effectuons les mêmes remplacements que dans l'étape précédente pour les six entiers du tableau, ce qui donne [1, 1, 1, 2, 1, 1, 2, 1, 2, 3] . Il s'agit du troisième tableau CURR.

Tâche

Écrivez un programme d'une fonction qui, étant donné un entier strictement positif n en entrée, calcule le n ^ème tableau CURR.

La sortie doit être une sorte de liste plate (et un tableau renvoyé par une fonction, une représentation sous forme de chaîne de la syntaxe du tableau de votre langue, séparée par des espaces, etc.).

C'est du code-golf . Que le code le plus court en octets gagne!

Cas de 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]

Gelée, 3 octets

R¡F

Essayez-le en ligne

Explication

R¡F    Argument n

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

Python, 50 octets

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

Abus de portée! Par exemple, pouri=3 , la chaîne à évaluer se développe.

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

D'une certaine manière, malgré l'utilisation de la variable d'entrée de fonction i pour tout, Python distingue chaque index d'itération comme appartenant à une portée distincte comme si l'expression était

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

avec il'entrée de la fonction.

05AB1E, 6 3 octets

DFL

Expliqué

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

Essayez-le en ligne

Sauvegardé 3 octets grâce à @Adnan

Rétine , 33 octets

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

Entrée et sortie unaires.

Essayez-le en ligne!

Même si je n'ai pas utilisé le formulaire fermé pour le défi associé, l'adaptation de cette réponse a été étonnamment délicate.

Python 2, 82 octets

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

Ce n'est pas la solution la plus courte, mais elle illustre une méthode intéressante:

• Notez les premiers 2^(2*n-1)nombres en binaire
• Gardez ceux avec exactement nceux
• Pour chaque nombre, comptez le nombre de zéros à la fin et ajoutez 1.

En fait, 9 octets

;#@`♂RΣ`n

Essayez-le en ligne!

Explication:

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

Merci à Leaky Nun pour un octet et inspiration pour 2 autres octets.

C #, 128 octets

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 octets

{∊⍳¨∘∊⍣⍵+⍵}

Tester:

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

Explication:

• +⍵: en commençant par ⍵,
• ⍣⍵: procédez comme suit ⍵:
  • ⍳¨∘∊: aplatir l'entrée, puis générer une liste [1..N] pour chaque N dans l'entrée
• ∊: aplatir le résultat de cette

CJam, 14 octets

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

Testez-le ici.

Explication

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

1 octet enregistré avec une certaine inspiration de la réponse d'Essari.

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

Assez simple: pour l' entrée , xnous commençons par {x}et appliquer ensuite la Rangelui xfois ( Rangeest ce Listablequi signifie qu'il applique automatiquement aux entiers à l' intérieur des listes imbriquées arbitrairement). À la fin, Flattenle résultat.

Clojure, 59 octets

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

Explication:

Un moyen très simple de résoudre le problème. Travailler de l'intérieur:

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

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

Il s'agit simplement d'une traduction simple de la description du problème en code.

Edit: enregistré un octet grâce à @Dennis.

R, 60 49 octets

Utilisation assez simple de unlistet sapply.

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

Merci à @MickyT pour avoir économisé 11 octets

php 121

Pas vraiment beaucoup de trucs derrière celui-ci. L'aplatissement d'un tableau en php n'est pas court, il est donc nécessaire de le construire à plat en premier lieu

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

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

Merci à nimi d'avoir enregistré un octet.

Une version sans point est plus longue (35 octets):

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

JavaScript (Firefox 30-57), 63 60 octets

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

Port de la réponse Python @ xnor.

J, 18 octets

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

Approche directe basée sur le processus décrit dans le défi.

Usage

   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

Explication

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

usSMGQ]Q

Essayez-le en ligne!

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ée, 7 octets

Rapide, avant que Dennis ne réponde (jk)

WR€F$³¡

Essayez-le en ligne!

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 octets

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

Renvoie une fonction anonyme prenant n en entrée.

Remplace chaque entrée k dans A par [1..k], répète le processus n fois, en commençant par A = [n].

Swift 3, 58 octets

Destiné à fonctionner directement dans une aire de jeux, avec n réglé sur l'entrée:

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

Non golfé, avec la notation la plus courte à la main inversée:

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 octets

Procédure

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

Usage

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

Exemple de sortie:

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

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

Edit: 1 octet enregistré grâce à @xnor. Enregistré 2 octets grâce à @ Dennis ♦.

Utilitaires Bash + GNU, 49

• 1 octet enregistré grâce à @Dennis.

Fonctions récursives canalisées FTW!

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

nest transmis sur la ligne de commande. La sortie est séparée par des sauts de ligne.

L'utilisation des ddstatistiques de causes à envoyer à STDERR. Je pense que c'est OK, mais sinon, ddpeut être remplacé par catau coût de 1 octet supplémentaire.

Perl 5, 53 octets

Un sous-programme:

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

Voyez-le en action comme

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

Rubis, 61 octets

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

PHP, 100 98 octets

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

Dans chaque itération, créez une copie temporaire en boucle de 1 .. (première valeur supprimée) jusqu'à $a soit vide.

Ces deux sont toujours et resteront probablement à 100 octets:

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

Dans chaque boucle d'itération en arrière à travers le tableau en remplaçant chaque nombre par une plage.

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

Dans chaque boucle d'itération à travers le tableau, augmentez l'index par le numéro précédent et remplacez chaque élément indexé par une plage