Đây là Braid của Pascal:

 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

^{Tôi hoàn toàn làm điều đó lên. Blaise Pascal không có bím tóc như tôi có thể nói, và nếu anh ta làm thì có lẽ nó được làm từ tóc thay vì số.}

Nó được định nghĩa như thế này:

1. Cột đầu tiên có một 1ở giữa.
2. Cột thứ hai có một 1ở trên cùng và ở dưới cùng.
3. Bây giờ chúng tôi xen kẽ giữa việc đặt một số ở giữa hoặc hai bản sao của một số ở trên cùng và dưới cùng.
4. Nếu số đi trên đỉnh hoặc dưới cùng, nó sẽ là tổng của hai số liền kề (ví dụ 56 = 15 + 41). Nếu bạn nghiêng đầu một chút, đây giống như một bước trong tam giác của Pascal.
5. Nếu số đi ở giữa, nó sẽ là tổng của cả ba số liền kề (ví dụ 41 = 15 + 11 + 15).

Nhiệm vụ của bạn sẽ là in (một phần của) bím tóc này.

Đầu vào

Bạn nên viết một chương trình hoặc hàm, nhận một số nguyên duy nhất n, đưa ra chỉ mục của cột cuối cùng là đầu ra.

Bạn có thể chọn xem cột đầu tiên (chỉ in một 1dòng trên dòng giữa) có tương ứng với n = 0hoặc n = 1. Điều này phải là một sự lựa chọn phù hợp trên tất cả các đầu vào có thể.

Đầu ra

Braid đầu ra Pascal lên đến ncột thứ. Khoảng trắng phải khớp chính xác với bố cục ví dụ ở trên, ngoại trừ việc bạn có thể đệm (các) dòng ngắn hơn với độ dài của (các) dòng dài hơn với khoảng trắng và bạn có thể tùy ý xuất một nguồn cấp dữ liệu theo dõi đơn.

Nói cách khác, mỗi cột phải chính xác bằng số (hoặc cặp số bằng nhau) trong cột đó, các số trong các cột liên tiếp không được trùng nhau và không có khoảng cách giữa các cột.

Bạn có thể in kết quả sang STDOUT (hoặc thay thế gần nhất) hoặc nếu bạn viết hàm, bạn có thể trả về một chuỗi có cùng nội dung hoặc danh sách ba chuỗi (một chuỗi cho mỗi dòng).

Biết thêm chi tiết

Bạn có thể cho rằng nsẽ không nhỏ hơn chỉ mục của cột đầu tiên (vì vậy không ít hơn 0hoặc 1tùy thuộc vào chỉ mục của bạn). Bạn cũng có thể giả sử rằng số cuối cùng trong bím tóc nhỏ hơn 256 hoặc số lớn nhất được biểu thị theo loại số nguyên gốc của ngôn ngữ của bạn, tùy theo số nào lớn hơn . Vì vậy, nếu loại số nguyên riêng của bạn chỉ có thể lưu trữ byte, bạn có thể giả sử rằng loại lớn nhất nlà 9hoặc 10(tùy thuộc vào việc bạn sử dụng 0 hoặc 1 dựa trên n) và nếu nó có thể lưu trữ số nguyên 32 bit đã ký, nsẽ nhiều nhất 33hoặc 34.

Luật golf tiêu chuẩn được áp dụng. Mã ngắn nhất sẽ thắng.

OEIS

Dưới đây là một vài liên kết OEIS có liên quan. Tất nhiên, những thứ này chứa các spoilers cho các cách khác nhau để tạo ra các số trong bím tóc:

• Trên / dưới: A001353 hoặc A010905 hoặc A106707 hoặc A195503
• Giữa: A001835 hoặc A079935
• Cả hai: A002530

Các trường hợp thử nghiệm

Những trường hợp thử nghiệm sử dụng lập chỉ mục 1 cơ sở. Mỗi trường hợp thử nghiệm là bốn dòng, đầu tiên là đầu vào và ba dòng còn lại là đầu ra.

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

