NGeben Sie bei einer gegebenen Zahl ein rechtwinkliges NxN-Dreieck aus, in dem jede Zeile imit Zahlen bis zu gefüllt ist i.

Beispiel

n = 0

(keine Leistung)

n = 4

1
1 2
1 2 3
1 2 3 4

n = 10

1
1 2
1 2 3
.
.
.
1 2 3 4 5 6 7 8 9 10

(keine Ausrichtung erforderlich)

n = N

1
1 2
1 2 3
.
.
.
1 2 3 4 .... N

Am Ende jeder Zeile steht kein Leerzeichen.

Die geringste Anzahl von Bytes gewinnt, und Standardlücken sind nicht zulässig.

Joe , 5 3 Bytes (+2 oder +3 für -tFlag)

Nun, anscheinend habe ich nicht das volle Potenzial von Joe ausgeschöpft. Dies war möglich, als ich dies zum ersten Mal gepostet habe.

\AR

Hier Rgibt der Bereich von 0 bis n, exklusiv. Nimmt \Adann aufeinanderfolgende Präfixe davon ( Aist die Identitätsfunktion). Beispiele:

Mit -tFlag (Hinweis: Dies ist jetzt die Standardausgabe, auch ohne Flag):

   (\AR)5
0
0 1
0 1 2
0 1 2 3
0 1 2 3 4
   \AR5
0
0 1
0 1 2
0 1 2 3
0 1 2 3 4
   \AR2
0
0 1
   \AR1
0
   \AR0

Ohne es:

   \AR5
[[0], [0, 1], [0, 1, 2], [0, 1, 2, 3], [0, 1, 2, 3, 4]]
   (\AR)5
[[0], [0, 1], [0, 1, 2], [0, 1, 2, 3], [0, 1, 2, 3, 4]]
   \AR2
[[0], [0, 1]]
   \AR1
[[0]]
   \AR0
[]

Die Regeln wurden ein wenig geändert. Mein alter Code hat sich mit N = 0 nicht richtig verhalten. Außerdem könnte die Ausgabe jetzt nur eine verschachtelte Liste sein, sodass -tsie gelöscht werden kann.

1R1+R

Nun Rngibt es einen Bereich von 0 bis n, exklusiv. Wenn 0 angegeben wird, wird eine leere Liste zurückgegeben. 1+Fügt jedem Element dieses Bereichs 1 hinzu. 1Rordnet die Werte den Bereichen 1 bis x zu. Wenn leere Lügen zugeordnet sind, werden leere Listen zurückgegeben.

Beispielausgabe:

   1R1+R0
[]
   1R1+R5
[[1], [1, 2], [1, 2, 3], [1, 2, 3, 4], [1, 2, 3, 4, 5]]

Update: Mir ist gerade etwas aufgefallen. Die Funktion ordnet automatisch Elementen mit Rang 0 zu. Das folgende Beispiel wird mit -tflag ausgeführt.

   1R1+R3 5 8
1
1 2
1 2 3

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
1 2 3 4 5 6 7
1 2 3 4 5 6 7 8

Alt: 5 Bytes (mit dem -tFlag)

1R1R

Dies ist eine anonyme Funktion, die eine Zahl aufnimmt, eine Liste von 1 bis N ( 1Rn) erstellt und diese Werte dem vorhergehenden Bereich zuordnet, wobei für jedes Element des Bereichs 1 bis N ein Bereich von 1 bis x angegeben wird.

Das -tFlag gibt die Ausgabe als J-ähnliche Tabelle aus.

   1R1R5
1
1 2
1 2 3
1 2 3 4
1 2 3 4 5

Hinweis: Die Sprache ist sehr neu und nicht vollständig, aber die neueste Version wurde vor dieser Herausforderung veröffentlicht.

Python 3, 48 45 Bytes

f=lambda n:n and[f(n-1),print(*range(1,n+1))]

Hurra für Nebenwirkungen.

APL, 5

⍪⍳¨⍳⎕

erzeugt einen Vektor 1..n und für jedes Element einen anderen solchen Vektor.

Dann macht ⍪ aus allen Vektoren eine Spalte. Dies vermeidet das Problem mit nachgestellten Leerzeichen.

Probieren Sie es auf tryapl.org

Ältere Lösung:

