Questa è la treccia di 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

^{L'ho completamente inventato. Blaise Pascal non aveva una treccia per quanto ne so, e se lo facesse probabilmente era fatto di capelli anziché di numeri.}

Si definisce così:

1. La prima colonna ha un singolo 1nel mezzo.
2. La seconda colonna ha una 1in alto e in basso.
3. Ora alterniamo inserendo un numero nel mezzo o due copie di un numero in alto e in basso.
4. Se il numero va in cima o in fondo, sarà la somma dei due numeri adiacenti (ad es 56 = 15 + 41.). Se inclini leggermente la testa, questo è come un passo nel triangolo di Pascal.
5. Se il numero va nel mezzo, sarà la somma di tutti e tre i numeri adiacenti (ad es 41 = 15 + 11 + 15.).

Il tuo compito sarà stampare (una parte di) questa treccia.

Ingresso

È necessario scrivere un programma o una funzione, che riceve un singolo numero intero n, fornendo l'indice dell'ultima colonna da emettere.

Puoi scegliere se la prima colonna (stampando solo una 1riga sulla linea centrale) corrisponde a n = 0o n = 1. Questa deve essere una scelta coerente tra tutti i possibili input.

Produzione

Output Treccia di Pascal fino alla ncolonna th. Lo spazio bianco deve corrispondere esattamente al layout di esempio sopra, tranne per il fatto che è possibile riempire le linee più corte con la lunghezza delle linee più lunghe con spazi e si può facoltativamente produrre un singolo avanzamento riga finale.

In altre parole, ogni colonna dovrebbe essere esattamente larga quanto il numero (o coppia di numeri uguali) in quella colonna, i numeri nelle colonne successive non dovrebbero sovrapporsi e non dovrebbero esserci spazi tra le colonne.

È possibile stampare il risultato su STDOUT (o l'alternativa più vicina) oppure, se si scrive una funzione, è possibile restituire una stringa con lo stesso contenuto o un elenco di tre stringhe (una per ogni riga).

Maggiori dettagli

Puoi presumere che nnon sarà inferiore all'indice della prima colonna (quindi non inferiore 0o 1dipendente dall'indicizzazione ). Puoi anche supporre che l'ultimo numero nella treccia sia inferiore a 256 o il numero più grande rappresentabile dal tipo intero nativo della tua lingua, a seconda di quale sia maggiore . Quindi, se il tuo tipo intero nativo può memorizzare solo byte, puoi supporre che il più grande nsia 9o 10(a seconda che tu usi 0 o 1-based n) e se può memorizzare numeri interi a 32 bit firmati, nsarà al massimo 33o 34.

Si applicano le regole standard del code-golf . Vince il codice più corto.

OEIS

Ecco alcuni link OEIS pertinenti. Naturalmente, questi contengono spoiler per diversi modi per generare i numeri nella treccia:

• Alto / basso: A001353 o A010905 o A106707 o A195503
• Al centro: A001835 o A079935
• Entrambi: A002530

Casi test

Questi casi di test utilizzano l'indicizzazione su 1 base. Ogni test case è composto da quattro righe, con la prima come input e le restanti tre come output.

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

Gelatina , 31 30 29 byte

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

Questo è un collegamento monadico; accetta un indice di colonna basato su 0 come argomento e restituisce un elenco di stringhe.

Provalo online!

Come funziona

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 byte

La generazione del numero ha richiesto 20 byte e la formattazione ha richiesto 24 byte.

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

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

Provalo su Ideone.

MATL , 38 byte

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

Provalo online!

Il calcolo di un array con i numeri (univoci) richiede i primi 17 byte. La formattazione richiede i 21 byte rimanenti.

Spiegazione

Parte 1: genera i numeri

Questo genera un array con i numeri della prima e della seconda fila in ordine crescente: [1; 1; 3; 4; 11; 15; ...]. Si inizia con 1, 1. Ogni nuovo numero è ottenuto iterativamente dai precedenti due. Di questi, il secondo viene moltiplicato per 1o in 2base all'indice di iterazione e quindi sommato al primo per produrre il nuovo numero.

Il numero di iterazioni è uguale all'input n. Ciò significa che n+2vengono generati numeri. Una volta generato, l'array deve essere tagliato in modo da mantenere solo le prime nvoci.

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

Parte 2: formattare l'output

Per ogni numero nell'array ottenuto, ciò genera due stringhe: rappresentazione stringa del numero e una stringa della stessa lunghezza composta dal carattere 0 ripetuto (il carattere 0 viene visualizzato come spazio in MATL). Per le iterazioni uniformi, queste due stringhe vengono scambiate.

Le due stringhe vengono quindi concatenate verticalmente. Quindi i ncaratteri 2D sono prodotti come segue (usando ·per rappresentare il carattere 0):

·
1

1
·

· 
3

4
·

·· 
11

15
··

Questi array vengono quindi concatenati orizzontalmente per produrre

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

Infine, questo array di caratteri 2D viene suddiviso in due righe e il primo viene duplicato nella parte superiore dello stack. Le tre stringhe vengono visualizzate in ordine, ognuna su una riga diversa, producendo l'output desiderato

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

Definisce una funzione f :: Int → [String].

• Michael Klein mi ha ricordato che non avevo bisogno di chiamare unlinesil risultato, risparmiando 7 byte. Grazie!

• Ho salvato un byte sostituendolo " 9"!!mod i 2con cycle" 9"!!i.

• Altri tre byte scrivendo due elenchi corecursive invece di utilizzare drop.

• La mia ragazza ha sottolineato che posso salvare altri due byte avviando le mie risposte 0invece di 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);}