Thạch , 31 30 29 byte

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

Đây là một liên kết đơn nguyên; nó chấp nhận một chỉ mục cột dựa trên 0 làm đối số và trả về một danh sách các chuỗi.

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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.

Bình thường , 44 byte

Việc tạo số lấy 20 byte và định dạng mất 24 byte.

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

Hãy thử trực tuyến!

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 byte

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

Hãy thử nó trên Ideone.

MATL , 38 byte

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

Hãy thử trực tuyến!

Việc tính toán một mảng với các số (duy nhất) sẽ mất 17 byte đầu tiên. Định dạng mất 21 byte còn lại.

Giải trình

Phần 1: tạo số

Điều này tạo ra một mảng với các số từ hàng đầu tiên và thứ hai theo thứ tự tăng dần : [1; 1; 3; 4; 11; 15; ...]. Nó bắt đầu với 1, 1. Mỗi số mới được lặp lại từ hai số trước. Trong số đó, số thứ hai được nhân với 1hoặc 2phụ thuộc vào chỉ số lặp, và sau đó được tổng hợp thành số thứ nhất để tạo ra số mới.

Số lần lặp bằng với đầu vào n. Điều này có nghĩa là n+2số được tạo ra. Sau khi tạo, mảng cần được cắt bớt để chỉ các nmục đầu tiên được giữ.

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

Phần 2: định dạng đầu ra

Đối với mỗi số trong mảng thu được, điều này tạo ra hai chuỗi: biểu diễn chuỗi của số đó và một chuỗi có cùng độ dài bao gồm ký tự 0 được lặp lại (ký tự 0 được hiển thị dưới dạng khoảng trắng trong MATL). Đối với các lần lặp thậm chí, hai chuỗi này được hoán đổi.

Hai chuỗi sau đó được nối theo chiều dọc. Vì vậy, nmảng char 2D được tạo ra như sau (sử dụng ·để thể hiện ký tự 0):

·
1

1
·

· 
3

4
·

·· 
11

15
··

Các mảng này sau đó được nối theo chiều ngang để tạo ra

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

Cuối cùng, mảng char 2D này được chia thành hai hàng và hàng đầu tiên được sao chép trên đỉnh của ngăn xếp. Ba chuỗi được hiển thị theo thứ tự, mỗi chuỗi trên một dòng khác nhau, tạo ra đầu ra mong muốn

!       % 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 byte

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

Xác định một hàm f :: Int → [String].

• Michael Klein nhắc nhở tôi rằng tôi không cần phải gọi unlineskết quả, tiết kiệm 7 byte. Cảm ơn!

• Tôi đã lưu một byte bằng cách thay thế " 9"!!mod i 2bằng cycle" 9"!!i.

• Thêm ba byte bằng cách viết hai danh sách corecursive thay vì sử dụng drop.

• Bạn gái của tôi chỉ ra rằng tôi có thể lưu thêm hai byte bằng cách bắt đầu câu trả lời của mình 0thay vì 1.

C, 183 177 176 byte

#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);}

Giải trình

C sẽ không bao giờ giành được bất kỳ giải thưởng nào cho sự ngắn gọn trước một ngôn ngữ cấp cao hơn, nhưng bài tập rất thú vị và thực hành tốt.

Macro F tắt sáu byte với chi phí dễ đọc. Các biến được khai báo trên toàn cầu để tránh nhiều khai báo. Tôi cần một bộ đệm ký tự cho sprintf, nhưng vì K & R lỏng lẻo với việc kiểm tra kiểu, sprintf và printf có thể hiểu t [9] là một con trỏ tới bộ đệm 36 byte. Điều này tiết kiệm một tuyên bố riêng.

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

Chức năng in đẹp, trong đó r là số hàng. Sprintf định dạng số và tính chiều rộng cột. Để tiết kiệm không gian, chúng tôi chỉ cần gọi ba lần, một lần cho mỗi hàng đầu ra; biểu thức ri & 1 lọc những gì được in.

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