{⎕←⍳⍵}¨⍳⎕

Erzeugt einen Vektor 1..n.

{⎕ ← ⍳⍵} ist eine Funktion, die für jedes (¨) Element einen Vektor 1..n in einer separaten Zeile ausgibt

Dieser kann leider nicht auf tryapl.org ausprobiert werden, da ⎕ ← dort nicht funktioniert.

J, 27 Bytes

J ist nicht gut mit numerischer Ausgabe ohne Array. Diese Funktion erstellt eine korrekt formatierte Zeichenfolge aus den Zahlen.

   ;@(<@,&LF@":@:>:@:i.@>:@i.)

   (;@(<@,&LF@":@:>:@:i.@>:@i.)) 4
1
1 2
1 2 3
1 2 3 4

Probieren Sie es hier online aus.

PHP, 53 Bytes

Edit 2: Ismael Miguel schlug vor, von der Eingabe zu lesen, anstatt eine Funktion zu definieren. Die Punktzahl für PHP beträgt jetzt 53 Byte:

for($a=1;@$i++<$n=$argv[1];$a.=" ".($i+print"$a\n"));

Und noch einmal, es kann verbessert werden, wenn PHP so konfiguriert ist, dass Fehler ignoriert werden (52 Bytes):

for($a=1;$i++<$n=$argv[1];$a.=" ".($i+print"$a\n"));
for($a=1;$i++<$n=$_GET[n];$a.=" ".($i+print"$a\n"));

Bearbeiten: Austin schlug eine 60-Byte-Version in den Kommentaren vor:

function f($n){for($a=1;@$i++<$n;$a.=" ".($i+print"$a\n"));}

Was verbessert werden kann, wenn wir keine PHP-Fehler anzeigen (59 Bytes):

function f($n){for($a=1;$i++<$n;$a.=" ".($i+print"$a\n"));}

$aSpeichert die nächste Zeile, die gedruckt wird, und jedes Mal, wenn sie gedruckt wird, werden ein Leerzeichen und die nächste Zahl (die printimmer zurückkehrt 1) damit verknüpft.

Rekursive Funktionen (65 Bytes):

function f($n){$n>1&&f($n-1);echo implode(' ',range(1,$n))."\n";}
function f($n){$n>1&&f($n-1);for(;@$i++<$n;)echo$i,' ';echo"\n";}   // Using @ to hide notices.

Kürzere rekursive Funktion mit deaktivierter Fehlerberichterstattung (64 Byte):

function f($n){$n>1&&f($n-1);for(;$i++<$n;)echo$i,' ';echo"\n";}

Noch kürzere rekursive Funktion mit deaktivierter Fehlerberichterstattung und einer Leerzeile vor der tatsächlichen Ausgabe (62 Byte):

function f($n){$n&&f($n-1);for(;$i++<$n;)echo$i,' ';echo"\n";}

Nur zum Spaß, nicht-rekursive Funktionen:

function f($n){for($i=0;$i<$n;print implode(' ',range(1,++$i))."\n");}    // 70 bytes
function f($n){for(;@$i<$n;print implode(' ',range(1,@++$i))."\n");}      // 68 bytes, hiding notices.
function f($n){for(;$i<$n;print implode(' ',range(1,++$i))."\n");}        // 66 bytes, error reporting disabled.

CJam, 13 12 Bytes

ri{),:)S*N}/

Wie es funktioniert :

ri{       }/     "Run the block input number of times with iteration index from 0 to N-1";
   )             "Increment the iteration index (making it 1 to N)";
    ,            "Get an array of 0 to iteration index";
     :)          "Increment each of the above array members by 1";
       S*        "Join all above array numbers with space";
         N       "Add a new line. After all iterations, things are automatically printed";

Probieren Sie es hier online aus

Pyth, 9 Bytes

VQjdr1hhN

Wirklich gedacht, dass dies kürzer gemacht werden kann, aber es scheint nicht so.

Probieren Sie es online aus .

            Q = input()
VQ          For N in [0, 1, ..., Q-1]:
    r1hhN       create list [1, ..., N+1+1-1]
  jd            print joined with spaces

JavaScript (ES6) 49 52

Eine so einfache Aufgabe, ich frage mich, ob dies in JS kürzer gemacht werden kann (Update: ja, mit Rekursion)

