这是帕斯卡的辫子：

 1 4  15  56   209   780    2911    10864     40545      151316      564719
1 3 11  41  153   571   2131    7953     29681     110771      413403      1542841
 1 4  15  56   209   780    2911    10864     40545      151316      564719

^{我完全弥补了。据我所知，布莱斯·帕斯卡（Blaise Pascal）没有辫子，如果他这样做，那可能是由头发而不是数字制成的。}

它的定义如下：

1. 第一列1中间有一个。
2. 第二列1的顶部和底部都有一个。
3. 现在，我们在将数字放在中间或将数字的两个副本放在顶部和底部之间进行交替。
4. 如果数字位于顶部或底部，则为两个相邻数字的总和（例如56 = 15 + 41）。如果您稍微倾斜头部，这就像是Pascal三角形中的一个台阶。
5. 如果数字在中间，则它将是所有三个相邻数字的总和（例如41 = 15 + 11 + 15）。

您的任务将是打印编织物（的一部分）。

输入值

您应该编写一个程序或函数，该程序或函数接收一个整数n，给出要输出的最后一列的索引。

您可以选择第一列（仅1在中间一行打印一个）对应n = 0还是n = 1。在所有可能的输入中，这必须是一个一致的选择。

输出量

将Pascal的辫子输出到第nth列。空格必须与上面的示例布局完全匹配，除了可以用空格将较短的行填充到较长的行的长度之外，还可以选择输出单个尾随换行符。

换句话说，每一列都应与该列中的数字（或一对相等的数字）完全一样宽，连续列中的数字不应重叠，并且各列之间不应有空格。

您可以将结果打印到STDOUT（或最接近的替代品），或者如果编写函数，则可以返回内容相同的字符串或三个字符串的列表（每行一个）。

更多详情

您可能会假设它n不会小于第一列的索引（因此不会小于0或1取决于您的索引）。您还可以假定辫子中的最后一个数字小于256或您的语言的本机整数类型可表示的最大数字，以较大者为准。因此，如果您的本机整数类型只能存储字节，则可以假定最大n为9或10（取决于您使用的是基于0还是基于1 n），如果可以存储带符号的32位整数，n则最大为33或34。

适用标准代码高尔夫球规则。最短的代码获胜。

信息系统

这是一些相关的OEIS链接。当然，这些包含破坏者，用于以不同方式在编织物中生成数字：

• 顶部/底部：A001353或A010905或A106707或A195503
• 中线：A001835或A079935
• 两者：A002530

测试用例

这些测试用例使用1基索引。每个测试用例有四行，第一行是输入，其余三行是输出。

1

1

---
2
 1
1
 1
---
3
 1
1 3
 1
---
5
 1 4
1 3 11
 1 4
---
10
 1 4  15  56   209
1 3 11  41  153
 1 4  15  56   209
---
15
 1 4  15  56   209   780    2911
1 3 11  41  153   571   2131    7953
 1 4  15  56   209   780    2911
---
24
 1 4  15  56   209   780    2911    10864     40545      151316      564719       2107560
1 3 11  41  153   571   2131    7953     29681     110771      413403      1542841
 1 4  15  56   209   780    2911    10864     40545      151316      564719       2107560

果冻，31 30 29 字节

Q;S⁹o_
3ḶḂç@⁸СIµa"Ṿ€o⁶z⁶Zµ€Z

这是一个单子链接。它接受基于0的列索引作为参数，并返回字符串列表。

在线尝试！

怎么运行的

Q;S⁹o_                  Helper link.
                        Arguments: [k, 0, k] and [0, m, 0] (any order)

Q                       Unique; deduplicate the left argument.
 ;                      Concatenate the result with the right argument.
  S                     Take the sum of the resulting array.
   ⁹o                   Logical OR with the right argument; replaces zeroes in the
                        right argument with the sum.
     _                  Subtract; take the difference with the right argument to
                        remove its values.
                        This maps [k, 0, k], [0, m, 0] to [0, k + m, 0] and
                        [0, m, 0], [k, 0, k] to [m + 2k, 0, m + 2k].