Hàm điểm nhập, đối số là số cột. Tính toán mảng a của các giá trị cột a [], sau đó gọi hàm in p một lần cho mỗi hàng đầu ra.

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

Gọi mẫu (không bao gồm trong câu trả lời và số byte):

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

Đã cập nhật

Kết hợp đề xuất chạy nước rút nội tuyến từ tomsmeding. Điều đó làm giảm số lượng từ 183 xuống 177 ký tự. Điều này cũng cho phép loại bỏ các dấu ngoặc xung quanh khối printf (sprintf ()) vì hiện tại nó chỉ có một câu lệnh, nhưng điều đó chỉ lưu một ký tự vì nó vẫn cần một khoảng trắng làm dấu phân cách. Vì vậy, xuống 176.

PowerShell v2 +, 133 byte

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 byte để tính toán các giá trị, 70 byte để xây dựng ASCII}

Lấy đầu vào $nlà cột không có chỉ mục. Đặt điểm bắt đầu của chuỗi trình tự của chúng tôi $a=1,1. Chúng tôi sau đó lặp lại $nvới 1..$n|%{...}để xây dựng các mảng. Mỗi lần lặp lại, chúng tôi nối vào tổng của (hai phần tử trước) + (phần tử trước) * (cho dù chúng tôi là số lẻ hay chỉ mục chẵn). Điều này sẽ tạo ra $a=1,1,3,4,11...lên đến $n+2.

Vì vậy, chúng ta cần cắt lát $ađể chỉ lấy các 0..$nphần tử đầu tiên và dẫn chúng qua một vòng lặp khác |%{...}. Mỗi lần lặp chúng ta đặt trình trợ giúp $zbằng một số khoảng trắng cộng với phần tử hiện tại dưới dạng chuỗi. Sau đó, chúng tôi sẽ phân tách xem liệu điều đó được nối vào $x(hàng trên cùng và dưới cùng) hay $y(hàng giữa) bằng một số lẻ-chẵn if/ đơn giản else. Sau đó, chúng tôi tính toán số lượng khoảng trắng cho $lbằng cách lấy số hiện tại, xâu chuỗi nó và lấy nó .Length.

Cuối cùng, chúng tôi đặt $x, $yvà $xmột lần nữa vào đường ống dẫn, và đầu ra là ẩn. Vì .ToString()dấu phân cách mặc định cho một mảng khi in sang STDOUT là một dòng mới, chúng tôi nhận được nó miễn phí.

Thí dụ

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 byte

<?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]);

Chưa chơi gôn:

$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 byte

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 byte

Trả về một chuỗi nhiều dòng.

Hãy thử trực tuyến!

->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 ký tự, 226 byte

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,[])

Ungolfed và bình luận:

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 byte

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

lợi dụng các kiểu chữ ngầm định và các biến biến
một phần ba mã (37 byte) đi vào khoảng trắng, 64 byte được sử dụng hoàn toàn cho đầu ra

phá vỡ

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

Hàng loạt, 250 byte

@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%

Vì các dòng đầu tiên và thứ ba là như nhau, chúng ta chỉ cần xây dựng hai chuỗi. Ở đây dđại diện cho chuỗi kết thúc bằng mục cuối cùng và sđại diện cho chuỗi kết thúc bằng dấu cách; bốn dòng cuối cùng đảm bảo rằng chúng được in theo thứ tự thích hợp. ichỉ là bộ đếm vòng lặp (rẻ hơn một chút so với đếm ngược từ %1). jlà chuyển đổi giữa nhân đôi số trước đó trước khi thêm nó vào số hiện tại để lấy số tiếp theo. mvà nchứa những con số đó. l, cũng như được sử dụng tạm thời để tính số tiếp theo, cũng được thay thế các chữ số của nó bằng khoảng trắng để điền vào s; svà dđược trao đổi mỗi lần thông qua biến trung gian t.