Rekursiv 49

f=n=>alert((r=w=>n-i++?w+'\n'+r(w+' '+i):w)(i=1))

Iteraive 52

f=n=>{for(o=r=i=1;i++<n;o+='\n'+r)r+=' '+i;alert(o)}

Java, 85 84 Bytes

Dies ist in Java überraschend kurz.

void a(int a){String b="";for(int c=0;c++<a;System.out.println(b+=(c>1?" ":"")+c));}

Eingerückt:

void a(int a){
    String b="";
    for(int c=0;
        c++<a;
        System.out.println(
                b+=(c>1?" ":"")+c
        ));
}

1 Byte dank Bigtoes / Geobits

Prolog - 119

h(N):-setof(X,(between(1,N,K),setof(Y,between(1,K,Y),X)),[L]),k(L),nl,fail.
k([A|B]):-write(A),(B=[];write(" "),k(B)).

Python 2 - 62 54 65 Bytes

def f(n):
 for x in range(n):print' '.join(map(str,range(1,x+2)))

J, 9 Zeichen

Als stillschweigendes, monadisches Verb.

[:":\1+i.

• i. y- die Nummern von 0bis y - 1.
• 1 + i. y- die Nummern von 1bis y.
• ": y- Der yals Zeichenfolge dargestellte Vektor .
• ":\ y- Jedes Präfix wird yals Zeichenfolge dargestellt.
• ":\ 1 + i. y - jedes Präfix der Nummern von 1 bis wird yals Zeichenmatrix dargestellt.

> <> (Fisch) , 40 37 + 3 = 40 Bytes

&1>:&:&)?;1\
(?v:n" "o1+>}:{:@
ao\~1+

Wiederum macht sich> <> bei einer anderen Zifferndruckübung anständig. Mit dem -vFlag für die Eingabe ausführen, z

py -3 fish.py -v 4

Erläuterung

&               Put n in register
1               Push 1 (call this "i")

[outer loop]

:&:&)?          If i > n...
;                 Halt
1                 Else push 1 (call this "j")

