Dado un número N, genera un triángulo en ángulo recto NxN, donde cada fila ise llena con números hasta i.

Ejemplo

n = 0

(ninguna salida)

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

(no se necesita alineación)

n = N

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

No hay espacio final al final de cada línea.

Se gana el menor número de bytes y no se permiten las lagunas estándar.

Joe , 5 3 bytes (+2 o +3 para -tbandera)

Bueno, aparentemente no utilicé todo el potencial de Joe. Esto fue posible cuando publiqué esto por primera vez.

\AR

Aquí, Rda el rango de 0 a n, exclusivo. Luego \Atoma sucesivos prefijos ( Aes la función de identidad). Ejemplos:

Con -tbandera (nota: esta es ahora la salida estándar incluso sin la bandera):

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

Sin ello:

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

Las reglas cambiaron un poco. Mi código anterior no se comportó correctamente con N = 0. Además, ahora la salida podría ser solo una lista anidada, por lo que -tse puede descartar.

1R1+R

Ahora, Rnda un rango de 0 a n, exclusivo. Si se le da 0, devuelve una lista vacía. 1+agrega 1 a cada elemento de ese rango. 1Rasigna los valores a rangos de 1 a x. Los pasivos vacíos, cuando se asignan, devuelven listas vacías.

Salida de ejemplo:

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

Actualización: acabo de notar algo. La función se asigna automáticamente a elementos de rango 0. El siguiente ejemplo se ejecuta con -tflag.

   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

Antiguo: 5 bytes (con la -tbandera)

1R1R

Esta es una función anónima que toma un número, crea una lista de 1 a N ( 1Rn) y asigna esos valores al rango anterior, dando un rango de 1 a x para cada elemento del rango 1 a N.

La -tbandera da salida como una tabla tipo J.

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

Nota: el lenguaje es muy nuevo y no está completo, pero la última versión se lanzó antes de este desafío.

Python 3, 48 45 bytes

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

Hurra por los efectos secundarios.

APL, 5

⍪⍳¨⍳⎕

crea un vector 1..n y para cada elemento otro vector de este tipo.

Entonces ⍪ forma una columna con todos los vectores. Esto evita el problema con los espacios en blanco finales.

Pruébalo en tryapl.org

Solución anterior:

{⎕←⍳⍵}¨⍳⎕

Crea un vector 1..n

{⎕ ← ⍳⍵} es una función que genera para cada elemento (¨) un vector 1..n en una línea separada

Desafortunadamente, este no se puede probar en tryapl.org, porque ⎕ ← no funciona allí.

J, 27 bytes

J no es bueno con salida numérica sin matriz. Esta función crea una cadena con el formato adecuado a partir de los números.

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

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

Pruébelo en línea aquí.

PHP, 53 bytes

Edición 2: Ismael Miguel sugirió leer desde la entrada en lugar de definir una función, por lo que la puntuación ahora es de 53 bytes para PHP:

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

Y una vez más, se puede mejorar si PHP está configurado para ignorar errores (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"));

Editar: Austin sugirió una versión de 60 bytes en los comentarios:

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

Que se puede mejorar si no mostramos errores de PHP (59 bytes):

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

$aalmacena la siguiente línea que se imprimirá, y cada vez que se imprime un espacio y el siguiente número ( printsiempre devuelve 1) se concatenan.

Funciones recursivas (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.

Función recursiva más corta, con informe de errores deshabilitado (64 bytes):

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

Función recursiva aún más corta, con informe de errores deshabilitado y una línea vacía antes de la salida real (62 bytes):

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

Solo por diversión, funciones no recursivas:

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

Cómo funciona :

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

Pruébalo en línea aquí

Pyth, 9 bytes

VQjdr1hhN

Realmente pensé que esto se puede hacer más corto, pero no lo parece.

Pruébalo en línea .

            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

Una tarea tan simple, me pregunto si esto se puede acortar en JS (Actualización: sí, usando recursividad)

Recursivo 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

Esto es sorprendentemente corto en Java.

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

Sangrado:

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

1 byte gracias a Bigtoes / Geobits

Prólogo - 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 62 54 65 bytes

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

J, 9 caracteres

Como verbo tácito, monádico.

[:":\1+i.

• i. y- los números de 0a y - 1.
• 1 + i. y- los números de 1a y.
• ": y- el vector yrepresentado como una cadena.
• ":\ y- cada prefijo de yrepresentado como una cadena.
• ":\ 1 + i. y- cada prefijo de los números de 1a yrepresentados como una matriz de caracteres.

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

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

Una vez más,> <> funciona decentemente bien en otro ejercicio de impresión de números. Ejecutar con la -vbandera de entrada, por ejemplo

py -3 fish.py -v 4

Explicación

&               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 (sin bucles, ¡sí!) - 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);}}

Esto crea una función r(n)que se puede usar de esta manera:

main(){ r(5); }

Véalo en acción, aquí en tutorialspoint.com

Requiere unos pocos trucos fáciles de explicar. Creo que se puede mejorar mucho.

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

Lee el parámetro de stdin.

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

Desde la línea de comando:

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

pero ahora no sé cómo contar eso (probablemente entre 25 y 29).

Pitón

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

Espera que el número de entrada esté presente en la pila.

Ejemplo en línea: enlace

Clip , 16

Jm[ijkw,1iwS},1n

Explicación

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

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

Actual sin golf

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
}

Si necesitamos manejar N> 9, podemos usar lo siguiente en 78 bytes, sin embargo, requiere importar el fmtpaquete.

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

Si incluimos la declaración de importación, ahora estoy de vuelta en mi inicial 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}

Pruébelo en línea aquí: http://play.golang.org/p/BWLQ9R6ilw

La versión con fmtestá aquí: http://play.golang.org/p/hQEkLvpiqt

ZX / Sinclair BASIC - 39 bytes

ZX Basic utiliza 1 byte por palabra clave (todas las palabras en mayúscula), por lo que ayuda a mantener un poco el tamaño del byte ...

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

Usando 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 caracteres

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

Para eliminar la confusión sobre puts("");. Esto simplemente imprime un carácter de nueva línea (como se ve aquí ):

Tenga en cuenta que no solo difiere de fputs en que usa stdout como destino, sino que también agrega un carácter de nueva línea al final automáticamente (que fputs no).

Lo hice un poco más corto con el algoritmo java de @ TheBestOne:

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

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

Este código obtiene el número de entrada proporcionado a través de la variable especial $_.

C # - 94 bytes

Escrito como una función anónima que devuelve una cadena, que no parece estar prohibida por la especificación.

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

Aquí hay una versión sin golf (los comentarios se leen en orden BDCA):

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 simplemente genera los números 1 a n
• sed guarda la salida completa para una línea dada en el espacio de espera y luego agrega la siguiente línea.

Haskell, 62 57 bytes

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

Estilo sin puntos. Ejemplo de uso:

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

Sin golf

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