3ḶḂç@⁸СIµa"Ṿ€o⁶z⁶Zµ€Z  Monadic link. Argument: A (array of column indices)

3Ḷ                      Yield [0, 1, 2].
  Ḃ                     Bit; yield [0, 1, 0].
        I               Increments of n; yield [].
      С                Apply...
   ç@                       the helper link with swapped arguments...
     ⁸                      n times, updating the left argument with the return
                            value, and the right argument with the previous value
                            of the left one. Collect all intermediate values of
                            the left argument in an array.
         µ         µ€   Map the chain in between over the intermediate values.
            Ṿ€          Uneval each; turn all integers into strings.
          a"            Vectorized logical AND; replace non-zero integers with
                        their string representation.
              o⁶        Logical OR with space; replace zeroes with spaces.
                z⁶      Zip with fill value space; transpose the resulting 2D
                        array after inserting spaces to make it rectangular.
                  Z     Zip; transpose the result to restore the original shape.
                     Z  Zip; transpose the resulting 3D array.

Pyth，44个字节

数字生成占用20个字节，而格式化占用24个字节。

jsMC+Led.e.<bkC,J<s.u+B+hNyeNeNQ,1 1Qm*;l`dJ

在线尝试！

jsMC+Led.e.<bkC,J<s.u+B+hNyeNeNQ,1 1Qm*;l`dJ   input as Q
                   .u          Q,1 1           repeat Q times, starting with [1,1],
                                               collecting all intermediate results,
                                               current value as N:
                                               (this will generate
                                                more than enough terms)
                       +hNyeN                  temp <- N[0] + 2*N[-1]
                     +B      eN                temp <- [temp+N[-1], temp]

now, we would have generated [[1, 1], [3, 4], [11, 15], [41, 56], ...]

jsMC+Led.e.<bkC,J<s                 Qm*;l`dJ
                  s                            flatten
                 <                  Q          first Q items
                J                              store in J
                                     m    dJ   for each item in J:
                                         `     convert to string
                                        l      length
                                      *;       repeat " " that many times

jsMC+Led.e.<bkC,
              C,     transpose, yielding:
[[1, ' '], [1, ' '], [3, ' '], [4, ' '], [11, '  '], ...]
(each element with as many spaces as its length.)
        .e            for each sub-array (index as k, sub-array as b):
          .<bk            rotate b as many times as k

[[1, ' '], [' ', 1], [3, ' '], [' ', 4], [11, '  '], ...]

jsMC+Led
    +Led              add to each sub-array on the left, the end of each sub-array
   C                  transpose
 sM                   sum of each sub-array (reduced concatenation)
j                     join by new-lines

Python 2，120字节

a=1,1,3,4
n=input()
y=0
exec"y+=1;t='';x=0;%sprint t;"%(n*"a+=a[-2]*4-a[-4],;v=`a[x]`;t+=[v,len(v)*' '][x+y&1];x+=1;")*3

在Ideone上尝试。

MATL，38字节

1ti:"yy@oQ*+]vG:)!"@Vt~oX@o?w]&v]&hZ}y

在线尝试！

计算具有（唯一）数字的数组需要前17个字节。格式化将占用剩余的21个字节。

说明

第1部分：生成数字

这将生成一个数组，其中第一行和第二行中的数字按升序排列：[1; 1; 3; 4; 11; 15; ...]。它开始1，1。每个新数字都是从前两个中迭代获得的。其中，第二个乘以1或2取决于迭代索引，然后加到第一个以产生新的数字。

迭代次数等于输入n。这意味着n+2将生成数字。生成后，需要修剪数组，以便仅n保留第一个条目。

