Desafío

Dada una secuencia de enteros no negativos, cree una función que genere una pirámide descendente donde los hijos son la suma de ambos números primarios.

El resultado se genera como una cadena usando tab \t.

Nota: no se requieren pestañas finales en cada línea

1\t\t2\t\t3\n\t3\t\t5\t\n\t\t8\t\t results in 
1       2       3
    3       5   
        8       

Opcionalmente, el resultado se puede generar como una matriz utilizando una posición vacía como espacio.

[[1,,2,,3],
[,3,,5,],
[,,8,,]]

Ejemplo:

4,5,7,3,4,2Salida dada :

4       5       7       3       4       2
    9       12      10      7       6
        21      22      17      13
            43      39      30
                82      69
                    151

Reglas

• Aplican reglas estándar de código de golf
• La entrada puede ser una cadena usando cualquier separador o una matriz
• Se permiten nuevas líneas y pestañas iniciales / finales (pero no se requieren siempre que la salida sea una pirámide invertida)

Casos de prueba

Input: 1,3,5

1       3       5
    4       8
        12


Input: 9,8,7,6,5

9       8       7       6       5
    17      15      13      11
        32      28      24
            60      52
                112


Input: 5,5,2,5

[[5,,5,,2,,5],
[,10,,7,,7,],
[,,17,,14,,],
[,,,31,,,]]

Input: 3,3,3

[[3,,3,,3],
[,6,,6,],
[,,12,,]]

El criterio ganador es code-golf

Nota: Este desafío está muy cerca del Generar el triángulo de Pascal . La diferencia es la secuencia de inicio personalizada (pascal va desde 1 y en modo ascendente, esto desde una entrada y en modo descendente).

Publicación de sandbox

APL (Dyalog Unicode) , 31 28 bytes ^SBCS

Función de prefijo tácito. Utiliza un solo espacio como marcador de ranura vacío. Devuelve la lista de listas de números / espacios.

⍳∘≢{∊(⍺⍴''),,∘' '¨2+/⍣⍺⊢⍵}¨⊂

Pruébalo en línea!

⍳∘≢{… }¨⊂ Aplique la siguiente función para cada uno de
⍳los of nices  ∘de  ≢la cuenta con
⊂el argumento completo:

 ⊢⍵ producir el argumento correcto (la entrada original)

 2+/⍣⍺ aplique la suma por pares tantas veces como lo indique el argumento izquierdo

 ,∘' '¨ agrega un espacio a cada número

 (... ), agregue eso a lo siguiente:

  ⍺⍴'' Elementos de argumento izquierdo de la cadena vacía (rellenados con espacios)

 ∊ ϵ nlist (aplanar)

05AB1E , 15 bytes

gFD„		ý'	N×ì,ü+

Pruébalo en línea!

Wolfram Language (Mathematica) , 74 bytes