[inner loop]

}:{:@(?         If j > i...
~1+ao             Pop j, print newline, increment i and go to start of outer loop
:n" "o1+          Else print j, print a space, increment j and go to start of inner loop

C (ohne Schleifen, ja!) - 72 Bytes

b(n,c){if(n){b(n-1,32);printf("%d%c",n,c);}}r(n){if(n){r(n-1);b(n,10);}}

Dadurch wird eine Funktion erstellt r(n), die folgendermaßen verwendet werden kann:

main(){ r(5); }

Sehen Sie es in Aktion, hier auf tutorialspoint.com

Es erfordert ein paar Tricks, die sich leicht erklären lassen. Ich denke, es kann stark verbessert werden.

Python 2 - 72

>>> def p(N):print'\n'.join(' '.join(map(str,range(1,i+2)))for i in range(N))
... 
>>> p(5)
1
1 2
1 2 3
1 2 3 4
1 2 3 4 5

Perl, 28

Liest den Parameter von stdin.

@x=1..$_,print"@x
"for 1..<>

Von der Kommandozeile:

perl -E'$,=$";say 1..$_ for 1..<>'

Aber ich weiß jetzt nicht, wie ich das zählen soll (wahrscheinlich zwischen 25 und 29).

Python

import string
N,s=int(input()),list(string.digits)
for i in range(1,N+1):
    print(' '.join(s[1:i+1]))

Golfscript 14

,{2+,1>' '*n}/

Erwartet, dass die Eingabenummer auf dem Stapel vorhanden ist.

Online Beispiel: Link

Clip , 16

Jm[ijkw,1iwS},1n

Erläuterung

J                   .- join with newlines                           -.
 m[i        },1n    .- map numbers from 1 to numeric value of input -.
    jkw   wS        .- join with spaces                             -.
       ,1i          .- numbers from 1 to index                      -.

Gehen, 93 81 78 93 90 Bytes

func r(n int)(s string){s=string(n+48);if n!=1{s=r(n-1)+" "+s};println(s);return}

Aktuelle ungolfed

func r(n int) (s string) {
    // Convert n to a string, we do not have to initialize s since
    // we hijacked the return value.
    // Numbers in the ascii table starts at 48
    s = string(n | 48)
    // Unless we are on our last iteration, we need previous iterations,
    // a space and our current iteration
    if n != 1 {
        // Collect the result of previous iteration for output
        s = r(n-1) + " " + s
    }
    println(s)
    // We can use a naked return since we specified the
    // name of our return value in the function signature
    return
}

Wenn wir N> 9 verarbeiten müssen, können wir das Folgende bei 78 Bytes verwenden, es erfordert jedoch den Import des fmtPakets.

func r(n int)(s string){s=Sprint(n);if n!=1{s=r(n-1)+" "+s};Println(s);return}

Wenn wir die Import-Anweisung einschließen, bin ich jetzt wieder bei meiner Initiale 93 92 90 Bytes

import."fmt";func r(n int)(s string){s=Sprint(n);if n>1{s=r(n-1)+" "+s};Println(s);return}

Testen Sie es online hier: http://play.golang.org/p/BWLQ9R6ilw

Die Version mit fmtist hier: http://play.golang.org/p/hQEkLvpiqt

ZX / Sinclair BASIC - 39 Bytes

ZX Basic verwendet 1 Byte pro Schlüsselwort (alle Wörter in Großbuchstaben), um die Bytegröße etwas zu verringern ...

1 INPUT n:FOR i=1 TO n:FOR j=1 TO i:PRINT j;" ";:NEXT j:PRINT:NEXT i

Mit n = 8

R 28

for(i in 1:scan())print(1:i)

TI-Basic, 28 Bytes

Input N
For(I,1,N
randIntNoRep(1,N->L1
SortA(L1
Disp L1
End

C 89 Zeichen

// 90 characters
f(int n){int a=1,b;for(;n--;++a){for(b=0;b<a;++b)printf("%c%d",(!!b)*' ',b+1);puts("");}}

Um Verwirrung zu beseitigen puts("");. Dies druckt einfach ein Newline-Zeichen (wie hier zu sehen ):

Beachten Sie, dass puts nicht nur stdout als Ziel verwendet, sondern am Ende automatisch ein Zeilenumbruchzeichen anfügt (was fputs nicht tut).

Ich habe es mit @ TheBestOnes Java-Algorithmus etwas kürzer gemacht:

// 89 characters
f(int a){char b[999]="",*p=b+1;int c=0;for(;a--&&(sprintf(b,"%s %d",b,++c)&&puts(p)););}

Perl: 34 Zeichen

print"@$_\n"for map[1..$_],1..$_;

Dieser Code erhält die Eingangsnummer, die durch die spezielle Variable geliefert wird $_.

94 Bytes

Geschrieben als anonyme Funktion, die eine Zeichenfolge zurückgibt, die von der Spezifikation nicht unzulässig zu sein scheint.

n=>String.Join("\n\n",Enumerable.Range(1,n).Select(l=>String.Join(" ",Enumerable.Range(1,l))))

Hier ist eine ungolfed Version (Kommentare werden in BDCA-Reihenfolge gelesen):

n =>
    String.Join("\n\n",                    //...then join it together with newlines.
        Enumerable.Range(1, n).Select(l => //For each l from 1 to n, ...
                String.Join(" ",              //...and join it with spaces, ...
                    Enumerable.Range(1, l)    //...get the range from 1 to l, ...

Bash + Coreutils, 26 Bytes

seq $1|sed "x;G;s/\n/ /;h"

• seq generiert einfach die Zahlen 1 bis n
• sed Speichert die gesamte Ausgabe für eine bestimmte Zeile im Haltebereich und fügt die nächste Zeile hinzu.

Haskell, 62-57 Bytes

e=enumFromTo 1
f=putStr.unlines.map(unwords.map show.e).e

Punktfreier Stil. Anwendungsbeispiel:

Prelude> f 5
1
1 2
1 2 3
1 2 3 4
1 2 3 4 5

Mathematica, 32

Print@Row[Range@i," "]~Do~{i,#}&

Scala, 73 65 62 Bytes

(n:Int)=>print(1 to n map(1 to _ mkString " ") mkString "\n")

Ungolfed

def printNumberTriangle(n: Int): Unit = {
  def rowString(m: Int): String = 1.to(m).mkString(" ")
  print(1.to(n).map(rowString).mkString("\n"))
}