1t      % Push 1 twice
i:      % Take input n. Generage array [1 2 ... n]
"       % For each
  yy    %   Duplicate the two most recent numbers
  @o    %   Parity of the iteration index (0 or 1)
  Q     %   Add 1: gives 1 for even iteration index, 2 for odd
  *+    %   Multiply this 1 or 2 by the most recent number in the sequence, and add
       %    to the second most recent. This produces a new number in the sequence
]       % End for each
v       % Concatenate all numbers in a vertical array
G:)     % Keep only the first n entries

第2部分：格式化输出

对于获得的数组中的每个数字，这将生成两个字符串：该数字的字符串表示形式，以及由重复的字符0组成的相同长度的字符串（字符0在MATL中显示为空格）。对于均匀迭代，将交换这两个字符串。

然后将两个字符串垂直连接。因此，n二维字符数组的生成方式如下（·用来表示字符0）：

·
1

1
·

· 
3

4
·

·· 
11

15
··

然后将这些阵列水平连接以产生

·1·4··15
1·3·11··

最后，此2D char数组分为两行，第一行复制到堆栈的顶部。按顺序显示三个字符串，每个字符串在不同的行上，以产生所需的输出

!       % Transpose into a horizontal array [1 1 3 4 11 15 ...]
"       % For each
  @V    %   Push current number and convert to string
  t~o   %   Duplicate, negate, convert to double: string of the same length consisting 
        %   of character 0 repeated
  X@o   %   Parity of the iteration index (1 or 0)
  ?     %   If index is odd
    w   %     Swap
  ]     %   End if
  &v    %   Concatenate the two strings vertically. Gives a 2D char array representing
        %   a "numeric column" of the output (actually several columns of characters)
]       % End for
&h      % Concatenate all 2D char arrays horizontally. Gives a 2D char array with the
        % top two rows of the output
Z}      % Split this array into its two rows
y       % Push a copy of the first row. Implicitly display

Haskell，101个字节

a=1:1:t
t=3:4:zipWith((-).(4*))t a
g(i,x)=min(cycle" 9"!!i)<$>show x
f n=[zip[y..y+n]a>>=g|y<-[0..2]]

定义一个函数f :: Int → [String]。

• Michael Klein提醒我，我不需要调用unlines结果，节省了7个字节。谢谢！

• 我用代替" 9"!!mod i 2了保存了一个字节cycle" 9"!!i。

• 通过编写两个corecursive列表而不是使用，再增加三个字节drop。

• 我的女友指出我可以通过在0而不是在开始回答来节省两个字节1。

C，183个 177 176字节

#define F for(i=0;i<c;i++)
int i,c,a[35],t[9];p(r){F printf("%*s",sprintf(t,"%d",a[i]),r-i&1?t:" ");putchar(10);}b(n){c=n;F a[i]=i<2?1:a[i-2]+a[i-1]*(i&1?1:2);p(0);p(1);p(0);}

说明

C永远不会因使用高级语言而简洁而赢得任何奖励，但是该练习是有趣且很好的做法。

宏F以可读性为代价舍弃了六个字节。全局声明变量以避免重复声明。我需要一个用于sprintf的字符缓冲区，但是由于K＆R在进行类型检查时比较松懈，因此sprintf和printf可以将t [9]解释为指向36字节缓冲区的指针。这将保存一个单独的声明。

#define F for(i=0;i<c;i++)
int i,c,a[35],t[9];

漂亮的打印功能，其中r是行号。Sprintf格式化数字并计算列宽。为了节省空间，我们只需要调用三遍，每行输出一次即可。表达式ri＆1过滤要打印的内容。

p(r) {
    F
        printf("%*s", sprintf(t, "%d", a[i]), r-i&1 ? t
                                                    : " ");
    putchar(10);
}

入口点函数，参数是列数。计算列值a []的数组a，然后为输出的每一行调用一次打印函数p。