ArrayPad[Riffle[#,],k++,]&/@NestList[k=0;BlockMap[Tr,#,2,1]&,#,Tr[1^#]-1]&

Pruébalo en línea!

Jalea ,  14  13 bytes

^{14 -> 13 asume que solo se permite la entrada de espacios finales en la salida del formato de lista; si no, volveré a los 14 ( preguntado )}

+ƝƬK€z⁶Zṙ"JC$

Un enlace monádico. La salida es una lista de listas que utilizan caracteres de espacio como espacios (incluye una sola entrada de espacios finales).

Pruébalo en línea! (incluye un pie de página para mostrar la estructura de la lista ya que ejecutar el enlace monádico como un programa completo imprimirá la salida aplastada implícitamente).

Casco , 22 bytes

zoΣ~+R"	"oJ"		"msNU¡Ẋ+

Pruébalo en línea!

Explicación

z(Σ~+R" "(J"  "ms))NU¡Ẋ+  -- example input: [1,2,3]
                     ¡    -- infinitely do and collect in list
                      Ẋ+  -- | sum adjacent
                          -- : [[1,2,3],[3,5],[8],[],[],...
                    U     -- keep up until first repetition: [[1,2,3],[3,5],[8],[]]
z(                )N      -- zip with natural numbers under (example on 1 [1,2,3])
   ~+    (       )        -- | join arguments modified by
     R" "                 -- | | replicate tab: " "
               ms         -- | | show each: ["1","2","3"]
          J"  "           -- | | join with 2 tabs: ["1","  ","2","  ","3"]
                          -- | : [" ","1","  ","2","  ","3"]
  Σ                       -- | concatenate: " 1  2  3"
                          -- : [" 1  2  3","  3  5","   8"]

JavaScript (ES6), 73 bytes

Código fuente extraño ... De todos modos, ¡eso es código golf !

Incluye espacios en blanco iniciales y finales.

f=(a,p=`
`)=>p+a.join`		`+(1/(y=a.shift())?f(a.map(x=>y+(y=x)),p+`	`):'')

Pruébalo en línea!

Perl 5 -a , 62 bytes

$,="\t\t";do{say"\t"x$i++,@F;map$_+=$F[++$q[@F]],@F}while$#F--

Pruébalo en línea!

Python 3 , 101 93 80 bytes

Ahorré 7 bytes (en map(str,x)lugar de for ine init y as '') y me libré de las nuevas líneas finales (en x and[lugar de print(), gracias a Jo King .

Guardado 13 bytes (en [*map(sum,zip(x,x[1:]))]lugar de [x[j]+x[j+1]for j in range(len(x)-1)]) gracias a los ovs .

f=lambda x,y='':x and[y+'		'.join(map(str,x))]+f([*map(sum,zip(x,x[1:]))],y+'	')

Pruébalo en línea!

Retina , 35 bytes

+¶<`\d+ *(?=(\d+)?)
    $#1*$.(*_$1*)   

Pruébalo en línea! Explicación:

+

Repita hasta que el búfer deje de cambiar,

¶<`

Imprima el contenido del búfer antes de la sustitución, con una nueva línea final, y

\d+ *(?=(\d+)?)
    $#1*$.(*_$1*)   

Sustituya un solo número con un par de pestañas, pero un número seguido de otro número con una pestaña, la suma y otra pestaña.

C (clang) , 112 bytes

j,k;f(*i,c){for(j=c+1;--j;puts("")){for(k=c-j;k--;)printf("\t");for(;++k<j;i[k]+=i[k+1])printf("%d\t\t",i[k]);}}

Pruébalo en línea!

Rojo , 151 bytes

func[b][m: length? b repeat n m[loop n - 1[prin"^-"]print replace/all
form b" ""^-^-"c: copy[]repeat i -1 + length? b[append c b/(i) + b/(i + 1)]b: c]]

Pruébalo en línea!

Más legible:

f: func [ b ] [
    m: length? b
    repeat n m [
        loop n - 1 [ prin tab ]
        print replace/all form b " " rejoin [ tab tab ]
        c: copy []
        repeat i (length? b) - 1 [
            append c b/(i) + b/(i + 1)
        ]
        b: c
    ]
]

Perl 6 , 50 48 bytes

{$_,{say "	"x$++~.join("		");$_[1..*]Z+@$_}...0}

Pruébalo en línea!

Bloque de código anónimo que toma una lista de enteros e imprime la pirámide invertida.

C # (compilador de Visual C #) , 163 bytes

b=>{var s="";var c=b.Length;for(int i=0;i<c;i++){for(int z=0;z<i;z++)s+="\t";for(int x=0;x<c-i;x++){s+=b[x]+"\t\t";b[x]=x==c-i-1?0:b[x]+b[x+1];}s+="\n";}return s;}

Pruébalo en línea!

Legible:

b =>    {
            var s = "";
            var c = b.Length;
            for (int i = 0; i < c; i++)
            {
                for (int z = 0; z < i; z++)
                    s += "\t";
                for (int x = 0; x < c - i; x++)
                {
                    s += b[x] + "\t\t";
                    b[x] = x == c - i - 1 ? 0 : b[x] + b[x + 1];
                }
                s += "\n";
            }
            return s;
        }

Japt -Rx , 20 18 bytes

La segunda línea incluye una pestaña final.

Nc¡=ä+
Ëq' ² iEç'  

Intentalo

Explicación

                  :Implicit input of array U
N                 :The array of inputs (NOT the input array)
 c                :Concatenate
  ¡               :  Map U
    ä+            :    Consecutive sums of U
   =              :    Reassign to U for next iteration
\n                :Reassign the resulting 2D-array to U
Ë                 :Map each array at index E
 q                :  Join with
  '\t             :   Tab
     ²            :   Repeated twice
       i          :  Prepend
          '\t     :   Tab
         ç        :   Repeated
        E         :   E times
                  :Implicitly join with newlines, trim (not strictly necessary) and output.