Definition

Definieren Sie das n- ^te Array der CURR-Sequenz wie folgt.

1. Beginnen Sie mit dem Singleton-Array A = [n] .

2. Ersetzen Sie für jede Ganzzahl k in A den Eintrag k durch k natürliche Zahlen und zählen Sie dabei von 1 bis k auf .

3. Wiederholen Sie den vorherigen Schritt n - 1 weitere Male.

Wenn beispielsweise n = 3 ist , beginnen wir mit dem Array [3] .

Wir ersetzen 3 durch 1, 2, 3 und erhalten [1, 2, 3] .

Wir ersetzen jetzt 1 , 2 und 3 durch 1 ; 1, 2 und 1, 2, 3 (bzw.), was [1, 1, 2, 1, 2, 3] ergibt .

Schließlich führen wir die gleichen Ersetzungen wie im vorherigen Schritt für alle sechs Ganzzahlen im Array durch und ergeben [1, 1, 1, 2, 1, 1, 2, 1, 2, 3] . Dies ist das dritte CURR-Array.

Aufgabe

Schreiben Sie ein Programm einer Funktion, die bei einer streng positiven Ganzzahl n als Eingabe das n- ^te CURR-Array berechnet .

Die Ausgabe muss eine flache Liste sein (und ein von einer Funktion zurückgegebenes Array, eine Zeichenfolgendarstellung der Array-Syntax Ihrer Sprache, durch Leerzeichen getrennt usw.).

Das ist Code-Golf . Möge der kürzeste Code in Bytes gewinnen!

Testfälle

 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]

Gelee, 3 Bytes

R¡F

Probieren Sie es online aus

Erläuterung

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+"]")

Umfang Missbrauch! Beispielsweise wird für i=3die auszuwertende Zeichenfolge auf erweitert.

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

Trotz der Verwendung der Funktionseingabevariable ifür alles unterscheidet Python irgendwie jeden Iterationsindex als zu einem separaten Bereich gehörend, als ob der Ausdruck wäre

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

mit ider Eingabe in die Funktion.

05AB1E, 6 3 Bytes

DFL

Erklärt

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

Probieren Sie es online aus

3 Bytes gespart dank @Adnan

Retina , 33 Bytes

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

Ein- und Ausgabe in unary.

Probieren Sie es online!

Obwohl ich das geschlossene Formular für die damit verbundene Herausforderung nicht verwendet habe, war es überraschend schwierig, diese Antwort anzupassen.

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]

Dies ist nicht die kürzeste Lösung, zeigt aber eine interessante Methode:

• Schreiben Sie die ersten 2^(2*n-1)Zahlen binär auf
• Halten Sie die mit genau ndiejenigen
• Zählen Sie für jede Zahl die Anzahl der nachgestellten Nullen und addieren Sie 1.

Eigentlich 9 Bytes

;#@`♂RΣ`n

Probieren Sie es online!

Erläuterung:

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

Vielen Dank an Leaky Nun für ein Byte und Inspiration für weitere 2 Byte.

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

{∊⍳¨∘∊⍣⍵+⍵}

Prüfung:

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

Erläuterung:

• +⍵: beginnend mit ⍵,
• ⍣⍵: mache die folgenden ⍵Zeiten:
  • ⍳¨∘∊: Reduzieren Sie die Eingabe und erstellen Sie dann eine Liste [1..N] für jedes N in der Eingabe
• ∊: das Ergebnis davon abflachen

CJam, 14 Bytes

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

Teste es hier.

Erläuterung

_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 gespeichert mit etwas Inspiration von Essaris Antwort.

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

Ziemlich einfach: für die Eingabe xbeginnen wir mit {x}und dann die Anwendung , Rangeum es xmal ( Rangeist Listablewas bedeutet , dass es gilt automatisch für die ganzen Zahlen innerhalb beliebig verschachtelt Listen). Am Ende Flattendas Ergebnis.

Clojure, 59 Bytes

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

Erläuterung:

Wirklich direkter Weg, um das Problem zu lösen. Von innen heraus arbeiten:

(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)')

Dies ist nur eine einfache Übersetzung der Problembeschreibung in Code.

Bearbeiten: Ein Byte dank @Dennis gespeichert.

R 60 49 Bytes

Ziemlich unkomplizierte Verwendung von unlistund sapply.

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

Vielen Dank an @MickyT für das Speichern von 11 Bytes

php 121

Nicht wirklich viele Tricks stecken dahinter. Das Reduzieren eines Arrays in PHP ist nicht kurz, daher ist es notwendig, es zunächst flach zu bauen

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

Danke an nimi für das Speichern eines Bytes.

Eine pointfree Version ist länger (35 Bytes):

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

JavaScript (Firefox 30-57), 63 bis 60 Byte

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

Port von @ xnors Python-Antwort.

J, 18 Bytes

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

Einfacher Ansatz basierend auf dem in der Herausforderung beschriebenen Prozess.

Verwendung

   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

Erläuterung

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

Probieren Sie es 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.

Gelee, 7 Bytes

Schnell, bevor Dennis antwortet (jk)

WR€F$³¡

Probieren Sie es 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}

Gibt eine anonyme Funktion zurück, die n als Eingabe verwendet.

Ersetzt jeden Eintrag k in A durch [1..k], wiederholt den Vorgang n-mal, beginnend mit A = [n].

Schnelle 3, 58 Bytes

Soll direkt auf einem Spielplatz laufen, wobei n auf den Eingang gesetzt ist:

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

Ungolfed, wobei die meisten Kurznotationen rückgängig gemacht wurden:

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

Verfahren

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

Verwendung

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

Beispielausgabe:

[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

Bearbeiten: 1 Byte dank @xnor gespeichert. 2 Bytes gespart dank @ Dennis ♦.

Bash + GNU-Dienstprogramme, 49

• Dank @Dennis 1 Byte gespart.

Weitergeleitete rekursive Funktionen FTW!

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

nwird auf der Kommandozeile übergeben. Die Ausgabe ist durch Zeilenumbrüche getrennt.

Die Verwendung von ddbewirkt, dass Statistiken an STDERR gesendet werden. Ich denke, das ist in Ordnung, aber wenn nicht, ddkann gegen cateinen Aufpreis von 1 extra Byte ausgetauscht werden .

Perl 5, 53 Bytes

Ein Unterprogramm:

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

Sehen Sie es in Aktion als

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

Laufen Sie mit 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);

Erstellen Sie in jeder Iteration eine temporäre Kopierschleife von 1 .. (erster entfernter Wert) bis $aleer.

Diese beiden sind noch und werden wahrscheinlich bei 100 Bytes bleiben:

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

In jeder Iterationsschleife rückwärts durch das Array, wobei jede Zahl durch einen Bereich ersetzt wird.

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 jeder Iterationsschleife durch das Array wird der Index um die vorherige Nummer erhöht und jedes indizierte Element durch einen Bereich ersetzt