b(n) {
    c=n;
    F
        a[i] = i<2 ? 1
                   : a[i-2] + a[i-1]*(i&1 ? 1
                                          : 2);
    p(0);
    p(1);
    p(0);
}

示例调用（不包含在答案和字节数中）：

main(c,v) char**v;
{
    b(atoi(v[1]));
}

更新

合并了tomsmeding的内联sprintf建议。这样可以将计数从183个字符减少到177个字符。这也允许删除printf（sprintf（））块周围的花括号，因为它现在只是一个语句，但是只保存了一个字符，因为它仍然需要一个空格作为分隔符。降至176。

PowerShell v2 +，133个字节

param($n)$a=1,1;1..$n|%{$a+=$a[$_-1]+$a[$_]*($_%2+1)};$a[0..$n]|%{$z=" "*$l+$_;if($i++%2){$x+=$z}else{$y+=$z}$l="$_".Length};$x;$y;$x

_{44个字节用于计算值，70个字节用于表示ASCII}

将输入$n作为零索引列。设置序列数组的开始$a=1,1。然后，我们循环达$n与1..$n|%{...}构建阵列。每次迭代时，我们将（两个元素在前）+（前一个元素）*（无论我们是奇数还是偶数索引）的总和串联起来。这将产生$a=1,1,3,4,11...多达$n+2。

因此，我们需要切片$a以仅获取第一个0..$n元素，然后将它们通过另一个循环传递|%{...}。每次迭代时，我们将辅助程序设置为$z等于多个空格加上当前元素作为字符串。然后，我们通过简单的奇偶数/ 来拆分是将其连接到$x（顶部和底部行）还是$y（中间行）。然后，我们通过获取当前数字，对其进行字符串化并获取其来计算空间的数量。ifelse$l.Length

最后，我们将$x，$y和$x再次放在管道上，并且输出是隐式的。由于.ToString()在打印到STDOUT时数组的默认分隔符是换行符，因此我们免费获得该分隔符。

例

PS C:\Tools\Scripts\golfing> .\pascal-braid.ps1 27
 1 4  15  56   209   780    2911    10864     40545      151316      564719       2107560       7865521        29354524
1 3 11  41  153   571   2131    7953     29681     110771      413403      1542841       5757961       21489003
 1 4  15  56   209   780    2911    10864     40545      151316      564719       2107560       7865521        29354524

PHP 265字节

<?php $i=$argv[1];$i=$i?$i:1;$a=[[],[]];$s=['',''];$p='';for($j=0;$j<$i;$j++){$y=($j+1)%2;$x=floor($j/2);$v=$x?$y?2*$a[0][$x-1]+$a[1][$x-1]:$a[0][$x-1]+$a[1][$x]:1;$s[$y].=$p.$v;$a[$y][$x]=$v;$p=str_pad('',strlen($v),' ');}printf("%s\n%s\n%s\n",$s[0],$s[1],$s[0]);

未打高尔夫球：

$a = [[],[]];
$s = ['',''];

$p = '';

$i=$argv[1];
$i=$i?$i:1;
for($j=0; $j<$i; $j++) {
    $y = ($j+1) % 2;
    $x = floor($j/2);

    if( $x == 0 ) {
        $v = 1;
    } else {
        if( $y ) {
            $v = 2 * $a[0][$x-1] + $a[1][$x-1];
        } else {
            $v = $a[0][$x-1] + $a[1][$x];
        }
    }
    $s[$y] .= $p . $v;
    $a[$y][$x] = $v;
    $p = str_pad('', strlen($v), ' ');
}

printf("%s\n%s\n%s\n", $s[0], $s[1], $s[0]);

Python 278字节

import sys,math;a=[[],[]];s=['',''];p='';i=int(sys.argv[1]);i=1 if i<1 else i;j=0
while j<i:y=(j+1)%2;x=int(math.floor(j/2));v=(2*a[0][x-1]+a[1][x-1] if y else a[0][x-1]+a[1][x]) if x else 1;s[y]+=p+str(v);a[y].append(v);p=' '*len(str(v));j+=1
print ("%s\n"*3)%(s[0],s[1],s[0])

