生成帕斯卡三角形

35

Pascal的三角形是从第一行的1开始生成的。在随后的行上，该数字由在其左右上方正上方的两个数字之和确定。

为了演示，这是Pascal三角形的前5行：

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

挑战

给定输入n（但是，使用您选择的语言提供的最方便），请生成Pascal三角形的前n行。您可以假设n是一个介于1和25之间的整数（包括1和25）。每行之间必须有一个换行符，并且每个数字之间必须有一个空格，但是除此之外，您可以随意设置其格式。

这是代码高尔夫球，因此最短的解决方案是成功的。

示例I / O

> 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 
— 彼得·奥尔森
source
NB在某种意义上，这是一个简化版本分发球
— 彼得·泰勒
@彼得·奥尔森（Peter Olson）：您对棘轮怪胎对“您可以按自己的喜好格式化”有何看法？如果按照他的解释，我可以剃掉18个字符。
— 史蒂芬·鲁姆巴尔斯基
@StevenRumbalski他很好。每行之间有一个换行符，并且每个数字之间都有一个空格，因此符合条件。
— 彼得·奥尔森
@Peter Olson：感谢您的澄清。Tomas T的假设n已经定义了呢？
— 史蒂文·鲁姆巴尔斯基
4
@Gaffi可能不会，接受答案会使我感到自己正在结束比赛，不鼓励提出新的和可能更好的答案。
— 彼得·奥尔森