Spiegazione

C non vincerà mai alcun premio per brevità contro un linguaggio di livello superiore, ma l'esercizio è interessante e buona pratica.

La macro F si elimina di sei byte a costo di leggibilità. Le variabili sono dichiarate a livello globale per evitare dichiarazioni multiple. Avevo bisogno di un buffer di caratteri per sprintf, ma poiché K&R è libero con il controllo del tipo, sprintf e printf possono interpretare t [9] come un puntatore a un buffer di 36 byte. Questo salva una dichiarazione separata.

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

Bella funzione di stampa, dove r è il numero di riga. Sprintf formatta il numero e calcola la larghezza della colonna. Per risparmiare spazio, lo chiamiamo tre volte, uno per ogni riga di output; l'espressione ri & 1 filtra ciò che viene stampato.

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

Funzione punto di ingresso, argomento è il numero di colonne. Calcola la matrice a dei valori di colonna a [], quindi chiama la funzione di stampa p una volta per ogni riga di output.

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

Richiamo del campione (non incluso nella risposta e nel conteggio dei byte):

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

aggiornato

Incorporato il suggerimento di sprint in linea dal tomsmeding. Ciò ha ridotto il conteggio da 183 a 177 caratteri. Ciò consente anche di rimuovere le parentesi graffe attorno al blocco printf (sprintf ()) poiché ora è solo un'istruzione, ma ciò ha salvato solo un carattere perché ha ancora bisogno di uno spazio come delimitatore. Quindi fino a 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 per calcolare i valori, 70 byte per formulare l'ASCII}

Accetta input $ncome colonna con indice zero. Imposta l'inizio del nostro array di sequenze $a=1,1. Quindi eseguiamo il ciclo $ncon 1..$n|%{...}per costruire l'array. Ogni iterazione, ci concateniamo sulla somma di (due elementi fa) + (l'elemento precedente) * (sia che siamo pari o dispari indice). Questo genererà$a=1,1,3,4,11... fino a $n+2.

Quindi, dobbiamo tagliare $aper prendere solo i primi 0..$nelementi e convogliarli attraverso un altro loop |%{...}. Ogni iterazione che impostiamo come helper è $zuguale a un numero di spazi più l'elemento corrente come stringa. Quindi, stiamo dividendo se questo viene concatenato su $x(la riga superiore e inferiore) o $y(la riga centrale) da un semplice pari-dispari if/ else. Quindi, calcoliamo il numero di spazi per $lprendendo il numero corrente, stringendolo e prendendolo .Length.

Infine, abbiamo messo $x, $ye $xancora una volta sul gasdotto, e l'uscita è implicito. Poiché il .ToString()separatore predefinito per un array durante la stampa su STDOUT è una nuova riga, lo otteniamo gratuitamente.

Esempio

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

Un-giocato a golf:

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

Rubino, 120 byte

Restituisce una stringa multilinea.

Provalo online!

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

Ungolf e commentato:

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

sfruttando i typecast impliciti e le variabili variabili,
un terzo del codice (37 byte) va negli spazi, 64 byte utilizzati complessivamente per l'output

abbattersi

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

Lotto, 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%

Poiché la prima e la terza riga sono uguali, non ci resta che costruire due stringhe. Qui drappresenta la stringa che termina con l'ultima voce e srappresenta la stringa che termina con spazi; le ultime quattro righe assicurano che siano stampate nell'ordine appropriato. iè solo il contatore di loop (è leggermente più economico del conto alla rovescia da %1). jè il passaggio tra il raddoppio del numero precedente prima di aggiungerlo al numero corrente per ottenere il numero successivo. me ncontenere quei numeri. l, oltre ad essere utilizzato come temporaneo per calcolare il numero successivo, ottiene anche le sue cifre sostituite con spazi da riempire s;se dvengono scambiati ogni volta tramite la variabile intermedia t.