숫자가 주어지면 NNxN 직각 삼각형을 출력하십시오. 여기서 각 행 i은 최대 숫자까지 채워집니다 i.

예

n = 0

(출력 없음)

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

(정렬 불필요)

n = N

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

각 줄 끝에는 후행 공백이 없습니다.

최소 바이트 수가 이기고 표준 허점은 허용되지 않습니다.

조 , 5 3 바이트 ( -t플래그의 경우 +2 또는 +3 )

글쎄, 나는 분명히 Joe의 모든 잠재력을 활용하지 않았다. 내가 이것을 처음 게시했을 때 가능했습니다.

\AR

이리, R 0에서 n까지의 범위를 배타적으로 제공합니다. 그런 다음 \A접두사를 연속적으로 사용합니다 ( A식별 기능입니다). 예 :

함께 -t플래그 (참고 :이 심지어 플래그없이 표준 출력은 이제) :

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

그것없이 :

   \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
[]

규칙이 조금 바뀌 었습니다. 이전 코드는 N = 0으로 올바르게 작동하지 않았습니다. 또한 이제 출력은 중첩 목록 일 -t수 있으므로 삭제할 수 있습니다.

1R1+R

이제 Rn0에서 n까지의 범위를 배타적으로 제공합니다. 0을 지정하면 빈 목록을 반환합니다. 1+해당 범위의 모든 요소에 1을 추가합니다. 1R값을 1에서 x까지의 범위로 매핑합니다. 빈 리트는 매핑 될 때 빈 목록을 반환합니다.

출력 예 :

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

업데이트 : 방금 뭔가를 발견했습니다. 이 함수는 자동으로 순위 0 요소에 매핑됩니다. 다음 예제는 -t플래그 와 함께 실행됩니다 .

   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

Old : 5 바이트 ( -t 플래그 포함)

1R1R

이것은 숫자를 취하는 익명 함수이며 1에서 N까지의 목록을 만듭니다.1Rn ) 해당 값을 이전 범위에 매핑하여 1에서 N 범위의 각 항목에 대해 1에서 x까지의 범위를 지정 .

-t플래그는 J 형 테이블로서 출력을 제공한다.

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

참고 :이 언어는 매우 새롭고 완전하지는 않지만이 문제 이전에 최신 버전이 릴리스되었습니다.

파이썬 3, 48 45 바이트

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

부작용을위한 후 레이.

APL, 5

⍪⍳¨⍳⎕

벡터 1..n을 만들고 각 요소마다 다른 벡터를 만듭니다.

그런 다음 ⍪는 모든 벡터에서 열을 만듭니다. 이렇게하면 공백이 뒤 따르는 문제를 피할 수 있습니다.

tryapl.org에서 사용해보십시오

이전 솔루션 :

{⎕←⍳⍵}¨⍳⎕

벡터를 만듭니다. 1.n

{⎕ ← ⍳⍵}는 각 (¨) 요소에 대해 별도의 라인에 벡터 1..n을 출력하는 함수입니다

불행히도 tryapl.org에서는 시도 할 수 없습니다. ⎕ ←는 작동하지 않기 때문입니다.

J, 27 바이트

J는 비 배열 숫자 출력에 적합하지 않습니다. 이 함수는 숫자에서 올바른 형식의 문자열을 만듭니다.

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

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

여기에서 온라인으로 사용해보십시오.

PHP, 53 바이트

편집 2 : Ismael Miguel 은 함수를 정의하는 대신 입력에서 읽을 것을 제안 했으므로 PHP의 점수는 이제 53 바이트입니다.

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

PHP가 오류 (52 바이트)를 무시하도록 구성된 경우 다시 한 번 개선 할 수 있습니다.

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

편집 : 오스틴 은 주석에서 60 바이트 버전을 제안했습니다.

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

PHP 오류 (59 바이트)를 표시하지 않으면 개선 될 수 있습니다.

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

$a인쇄 될 다음 행을 저장하고, 인쇄 될 때마다 공백과 다음 숫자 ( print항상 리턴 1)가 연결됩니다.

재귀 함수 (65 바이트) :

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.

오류보고가 비활성화 된 짧은 재귀 함수 (64 바이트) :

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

더 짧은 재귀 함수, 오류보고가 비활성화되고 실제 출력 전의 빈 줄 (62 바이트) :

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

재귀가 아닌 재미를 위해 :

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 바이트

ri{),:)S*N}/

작동 방식 :

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

여기에서 온라인으로 사용해보십시오

Pyth, 9 바이트

VQjdr1hhN

실제로 이것이 더 짧을 수 있다고 생각했지만 그렇게 보이지는 않습니다.

온라인으로 사용해보십시오 .

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

자바 스크립트 (ES6) 49 52

이러한 간단한 작업, JS에서 이것이 더 짧아 질 수 있는지 궁금합니다 (업데이트 : 예, 재귀 사용)

재귀 49

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

반복적 인 52

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

자바, 85 84 바이트

이것은 Java에서 놀랍도록 짧습니다.

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

들여 쓰기 :

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

Bigtoes / Geobits 덕분에 1 바이트

프롤로그-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)).

파이썬 2- 62 54 65 바이트

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

J, 9 자

암묵적인 동사로.

[:":\1+i.

• i. y-에서 숫자 0에 y - 1.
• 1 + i. y-에서 숫자 1에 y.
• ": y– y문자열로 표시 되는 벡터
• ":\ y– 각 접두사 y는 문자열 로 표시됩니다.
• ":\ 1 + i. y– 숫자의 각 접두사 가 문자 행렬 1로 y표시됩니다.

><> (Fish), 40 37 + 3 = 40 bytes

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

Once again, ><> does decently well at another number printing exercise. Run with the -v flag for input, e.g.

py -3 fish.py -v 4

Explanation

&               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 (with no loops, yeah!) - 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);}}

This creates a function r(n) that can be used this way:

main(){ r(5); }

See it in action, here on tutorialspoint.com

It requires a very few tricks easily explained. I think it can be greatly improved.

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

Reads the parameter from stdin.

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

From the command line:

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

but I don't now how to count that (probably between 25 and 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}/

Expects the input number to be present on the stack.

Online example: link

Clip, 16

Jm[ijkw,1iwS},1n

Explanation

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

Go, 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}

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

If we need to handle N > 9 we can use the following at 78 bytes, however it requires importing the fmt package.

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

If we include the import statement I'm now back at my initial 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}

Test it online here: http://play.golang.org/p/BWLQ9R6ilw

The version with fmt is here: http://play.golang.org/p/hQEkLvpiqt

ZX / Sinclair BASIC - 39 bytes

ZX Basic uses 1 byte per keyword (all the uppercase words), so helps to keep the byte size down a bit...

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

Using 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 characters

// 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("");}}

To eliminate confusion about puts("");. This simply prints a newline character (as seen here):

Notice that puts not only differs from fputs in that it uses stdout as destination, but it also appends a newline character at the end automatically (which fputs does not).

I got it slightly shorter with @TheBestOne's java algorithm:

// 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 characters

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

This code gets the input number supplied through the special variable $_.

C# - 94 bytes

Written as an anonymous function that returns a string, which doesn't seem to be disallowed by the spec.

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

Here's an ungolfed version (comments are read in BDCA order):

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 simply generates the numbers 1 to n
• sed saves the entire output for a given line in the hold space, and then appends the next line to it.

Haskell, 62 57 bytes

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

Point-free style. Usage example:

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"))
}