Генерация треугольника Паскаля

35

Треугольник Паскаля генерируется, начиная с 1 в первом ряду. В последующих строках число определяется суммой двух чисел, расположенных непосредственно над ним слева и справа.

Чтобы продемонстрировать, вот первые 5 строк треугольника Паскаля:

    1
   1 1
  1 2 1
 1 3 3 1
1 4 6 4 1

Соревнование

Учитывая ввод n (при условии, что он наиболее удобен на выбранном вами языке), сгенерируйте первые n строк треугольника Паскаля. Вы можете предположить, что п является целым числом от 1 до 25. Между каждой строкой и пробелом между числами должен быть разрыв строки, но помимо этого вы можете отформатировать его так, как вам нравится.

Это код-гольф , поэтому выигрывает самое короткое решение.

Пример ввода / вывода

> 1
1
> 9
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1
1 7 21 35 35 21 7 1
1 8 28 56 70 56 28 8 1
code-golf math combinatorics Питер Олсон
источник
NB. В некотором смысле это упрощенная версия « Распределение шаров»
Питер Тейлор,
@Peter Olson: Что вы думаете о том, как фанат с толпой говорит: «Вы можете отформатировать его так, как вам нравится»? Если бы я следовал его интерпретации, я мог бы побрить 18 персонажей.
Стивен Румбальски
@ StevenRumbalski Он в порядке. Между каждой строкой есть новая строка, и между каждым числом есть пробел, поэтому он соответствует критериям.
Питер Олсон
@ Питер Олсон: Спасибо за разъяснения. Как насчет предположения Томаса Т, что n уже определено?
Стивен Румбальски
4
@Gaffi Наверное, нет, принятие ответа заставляет меня чувствовать, что я заканчиваю конкурс и не одобряю новые и, возможно, лучшие ответы.
Питер Олсон

Ответы:

30

J , 12 символов

":@(!{:)\@i.

   i.5
