Generate Pascal's Braid
Pyth, 44 bytes
The number generation took 20 bytes, and the formatting took 24 bytes.
jsMC+Led.e.<bkC,J<s.u+B+hNyeNeNQ,1 1Qm*;l`dJ
Try it online!
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 bytes
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
Try it on Ideone.
MATL, 38 bytes
1ti:"yy@oQ*+]vG:)!"@Vt~oX@o?w]&v]&hZ}y
Try it online!
Computing an array with the (unique) numbers takes the first 17 bytes. Formatting takes the remaining 21 bytes.
Explanation
Part 1: generate the numbers
This generates an array with the numbers from the first and second rows in increasing order: [1; 1; 3; 4; 11; 15; ...]. It starts with 1, 1. Each new number is iteratively obtained from the preceding two. Of those, the second is multiplied by 1 or 2 depending on the iteration index, and then summed to the first to produce the new number.
The number of iterations is equal to the input n. This means that n+2 numbers are generated. Once generated, the array needs to be trimmed so only the first n entries are kept.
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
Part 2: format the output
For each number in the obtained array, this generates two strings: string representation of the number, and a string of the same length consisting of character 0 repeated (character 0 is displayed as a space in MATL). For even iterations, these two strings are swapped.
The two strings are then concatenated vertically. So n 2D char arrays are produced as follows (using · to represent character 0):
·
1
1
·
·
3
4
·
··
11
15
··
These arrays are then concatenated horizontally to produce
·1·4··15
1·3·11··
Finally, this 2D char array is split into its two rows, and the first is duplicated onto the top of the stack. The three strings are displayed in order, each on a different line, producing the desired output
! % 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