Ruby，120个字节

返回多行字符串。

在线尝试！

->n{a=[1,1];(n-2).times{|i|a<<(2-i%2)*a[-1]+a[-2]}
z=->c{a.map{|e|c+=1;c%2>0?' '*e.to_s.size: e}*''}
[s=z[0],z[1],s]*$/}

Matlab，223个字符，226个字节

function[]=p(n)
r=[1;1];e={(' 1 ')',('1 1')'}
for i=3:n;r(i)=sum((mod(i,2)+1)*r(i-1)+r(i-2));s=num2str(r(i));b=blanks(floor(log10(r(i)))+1);if mod(i,2);e{i}=[b;s;b];else e{i}=[s;b;s];end;end
reshape(sprintf('%s',e{:}),3,[])

取消评论并评论：

function[]=p(n) 
r=[1;1];                                    % start with first two 
e={(' 1 ')',('1 1')'}                       % initialize string output as columns of blank, 1, blank and 1, blank, 1.
for i=3:n;                                  % for n=3 and up! 
    r(i)=sum((mod(i,2)+1)*r(i-1)+r(i-2));   % get the next number by 1 if even, 2 if odd times previous plus two steps back
    s=num2str(r(i));                        % define that number as a string
    b=blanks(floor(log10(r(i)))+1);         % get a number of space characters for that number of digits
    if mod(i,2);                            % for odds
        e{i}=[b;s;b];                       % spaces, number, spaces
    else                                    % for evens
        e{i}=[s;b;s];                       % number, spaces, number
    end;
end
reshape(sprintf('%s',e{:}),3,[])            % print the cell array of strings and reshape it so it's 3 lines high

PHP，135个 124 123 120字节

<?while($i<$argv[1]){${s.$x=!$x}.=${v.$x}=$a=$i++<2?:$v1+$v+$x*$v;${s.!$x}.=str_repeat(' ',strlen($a));}echo"$s
$s1
$s";

利用隐式类型转换和变量变量
，三分之一的代码（37字节）进入空格，总共64字节用于输出

分解

$i=0; $x=false; $v=$v1=1; $s=$s1='';    // unnecessary variable initializations
for($i=0;$i<$argv[1];$i++)  // $i is column number -1
{
    $x=!$x; // $x = current row: true (1) for inner, false (empty string or 0) for outer
    // calculate value
    $a=
        $i<2?               // first or second column: value 1
        :$v1+(1+$x)*$v      // inner-val + (inner row: 1+1=2, outer row: 1+0=1)*outer-val
    ;
    ${s.$x}.=${v.$x}=$a;    // replace target value, append to current row
    ${s.!$x}.=str_repeat(' ',strlen($a));    // append spaces to other row
}
// output
echo "$s\n$s1\n$s";

批处理，250字节

@echo off
set s=
set d=
set/ai=n=0,j=m=1
:l
set/ai+=1,j^^=3,l=m+n*j,m=n,n=l
set t=%s%%l%
for /l %%j in (0,1,9)do call set l=%%l:%%j= %%
set s=%d%%l%
set d=%t%
if not %i%==%1 goto l
if %j%==1 echo %d%
echo %s%
echo %d%
if %j%==2 echo %s%

由于第一行和第三行相同，因此我们只需要构建两个字符串即可。这里d代表以最后一个条目s结尾的字符串，代表以空格结尾的字符串；最后四行确保以适当的顺序打印。i只是循环计数器（比从倒数便宜一点%1）。j是在将前一个数字加倍到将其添加到当前数字以获得下一个数字之间的切换。m并n包含这些数字。l，以及用作临时计算下一个数字的方法，也将其数字替换为空格以进行填充s；s和d经由中间变量每次交换t。