Для Nзаданного числа выведите NxN прямоугольный треугольник, где каждая строка iзаполнена числами до i.

пример

n = 0

(нет выхода)

n = 4

1
1 2
1 2 3
1 2 3 4

п = 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 байта (+2 или +3 для -tфлага)

Ну, очевидно, я не использовал весь потенциал Джо. Это было возможно еще тогда, когда я впервые опубликовал это.

\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

Теперь Rnдает диапазон от 0 до 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

Старый: 5 байт (с -tфлагом)

1R1R

Это анонимная функция, которая принимает число, создает список от 1 до N ( 1Rn) и отображает эти значения в предыдущий диапазон, давая диапазон от 1 до x для каждого элемента в диапазоне от 1 до N.

-tФлаг дает выходной сигнал в виде J-подобной таблицы.

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

Примечание: язык очень новый и не полный, но перед этим испытанием была выпущена последняя версия.

Python 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: Исмаэль Мигель предложил читать из ввода вместо определения функции, поэтому оценка теперь составляет 53 байта для PHP:

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

JavaScript (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)}

Java, 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
        ));
}

1 байт благодаря Bigtoes / Geobits

Пролог - 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 байт

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представлен в виде матрицы символов.

> <> (Рыба) , 40 37 + 3 = 40 байт

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

Еще раз,> <> неплохо справляется с другим упражнением по печати чисел. Запустите с -vфлагом для ввода, например

py -3 fish.py -v 4

объяснение

&               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 (без петель, да!) - 72 байта

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

Это создает функцию, r(n)которую можно использовать следующим образом:

main(){ r(5); }

Посмотрите это в действии, здесь на tutorialspoint.com

Требуется очень мало трюков, которые легко объяснить. Я думаю, что это может быть значительно улучшено.

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

Читает параметр из стандартного ввода.

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

Из командной строки:

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

но я не знаю, как считать это (вероятно, между 25 и 29).

питон

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

Ожидает, что входной номер будет присутствовать в стеке.

Пример в сети: ссылка

клип , 16

Jm[ijkw,1iwS},1n

объяснение

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

Идти, 93 81 78 93 90 байт

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

Текущий негольфированный

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
}

Если нам нужно обработать N> 9, мы можем использовать следующее в 78 байтах, однако это требует импорта fmt пакета.

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

Если мы включим оператор импорта, я вернусь к моей первоначальной 93 92 90 байт

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

Проверьте это онлайн здесь: http://play.golang.org/p/BWLQ9R6ilw

Версия с fmtздесь: http://play.golang.org/p/hQEkLvpiqt

ZX / Sinclair BASIC - 39 байт

ZX Basic использует 1 байт на ключевое слово (все заглавные слова), поэтому помогает немного уменьшить размер байта ...

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

Используя n = 8

Р, 28

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

TI-Basic, 28 байтов

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

C, 89 символов

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

Чтобы устранить путаницу по поводу puts("");. Это просто печатает символ новой строки (как видно здесь ):

Обратите внимание, что put не только отличается от fputs тем, что он использует stdout в качестве места назначения, но также автоматически добавляет символ новой строки в конце (чего не делает fputs).

Я получил немного короче с Java-алгоритмом @ 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 символа

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

Этот код получает входной номер, указанный через специальную переменную $_.

C # - 94 байта

Написано как анонимная функция, которая возвращает строку, которая не запрещена спецификацией.

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

Вот негольфированная версия (комментарии читаются в порядке 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 байт

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

• seq просто генерирует числа от 1 до п
• sed сохраняет весь вывод для данной строки в области удержания, а затем добавляет к ней следующую строку.

Haskell, 62 57 байт

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

Бессмысленный стиль. Пример использования:

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

Математика, 32

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

Scala, 73 65 62 байта

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