0 1 2 3 4
   {: I.5
4
   (I.5) {: i.5
1 4 6 4 1
   (! {:) i.5
1 4 6 4 1
   ({!) \ I.5
1 0 0 0 0
1 1 0 0 0
1 2 1 0 0
1 3 3 1 0
1 4 6 4 1
   «: @ ({!) \ I.5
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
   ( ": @ ({!). \ @ Я)` ''
+ ---------------------------------- +
| + - + ------------------------------ + |
|| @ | + ------------------------- + - + ||
|| . || + - + --------------------- + | я |||
|| ||| \ | + ------------------- + || |||
|| ||| || + - + --------------- + ||| |||
|| ||| ||| @ | + - + ---------- + |||| |||
|| ||| ||| || ": | + - + ------ + ||||| |||
|| ||| ||| || || 2 | + - + - + |||||| |||
|| ||| ||| || || || | {: ||||||| |||
|| ||| ||| || || | + - + - + |||||| |||
|| ||| ||| || | + - + ------ + ||||| |||
|| ||| ||| | + - + ---------- + |||| |||
|| ||| || + - + --------------- + ||| |||
|| ||| | + ------------------- + || |||
|| || + - + --------------------- + | |||
|| | + ------------------------- + - + ||
| + - + ------------------------------ + |
+ ---------------------------------- +
ephemient
источник
1
J бьет GolfScript? Интересный. Я хотел бы увидеть объяснение этого кода, если у вас есть время.
Мистер Волшебник
4
Он уже разбит на части, но вот строка за строкой, если вам нужен дополнительный английский. Строка 1 i.5возвращает первые пять натуральных чисел. Строка 2 добавляет {:«Хвост» (возвратите последний). Строка 3 объединяет их с !«Out Of» (количество комбинаций). Строка 4 (!{:)i.5такая же. Факторинг Хук. Такова (!:)операция, которая преобразует первые n натуральных чисел в n-ю строку треугольника Паскаля. Строка 5 применяет его ко всем префиксам (обратная косая черта) в 0..4, но J заполняет неиспользуемые места 0, поэтому операция объединяется ( @) с операцией форматирования строки ":. Очень крутой J, проголосовал.
JB
@JB Нет! значит факториал тут? Также мы можем избавиться от @ справа.
defhlt
@ArtemIce Monadic !означает факториал; двоичный !подсчитывает комбинации. Окончательный @в ":@(!{:)\@i.только там , чтобы сделать это автономный глагол.
Эфимент
18

Python, 56 байт

a=[1];exec"print a;a=map(sum,zip([0]+a,a+[0]));"*input()

Пример использования:

echo 9 | python filename.py

Производит:

[1]
[1, 1]
[1, 2, 1]
[1, 3, 3, 1]
[1, 4, 6, 4, 1]
[1, 5, 10, 10, 5, 1]
[1, 6, 15, 20, 15, 6, 1]
[1, 7, 21, 35, 35, 21, 7, 1]
[1, 8, 28, 56, 70, 56, 28, 8, 1]
Примо
источник
1
+1 Умный способ использования execизбегать forпетли.
Стивен Румбальски,
15

Python, 94 91 88 70 63 символа

x=[1]
for i in input()*x:
 print x
 x=map(sum,zip([0]+x,x+[0]))
Стивен Румбальский
источник
14

Математика: 36 (41?)


У Mathematica есть Binomialфункция, но от этого она получает удовольствие. Я предлагаю:

NestList[{0,##}+{##,0}&@@#&,{1},n-1]

Строка выше отобразит рваный массив, такой как:

{{1}, {1, 1}, {1, 2, 1}, {1, 3, 3, 1}, {1, 4, 6, 4, 1},
 {1, 5, 10, 10, 5, 1}, {1, 6, 15, 20, 15, 6, 1}}

Поскольку это базовый формат в Mathematica, я подумал, что это будет приемлемо, но, как только я перечитал правила, я думаю, что это может быть не так. Добавление Grid@даст однозначно приемлемый вывод, всего 41 символ:

Grid@NestList[{0,##}+{##,0}&@@#&,{1},n-1]

n = 6:

1                       
1   1                   
1   2   1               
1   3   3   1           
1   4   6   4   1       
1   5   10  10  5   1   
1   6   15  20  15  6   1
Mr.Wizard
источник
14

С 522

Самостоятельно демонстрирующий C ответ. Не может быть яснее! Бонусные баллы за поиск дополнительного персонажа.

#define returns return 0
#define fr for
#define twentyonechexpressis0 0
                                                                                i
                                                                               , x
                                                                              [ 52 ]
                                                                            [ 52] ,j, y
                                                                       ; main (c){fr (;i< c
                                                                    ; i++){ x[i][i]=x[ i][0]= 1
                                                         ; }for(i =2;i<c;i++){for (j=1;j<i;j++){x [i][j] =
                                    1 +x[i][j ]+x[i-1][j-1]+x[i-1] [j]+1-1+1-1+1-1+1-1+1-1+111-11- twentyonechexpressis0 -100-1; }
} ;for(i=0 ;i<c;i++){for(j=0;j<=i;j++){ printf("%3d%c",x[i][j],(1+1+1+1)*(1+1+1+1+1+1+1+1)) ;}putchar(1+1+(1<<1+1)+1+1+1+1+1+111111-111111-1);} /*thiscomment_takes28chars*/ returns; }
walpen
источник
4
Я не могу помочь, но чувствую, что это упускает смысл кода гольф. (Я также не могу не указать, что дополнительный символ находится в позиции \ binom {5} {4}).
Питер Тейлор
2
Было весело писать. Это вообще то, для чего я прихожу в Codegolf.
Walpen
1
Умный :) Имейте upvote. Может быть, не кандидат-победитель, а креативный!
Accatyc
11

Golfscript (21 символ)

~]({0\{.@+\}/;1].p}*;

Поскольку было запрошено объяснение:

# Stack contains 'n'
~](
# Stack: [] n
{
    # prev_row is [\binom{i,0} ... \binom{i,i}]
    # We loop to generate almost all of the next row as
    #     [(\binom{i,-1} + \binom{i,0}) ... (\binom{i,i-1} + \binom{i,i})]
    # \binom{i,-1} is, of course, 0
    # Stack: prev_row
    0\
    # Stack: 0 prev_row
    {
        # Stack: ... \binom{i,j-1} \binom{i,j}
        .@+\
        # Stack: ... (\binom{i,j-1} + \binom{i,j}) \binom{i,j}
    }/
    # Stack: \binom{i+1,0} ... \binom{i+1,i} \binom{i,i}
    # unless it's the first time round, when we still have 0
    # so we need to pop and then push a 1 for \binom{i+1,i+1}
    ;1]
    # next_row
    .p
}*
# final_row
;
Питер Тейлор
источник
Возможно, вы захотите попробовать golf.shinh.org/p.rb?pascal+triangle
Набб
Не могли бы вы предоставить псевдокод или объяснение? Я вроде понимаю, что происходит, но я не совсем понимаю, что такое обмен.
Роб
Спасибо за подробное объяснение и отличный ответ (+1), но сейчас я еще больше запутался. Логика (процесс) не работает правильно.
Роб
@MikeDtrick, в объяснении произошла небольшая ошибка. Есть также тонкий момент, который нужно объяснить, но который я упустил, потому что я так долго писал код.
Питер Тейлор
Хорошо, это начинает иметь смысл. Мой последний вопрос: работает ли процесс печати и выполнения сверху вниз или снизу вверх (1, 1 1, 1 2 1: сверху вниз, 1 2 1, 1 1, 1: снизу вверх)?
Роб
7

Хаскелл, 94 92

f=[1]:[zipWith(+)(0:x)x++[1]|x<-f]
main=readLn>>=mapM_(putStrLn.unwords.map show).(`take`f)

Выход:

1
1 1
1 2 1
1 3 3 1
1 4 6 4 1

Версия из 71 символа, которая не печатает пробел между каждым числом:

f=[1]:[zipWith(+)(0:x)x++[1]|x<-f]
main=readLn>>=mapM_ print.(`take`f)

Выход:

[1]
[1,1]
[1,2,1]
[1,3,3,1]
Хаммар
источник
Вы можете сохранить символ, используя mapMвместо mapM_.
dfeuer
7

Scala, 81 78 72 70 знаков

81 символ: первая попытка, безбожно скопировано с версии Python :)

var x=Seq(1)
for(i<-1 to args(0).toInt){println(x)
x=(0+:x,x:+0).zipped.map(_+_)}

Запустите его как скрипт или прямо в REPL.

Сократить до 70 символов с чем-то удивительно читаемым и идиоматическим:

Seq.iterate(Seq(1),readInt)(a=>(0+:a,a:+0).zipped.map(_+_))map println

Или 72 70 символов совершенно другим методом:

0 to(readInt-1)map(i=>println(0 to i map(1 to i combinations(_)size)))
Луиджи Плинге
источник
+1 за бесстыдное копирование!
Стивен Румбальски
Последняя версия должна использоваться осторожно для огромных значений readInt, таких как 50.;)
пользователь неизвестен
@userunknown предположительно, поэтому в этом вопросе указан верхний предел 25 ...
Луиджи Плинге,
Это не было критикой, просто предупреждением для любопытных.
пользователь неизвестен
6

Рубин: 51 49 46 символов

(45 символов кода + 1 символ опции командной строки)

p=[];$_.to_i.times{n=0;p p.map!{|i|n+n=i}<<1}

Благодаря:

  • jsvnm за предложение альтернативы для переключения значений (2 символа)
  • ГБ для определения неиспользуемой переменной после предыдущего улучшения (4 символа)

Образец прогона:

bash-4.4$ ruby -ne 'p=[];$_.to_i.times{n=0;p p.map!{|i|n+n=i}<<1}' <<< 1
[1]

bash-4.4$ ruby -ne 'p=[];$_.to_i.times{n=0;p p.map!{|i|n+n=i}<<1}' <<< 9
[1]
[1, 1]
[1, 2, 1]
[1, 3, 3, 1]
[1, 4, 6, 4, 1]
[1, 5, 10, 10, 5, 1]
[1, 6, 15, 20, 15, 6, 1]
[1, 7, 21, 35, 35, 21, 7, 1]
[1, 8, 28, 56, 70, 56, 28, 8, 1]

Попробуйте онлайн!

manatwork
источник
1
Вы можете сохранить 2 p.map!{|i|(v=n)+n=i}
символа
Великолепно, @jsvnm! Чувак, как долго я комбинировал, чтобы сократить эту часть. Спасибо.
manatwork
1
Возможно, немного поздно, но: зачем использовать переменную v?
GB
Хороший улов, @GB! Это осталось от 1-й ревизии , где ... где ... дох. Где было также бесполезно. Я думаю, что это происходит от более ранней попытки при использовании .map. Спасибо.
manatwork
5

JavaScript ( 90 85 83 81)

for(n=prompt(o=i='');i++<n;o+='\n')for(s=j=1;j<=i;s=s*(i-j)/j++)o+=s+' ';alert(o)

Демо: http://jsfiddle.net/tcRCS/3/

ПРИМЕЧАНИЕ . Практически не работает примерно при n> 30, поскольку числа переполняют встроенный целочисленный тип данных и становятся числами с плавающей запятой.

Редактирование 1 : 5 символов удалены путем преобразования whileв forи комбинирование заявления

Редактировать 2 : переместить s=заявление внутрь forи сохранить 2 символа

Редактировать 3 : объединить s=1,j=1инициализатор в s=j=1и сохранить 2 символа

mellamokb
источник
Ницца! Вы можете сохранить еще один символ, изменив «s = s * ...» на «s * = ...»
Дерек Курт,
@DerekKurth: Я думал, что когда я впервые делал оптимизацию, но это испортило бы логику, потому что так должно быть s*(i-j)/j, а не s*((i-j)/j).
mellamokb
Хм, я попробовал это как s * = ... в jsfiddle, и это, казалось, работало. Может быть, я сделал что-то не так, хотя.
Дерек Курт
1
@DerekKurth: Технически это то же самое, но идея в том, что если вы умножите на (i-j) до деления на j, то арифметика с плавающей точкой не нужна, потому что результаты всегда должны быть целыми. Если вы сделаете это ((i-j)/j)сначала, это приведет к десятичным значениям, которые могут стать источником ошибки, и, по крайней мере, потребует дополнительного кода для округления / усечения. Вы не начнете видеть это, пока не доберетесь до n>11, и вы увидите десятичные значения в выводе, то есть,1 11 55 165 330 461.99999999999994 461.99999999999994...
mellamokb
Ах, это имеет смысл!
Дерек Курт
5

R, 39 символов

R, кажется, очень подходящий инструмент для этой задачи :-)

x=1;for(i in 1:n)x=c(print(x),0)+c(0,x)
Tomas
источник
3
Вы пропускаете одно из требований: «При вводе n (при условии, что это наиболее удобно на выбранном вами языке)»
Стивен Румбальски
@ Steven, "Учитывая вход n" ... так что я могу предположить, что nдано? Я исправил код. Это сейчас нормально?
Томас
Я попросил Питера Олсона уточнить.
Стивен Румбальски
@ StevenRumbalski Я не думаю, что это действительно, если это не требует ввода. Я не знаю R, так что, возможно, компилятор делает так, чтобы неопределенные переменные запрашивали ввод, так что это может быть хорошо, но если это похоже на большинство других языков в этом отношении, я не думаю, что это так.
Питер Олсон
1
По сути, во время выполнения nнеобходимо предоставить источник из внешнего источника, а аппарат для его захвата включен в вашу программу. Как правило, это означает аргумент командной строки, или стандартный ввод, или файл. По файлу почти никогда не используется, потому что он неизменно длиннее двух других вариантов.
Стивен Румбальски
5

в Q (25 символов / 20 с более короткой версией)

t:{(x-1) (p:{0+':x,0})\1}

Более короткие 

t:{(x-1){0+':x,0}\1}

Пример использования:

q)t 4
1
1 1
1 2 1
1 3 3 1
sinedcm
источник
Или, альтернативно, 20 персонажейt:{(x-1){0+':x,0}\1}
скивей
Хорошо, короче, чем решение GolfScript сейчас.
sinedcm
4

awk - 73 символа

довольно простая реализация:

{for(i=0;i<$1;++i)for(j=i;j>=0;)printf"%d%c",Y[j]+=i?Y[j-1]:1,j--?32:10}

образец прогона:

% awk -f pascal.awk <<<10
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1
1 7 21 35 35 21 7 1
1 8 28 56 70 56 28 8 1
1 9 36 84 126 126 84 36 9 1
Дэн Андреатта
источник
4

Perl, 52 , 49 символов

Редактировать: используя sayвместоprint

map{@_=(1,map$_[$_-1]+$_[$_],1..@_);say"@_"}1..<>
Тото
источник
4

Perl, 47 54 символов

$p=1;map{print"@{[split//,$p]}\n";$p*=11}1..<>

Он берет число из командной строки, но не выполняет никаких проверок ошибок.

Просто понял, что это работает только до п = 4. Это был какой-то старый код, который я имел на своем HD.

Это работает, хотя:

map{@a=(1,map$a[$_-1]+=$a[$_],1..@a);print"@a\n"}a..n

Однако в сценарий необходимо ввести n, иначе это будет еще один символ.

flesk
источник
3

Perl, 77 символов

$o[0]=1;for(1..<>){$"=" ";for(1..$_){$n[$_]=$o[$_]+$o[$_-1]}@o=@n;print"@o
"}

Пример ввода

5

Пример вывода

 1
 1 1
 1 2 1
 1 3 3 1
 1 4 6 4 1
PhiNotPi
источник
3

C 132 127 символов

c[25][25],n,i,j;main(){for(scanf("%d",&n);i<n;i++)for(j=0;j<=i;j++)printf("%d%c",c[i][j]=j?c[i-1][j-1]+c[i-1][j]:1,i-j?32:10);}
Саидн
источник
3

Паскаль: 216 192 символов

(Не настоящий конкурент, просто почетное присутствие.)

var p:array[0..1,0..25]of LongInt;i,j,n,u:Word;begin
Read(n);u:=0;for i:=1to n do begin
p[1,1]:=1;for j:=1to i do begin
p[u,j]:=p[1-u,j-1]+p[1-u,j];Write(p[u,j],' ')end;u:=1-u;Writeln
end
end.

Образец прогона:

bash-4.2$ fpc pascal.pas 
/usr/bin/ld: warning: link.res contains output sections; did you forget -T?

bash-4.2$ ./pascal <<< 1
1 

bash-4.2$ ./pascal <<< 9
1 
1 1 
1 2 1 
1 3 3 1 
1 4 6 4 1 
1 5 10 10 5 1 
1 6 15 20 15 6 1 
1 7 21 35 35 21 7 1 
1 8 28 56 70 56 28 8 1
Манатворк
источник
3

MATL , 10 байт

Язык создан после этого вызова

1iq:"tTTY+

Попробуйте онлайн!

1       % Push a 1. This will be the first row
iq:     % Take input n. Generate range [1,2,...,n-1]
"       % For each (that is, repeat n-1 times)
  t     %   Duplicate latest row
  TT    %   Push [1 1]
  Y+    %   Convolve latest row with [1 1] to produce next row
        % Implicitly end for each
        % Implicitly display stack contents
Луис Мендо
источник
неконкурентный, но святая катастрофа, ни одному из предыдущих представлений (даже J) не удалось уменьшить его до того, сколько сделал Матл !!!
Abr001am
Я почти уверен, что Jelly или 05AB1E будут короче :-)
Луис Мендо
2

D 134 128 символов

import std.stdio;void main(){int n,m;int[]l,k=[0,1];readf("%d",&n);foreach(i;0..n){writeln(l=k~0);k=[];foreach(e;l)k~=m+(m=e);}}

выход для 9 

>9
[0, 1, 0]
[0, 1, 1, 0]
[0, 1, 2, 1, 0]
[0, 1, 3, 3, 1, 0]
[0, 1, 4, 6, 4, 1, 0]
[0, 1, 5, 10, 10, 5, 1, 0]
[0, 1, 6, 15, 20, 15, 6, 1, 0]
[0, 1, 7, 21, 35, 35, 21, 7, 1, 0]
[0, 1, 8, 28, 56, 70, 56, 28, 8, 1, 0]

в полной мере использовать «вы можете отформатировать его так, как вам нравится»; между каждым числом и переводом строки стоит пробел

edit изменил положение для lбритья некоторых символов

чокнутый урод
источник
2

Scala, 131 персонаж

object P extends App{var x=List(1)
while(x.size<=args(0).toInt){println(x.mkString(" "))
x=(0+:x:+0).sliding(2).map(_.sum).toList}}

Принимает ввод из командной строки.

Выход для n = 10:

1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1
1 7 21 35 35 21 7 1
1 8 28 56 70 56 28 8 1
1 9 36 84 126 126 84 36 9 1
Gareth
источник
Что со всеми этими 0с :-)?
mellamokb
@mellamokb Небольшая перестановка заставила их уйти и сократила код. :-)
Гарет
2

F♯ - 203 символа

Моя первая попытка игры в гольф и первая попытка функционального программирования. Вероятно, есть какой-то очевидный способ сократить его, я еще не совсем понял. Он соответствует в F201-компиляторе VS2010 (который в отличие от более ранних версий запускает #light по умолчанию), а также работает в интерпретаторе F♯. Принимает ввод через стандартный ввод. Хотелось бы, чтобы был лучший способ ввода / вывода! Много персонажей!

open System
let rec C r m =if r=0||m<=0||m>=r then 1 else C(r-1)m+C(r-1)(m-1)
for j = 0 to Convert.ToInt32(Console.ReadLine ()) do (
 [0..j]|>List.map(C j)|>List.iter(fun k->printf "%i " k)
 printf "\n")
lochok
источник
2

Почему нет принятого ответа на этот вопрос?

VBA - 249 символов

Sub t(n)
ReDim a(1 To n,1 To n*2)
a(1,n)=1:y=vbCr:z=" ":d=z & 1 & z & y:For b=2 To n:For c=1 To n*2:x=a(b-1,c)
If c>1 Then a(b,c)=a(b-1,c-1)+x
If c<n*2 Then a(b,c)=a(b-1,c+1)+x
d=IIf(a(b,c)<>0,d & z & a(b,c) & z,d):Next:d=d & y:Next:MsgBox d
End Sub
Gaffi
источник
2

Постскриптум - 59 символов (63, если считать -dn= чтобы получить количество строк в)

[1]n{dup ==[0 3 2 roll{dup 3 2 roll add exch}forall]}repeat

бежать с

gs -q -dn=10 -dBATCH pascal.ps

получить

[1]
[1 1]
[1 2 1]
[1 3 3 1]
[1 4 6 4 1]
[1 5 10 10 5 1]
[1 6 15 20 15 6 1]
[1 7 21 35 35 21 7 1]
[1 8 28 56 70 56 28 8 1]
[1 9 36 84 126 126 84 36 9 1]
Джефф Риди
источник
2

Mathematica 35 символов

Вот скучный и ленивый способ разрезания треугольника Паскаля:

Table[n~Binomial~k,{n,0,5},{k,0,n}]

(* out *)
{{1}, {1, 1}, {1, 2, 1}, {1, 3, 3, 1}, {1, 4, 6, 4, 1}, {1, 5, 10, 10,5, 1}}
DavidC
источник
2

APL, 19 15 символов

Возможно, немного поздно для вечеринки?

{⍪{⍵!⍨⍳⍵+1}¨⍳⍵}

Это не бьет вход J, все же.

Это предполагает, что индекс origin ( ⎕IO) установлен в 0. К сожалению, с происхождением индекса 1нам нужно 25 18 символов:

{⍪{⍵!⍨0,⍳⍵}¨1-⍨⍳⍵}

Есть два ⍨ коде пункта, чтобы выразить мое разочарование.

Демо-версия:

      {⍪{⍵!⍨⍳⍵+1}¨⍳⍵}5
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1

Пояснения

Укороченная версия:

  • ⍳⍵(с источником индекса 0) создает массив чисел от 0 до ⍵-1включительно, где⍵ является правильным аргументом функции.
  • ⍳⍵+1 генерирует все числа от 0 до ⍵
  • {⍵!⍨⍳⍵+1}генерирует ⍵выбор kдля каждого элемента kв ⍳⍵+1. Оператор ⍨(коммутирует) меняет местами аргументы функции, так что правый аргумент становится левым, и наоборот.
  • {⍵!⍨⍳⍵+1}¨⍳⍵передает каждый элемент с ⍳⍵помощью ¨оператора (each). Результатом является одномерный массив, содержащий первые ⍵строки треугольника Паскаля.
  • Форма с одним аргументом ⍪принимает одномерный вектор и делает его столбцом, а не строкой. Каждый ряд треугольника размещен на отдельной линии.

Длинный ответ:

  • Практически так же, как и в другой версии, за исключением того, что 1-⍨помещается перед ⍳реплицировать источник индекса 0.
  • 0,⍳⍵с источником индекса 1 повторяет ⍳⍵+1с источником индекса 0.
летучесть
источник
2

Клен, 46

seq(print(seq(binomial(i,k),k=0..i)),i=0..n-1)

Использование:

> f:=n->seq(print(seq(binomial(i,k),k=0..i)),i=0..n-1);
> f(3)
    1
   1 1
  1 2 1
DSkoog
источник
2

VBA, 162 142 102 80 байт

Сохранено 22 байта благодаря Тейлор Скотт.

Это старый вопрос, но я нашел более короткое решение для VBA.

[B2].Resize([A1],[A1])="=IF(COLUMN()>ROW(),"""",IF(ROW()=2,1,IFERROR(A1+B1,1)))"

Это предназначено для запуска в непосредственном окне. Вход находится в ячейке A1активного листа. Выходные данные находятся в активном рабочем листе, начиная с B2и используя, однако на основе входных данных требуется много ячеек. При COLUMN()>ROW()проверке верхний правый угол треугольника остается пустым. ROW()=2Проверка делает первое значение1 , чтобы инициировать треугольник. Я мог бы сдвинуть вывод вниз и отбросить эту проверку, но он вводит много посторонних выводов до фактического треугольника, и я не чувствовал, что это было в духе задачи.

Первоначально я опубликовал гораздо более сложный метод, который вычислял каждое значение на основе его строки и столбца. Все, что делает этот метод, это использование внутриклеточных формул. Я начинаю с B2того, что могу ссылаться на строку над ним без #REF!ошибок. Затем он копирует и вставляет одну и ту же формулу в блок ячеек n шириной и n высотой. Вход и выход для n=25выглядит следующим образом:

Выход

Инженер Тост
источник
Очень крутой ответ, но вы можете немного поиграть в гольф. Преобразование Function p(r)в, Sub p(r)поскольку у вас нет выходного значения функции, удаление пробела debug.? c(n,k);и преобразование многострочного if-then-elseоператора в одну строку ( If k Then c=c(n-1,k-1)*n/k Else c=1) приводит к уменьшению подсчета байтов до 130моего значения
Тейлор Скотт,
@TaylorScott Спасибо! Я довольно новичок в гольфе и только немного менее новичок в программировании в целом. Я насчитал 142 из-за разрывов строк. Из того, что я мог найти , они должны были рассчитывать.
Инженер Тост
Ах, вы правы, я забыл сосчитать мои новые строки, и, как оказалось, по крайней мере, еще один трюк в гольф For n=0 To...может быть сведен к For n=0To...переносу моей версии кода в Sub p(r):For n=0To r-1:For k=0To n:Debug.?c(n,k);:Next:Debug.?:Next:End Sub Function c(n,k):If k Then c=1 Else c=c(n-1,k-1)*n/k[char (10)] End Functionс количеством байтов139
Тейлор Скотт
Второй взгляд на это наводит на мысль , что если разбить его на немедленную оконной функцию с вспомогательной функцией, вы можете получить его до 112 байт (Immediate Window Function: For n=0To[A1-1]:For k=0To n:?c(n,k);:Next:?:NextВспомогательная функция: Function c(n,k) If k Then c=c(n-1,k-1)*n/k Else c=1 End Function)
Тейлор Скотт
1
@TaylorScott Как насчет того, чтобы просто отбросить их? С изменением формулы все работает просто отлично. Я думаю, что вывод, начинающийся с B2вместо A1приемлемого.
Тост инженера