Answers:

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
   （“：@（！{：）\ @ i。）`''
+ ---------------------------------- +
| +-+ ------------------------------ + |
|| @ | + ------------------------- +-+ ||
|| || +-+ --------------------- + | i。|||
|| ||| \ | + ------------------- + || |||
|| ||| || +-+ --------------- + ||| |||
|| ||| ||| @ | +-+ ---------- + |||| |||
|| ||| ||| ||“：| +-+ ------ + ||||| ||||
|| ||| ||| || || 2 | +-+-+ |||||| |||
|| ||| ||| || || ||！| {：|||||||| |||
|| ||| ||| || || | +-+-+ ||||||| |||
|| ||| ||| || | +-+ ------ + |||||| |||
|| ||| ||| | +-+ ---------- + |||| |||
|| ||| || +-+ --------------- + ||| |||
|| ||| | + ------------------- + || |||
|| || +-+ --------------------- + | |||
|| | + ------------------------- +-+ ||
| +-+ ------------------------------ + |
+ ---------------------------------- +
— 短暂的
source
1
J击败了GolfScript？有趣。如果您有时间，我想查看此代码的说明。
— 威兹德先生2011年
4
它已经分解了，但是如果您需要其他英语，请逐行进行。第1行i.5返回前五个自然数。第2行添加了{:“尾巴”（最后返回）。第3行将它们与!“ Out Of”（组合数）组合。第4行(!{:)i.5是相同的。进行分析。这样(!:)的操作会将前n个自然数转换为Pascal三角形的第n条线。第5行将其应用于所有0..4的前缀（反斜杠），但是J用0填充未使用的点，因此该操作与（@）字符串格式化操作结合在一起":。很酷的J，赞成。
— JB
@JB不是！是指析因？同样，我们可以在右边删除@。
— 2012年
@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]
— 原始
source
1
+1聪明的使用方式exec避免for循环。
— Steven Rumbalski 2011年
14

Mathematica：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
— 向导先生
source
14

C，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; }
— 沃尔彭
source
4
我忍不住觉得这错过了代码开发的重点。（我也不禁要指出多余的字符在\ binom {5} {4}位置）。
— 彼得·泰勒
2
写作很有趣。通常这就是我来到codegolf的目的。
— walpen 2012年
1
聪明:)赞成。也许不是优胜者候选人，而是有创造力的候选人！
— Accatyyc 2012年
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
;
— 彼得·泰勒
source
— Nabb 2011年
您能提供一些伪代码或解释吗？我有点了解发生了什么，但是我并不完全了解交换部分。
— 罗布2012年
感谢您的详细说明和出色的答案（+1），但现在我更加困惑。逻辑（过程）不正确。
— 罗布
@MikeDtrick，解释中有一个小错误。还有一个微妙的地方需要解释，但是我错过了，因为我编写代码已经很久了。
— 彼得·泰勒
好的，这已经开始有意义了。我的最后一个问题是打印和执行过程是自上而下还是自下而上（1，1 1，1 2 1：自上而下，1 2 1，1 1，1：自下而上）？
— 罗布2012年
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]
— 哈马尔
source
您可以使用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)))
— 路易吉·普林格
source
+ 1用于无耻复制！
— 史蒂芬·鲁姆巴尔斯基
最后一个版本应谨慎使用readInt的巨大值，例如50。;）
— 用户未知
@userunknown大概就是这就是为什么该问题将上限指定为25 ...
— Luigi Plinge，2012年
这并不是批评，只是对好奇的警告。
— 用户未知
6

Ruby：51 49 46个字符

（45个字符的代码+ 1个字符的命令行选项）

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

谢谢：

  • jsvnm用于建议值切换的替代方法（2个字符）
  • GB，用于找出先前改进后未使用的变量（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]

在线尝试！

— 工作的人
source
1
您可以使用p.map!{|i|(v=n)+n=i}
— jsvnm
好极了，@ jsvnm！伙计，我加起来缩短了那部分的时间。谢谢。
— manatwork，2012年
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：通过转换while为for并合并语句删除了5个字符

编辑2：移动s=语句for并保存2个字符

编辑3：组合s=1,j=1初始化s=j=1并保存2个字符

— ella
source
真好！您可以通过将“ s = s * ...”更改为“ s * = ...”来节省一个字符
— Derek Kurth，
@DerekKurth：我曾以为，当我第一次进行优化时，但这会弄乱逻辑，因为它必须是s*(i-j)/j，而不是s*((i-j)/j)。
— mellamokb 2011年
嗯，我在jsfiddle中以s * = ...尝试过，它似乎可以工作。不过，也许我做错了。
— 德里克·库斯
1
@DerekKurth：从技术上讲是一样的，但是想法是，如果(i-j)在除以之前乘以j，则不需要浮点运算，因为结果应始终为整数。如果首先执行((i-j)/j)此操作，将导致十进制值，这可能是错误的来源，并且至少将需要用于舍入/截断的额外代码。直到大约到，您才开始看到它n>11，并且您将在输出中看到十进制值，即1 11 55 165 330 461.99999999999994 461.99999999999994...
— mellamokb 2011年
啊，那很有意义！
— 德里克·库斯
5

R，39个字符

R似乎是完成此任务的正确工具：-)

x=1;for(i in 1:n)x=c(print(x),0)+c(0,x)
— 托马斯
source
3
您缺少其中一项要求：“给出输入n（但要以您选择的语言提供最方便的条件）”
— Steven Rumbalski 2011年
@Steven，“给出输入n” ...所以我可以假设n给出了？我更正了代码。现在可以吗？
— Tomas
我被要求彼得·奥尔森澄清。
— 史蒂文·鲁姆巴尔斯基
@StevenRumbalski我认为除非输入，否则这是无效的。我不了解R，所以也许编译器可以做到这一点，以便未定义的变量提示输入，所以可能没问题，但是如果就这点而言，就像大多数其他语言一样，我认为不是。
— 彼得·奥尔森
1
基本上，n必须在运行时从外部来源提供这些东西，并且用于捕获它的设备已包含在您的程序中。通常，这意味着通过命令行参数或stdin或文件。按文件几乎从未使用过，因为它总是比其他两个选项更长。
— Steven Rumbalski 2011年
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
— 罪恶cm
source
或另选20个字符t:{(x-1){0+':x,0}\1}
— skeevey 2012年
不错，比现在的GolfScript解决方案要短。
— sinedcm 2012年
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
— 丹·安德烈塔
source
4

Perl， 52个，49个字符

编辑：使用say代替print

map{@_=(1,map$_[$_-1]+$_[$_],1..@_);say"@_"}1..<>
— 托托
source
4

Perl，47个 54个字符

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

它从命令行获取一个数字，但不执行任何错误检查。

刚意识到它只能工作到n = 4。这是我高清硬盘上的一些旧代码。

这可以工作：

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

但是，必须将n输入到脚本中，否则将再输入一个字符。

— 夫斯克
source
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
— 皮诺皮
source
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);}
— 赛登
source
3

Pascal：216192个字符

（不是真正的竞争对手，只是荣誉的存在。）

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
— 工作的人
source
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
— 路易斯·门多
source
非竞争性的灾难，而是一场神圣的灾难，以前提交的内容（甚至J）都没有成功地将其减少到Matl做了多少！
— 2016年
我非常确定Jelly或05AB1E会更短：-)
— Luis
2

D 134128字符

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]

充分利用“您可以随意设置格式”的优势；每个数字和一个换行符之间有一个空格

编辑将任务重新定位l为刮除一些字符

— 棘轮怪胎
source
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
— 加雷斯
source
所有这些0:-)是什么？
— mellamokb 2011年
@mellamokb的重新排列使它们消失了，并缩短了代码。:-)
— Gareth
2

F♯-203个字符

我的第一次尝试是一轮代码高尔夫，也是第一次尝试进行函数式编程。可能有一些明显的方法可以缩短它，但我还没有弄清楚。它符合VS2010的F♯编译器（与早期版本不同，默认情况下具有运行#light的效果），并且还可以在F♯解释器中工作。通过stdin接受输入。希望有一种更好的输入/输出方式！很多字符！

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
source
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
— 加菲
source
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]
— 杰夫·里迪（Geoff Reedy）
source
2

Mathematica 35个字符

这是切片Pascal三角形的愚蠢而懒惰的方式：

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}}
— 戴维
source
2

APL，19 15个字符

派对晚了一点吗？

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

但是，它没有击败J条目。

假设索引原点（⎕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}¨⍳⍵⍳⍵使用¨（每个）运算符传递每个元素。结果是一个包含⍵Pascal三角形的第一行的一维数组。
  • 的一个参数形式⍪采用一维向量，并使其成为列而不是行。三角形的每一行都放在自己的线上。

长答案：

  • 几乎与其他版本相同，不同之处在于，该版本1-⍨位于⍳复制索引原点0的之前。
  • 0,⍳⍵索引原点为1的副本将复制⍳⍵+1索引原点为0的副本。
— 挥发性
source
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
source
2

VBA，162个 142 102 80字节

由于泰勒·斯科特（Taylor Scott），节省了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看起来像这样：

Output

— 工程师吐司
source
答案很酷，但是您可以打高尔夫很多。转换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我的数字
— Taylor Scott
@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
— Taylor史考特
再来看一遍，这意味着如果您将其分解为带有帮助程序功能的即时窗口功能，则可以将其减少到112字节（立即窗口功能：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是可以接受的。
— Engineer Toast
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.