La adición de la pirámide invertida es el proceso de tomar una lista de números y sumarlos consecutivamente hasta llegar a un número.

Cuando se le dan los números 2, 1, 1, ocurre el siguiente proceso:

 2   1   1
   3   2 
     5

Esto termina en el número 5.

TU TAREA

Dado el lado derecho de una pirámide invertida (ascendente), escriba un programa o función que devolverá la lista original.

Nuevo desafío adicional : intente hacer esto en menos de O (n ^ 2)

EJEMPLO

f([5, 2, 1]) => [2, 1, 1]
f([84,42,21,10,2]) => [4,7,3,8,2]

NOTA: La Pirámide invertida nunca estará vacía y siempre consistirá en enteros positivos SOLAMENTE.

JavaScript (ES6),  62 58 49  46 bytes

Guardado 3 bytes gracias a @Oliver

Devuelve la lista como una cadena separada por comas.

f=a=>+a||f(a.map(n=>a-(a=n),a=a.shift()))+[,a]

Pruébalo en línea!

Comentado

f = a =>              // f = recursive function taking the input list a[]
  +a                  // if a[] consists of a single positive integer:
                      //   stop recursion and return this integer
  ||                  // else:
    f(                //   do a recursive call to f:
      a.map(n =>      //     for each value n in a[]:
        a - (a = n),  //       yield the difference between the previous value and n
                      //       and update a to n
        a = a.shift() //       start by removing the first element and saving it in a
                      //       (because of the recursion, it's important here to reuse
                      //       a variable which is defined in the scope of f)
      )               //     end of map()
    )                 //   end of recursive call
    + [, a]           //   append the last entry from a[]

Haskell , 22 bytes

foldl(flip$scanr(-))[]

Pruébalo en línea!

Haskell, 42 bytes

f[]=[]
f a=f(zipWith(-)a$tail a)++[last a]

Pruébalo en línea!

TI-BASIC, 54 bytes

Ans→L₁:dim(L₁→dim(L₂:While 1-Ans:L₁(Ans→L₂(Ans:-ΔList(L₁→L₁:dim(Ans:End:L₁(Ans→L₂(Ans:L₂

La entrada es la lista del lado derecho del triángulo Ans, como se describe en el desafío.
La salida es la fila superior de dicho triángulo.

Ejemplos:

{5,2,1
         {5 2 1}
prgmCDGF19
         {2 1 1}
{84,42,21,10,2
 {84 42 21 10 2}
prgmCDGF19
     {4 7 3 8 2}

Explicación:
Esta solución abusa del hecho de que el triángulo formado usando el lado derecho del triángulo como el inicio termina siendo el cambio en cada elemento.

En otras palabras,

2 1 1
 3 2
  5

se convierte en:

5 2 1
 3 1
  2

Por lo tanto, la lista resultante es el lado derecho de este nuevo triángulo, que puede formarse estableciendo el último elemento en el índice de la longitud de su lista principal en la lista resultante.

Ans→L₁          ;store the input list in L₁
dim(L₁→dim(L₂   ;set the length of L₂ to the length of L₁
While 1-Ans     ;while the L₁'s length is not 1
L₁(Ans→L₂(Ans   ;set the last element of L₁ to the corresponding index in L₂
-ΔList(L₁→L₁    ;get the change in each element, then negate
                ; (elements are in descending order so the change in each
                ;  element will be negative)
                ; and store the resulting list in L₁
dim(Ans         ;leave the length of L₁ in "Ans"
End
L₁(Ans→L₂(Ans   ;set the element again
                ; (needed for final step)
L₂              ;leave L₂ in "Ans"
                ;implicit print of "Ans"

Nota: TI-BASIC es un lenguaje tokenizado. El recuento de caracteres no es igual al recuento de bytes.

Jalea , 6 bytes

ṚIƬZḢṚ

Un enlace monádico que acepta una lista de enteros que produce una lista de enteros.

Pruébalo en línea!

¿Cómo?

Construye todo el triángulo y luego extrae los elementos requeridos.

ṚIƬZḢṚ - Link: list of integers          e.g.  [84,42,21,10,2]
Ṛ      - reverse                               [2,10,21,42,84]
  Ƭ    - collect & apply until a fixed point:
 I     -   incremental differences            [[2,10,21,42,84],[8,11,21,42],[3,10,21],[7,11],[4],[]]
   Z   - transpose                            [[2,8,3,7,4],[10,11,10,11],[21,21,21],[42,42],[84]]
    Ḣ  - head                                  [2,8,3,7,4]
     Ṛ - reverse                               [4,7,3,8,2]

MathGolf , 14 11 bytes

xÆ‼├│?;∟;]x

Pruébalo en línea!

Explicación

x             reverse int/array/string
 Æ     ∟      do while true without popping using 5 operators
  ‼           apply next 2 operators to TOS
   ├          pop from left of list
    │         get differences of list
     ?        rot3
      ;       discard TOS (removes rest from ├ command)
              loop ends here
        ;     discard TOS (removes empty array from stack)
         ]    wrap stack in array
          x   reverse array

Python 2 , 56 bytes

f=lambda a:a and f([l-r for l,r in zip(a,a[1:])])+a[-1:]

Una función recursiva que acepta una lista de enteros positivos que devuelve una lista de enteros no negativos.

Pruébalo en línea!

Jalea , 5 bytes

_ƝƬa/

Pruébalo en línea!

Podemos suponer que toda la pirámide es positiva, por lo que podemos usar una operación && en lugar de una operación "correcta".

Pari / GP , 36 bytes

Basado en el comentario de @Lynn :

$$f([a,b,c,d,e]) = \begin{bmatrix} 1&-4&6&-4&1 \\ 0&1&-3&3&-1 \\ 0&0&1&-2&1 \\ 0&0&0&1&-1 \\ 0&0&0&0&1 \end{bmatrix} \cdot \begin{bmatrix}a\\b\\c\\d\\e\end{bmatrix}$$

Pari / GP tiene una matriz incorporada para Pascal, y su inverso es exactamente la matriz que necesitamos:

a->r=Vecrev;r(r(a)/matpascal(#a-1)~)

Pruébalo en línea!

R , 69 67 bytes

function(n,x=sum(n|1):1-1,`[`=outer)(x[x,choose]*(-1)^x[x,"+"])%*%n

Pruébalo en línea!

Devuelve un vector de columna.

-2 bytes gracias a Kirill L.

También basado en el comentario de Lynn :

$$f([a,b,c,d,e]) = \begin{bmatrix} 1&-4&6&-4&1 \\ 0&1&-3&3&-1 \\ 0&0&1&-2&1 \\ 0&0&0&1&-1 \\ 0&0&0&0&1 \end{bmatrix} \cdot \begin{bmatrix}a\\b\\c\\d\\e\end{bmatrix}$$

Es más largo que la otra respuesta R, pero fue un enfoque interesante para tomar y tratar de jugar al golf.

Javascript (ES6), 127 bytes

f=a=>{for(e=[a],a=[a[l=a.length-1]],i=0;i<l;i++){for(e.push(g=[]),j=-1;j<l;)g.push(e[i][j]-e[i][++j]);r.unshift(g[j])}return r}

Código original

function f(a){
  var e=[a];
  var r=[a[a.length-1]];
  for (var i=1;i<a.length;i++){
    var g=[];
    for (var j=0;j<a.length;j++){
      g.push(e[i-1][j-1]-e[i-1][j]);
    }
    e.push(g);
    r.unshift(g[j-1]);
  }
  return r;
}

Oh, perdí como ... mucho ... a la respuesta anterior ...

Wolfram Language (Mathematica) , 57 bytes

(r=Reverse)[#&@@@Most@NestList[Differences,r@#,Tr[1^#]]]&

Pruébalo en línea!

05AB1E , 12 11 bytes

R.¥.Γ¥}¨ζнR

Puerto de @JonathanAllan jalea respuesta 's , aunque estoy jalea sobre órdenes internas más convenientes de jalea en este caso. ;)
-1 byte gracias a @Emigna .

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

R            # Reverse the (implicit) input-list
             #  i.e. [16,7,4,3] → [3,4,7,16]
 .¥          # Undelta it (with leading 0)
             #  → [0,3,7,14,30]
   .Γ }      # Continue until the result no longer changes, and collect all steps:
     ¥       #  Get the deltas / forward differences of the current list
             #  → [[3,4,7,16],[1,3,9],[2,6],[4],[]]
       ¨     # Remove the trailing empty list
             #  → [[3,4,7,16],[1,3,9],[2,6],[4]]
        ζ    # Zip/transpose; swapping rows/column (with space as default filler)
             #  → [[3,1,2,4],[4,3,6," "],[7,9," "," "],[16," "," "," "]]
         н   # Only leave the first inner list
             #  → [3,1,2,4]
          R  # Revert it back
             #  → [4,2,1,3]
             # (after which it's output implicitly as result)

R , 55 63 55 53 bytes

x=scan();for(i in sum(1|x):1){F[i]=x[i];x=-diff(x)};F

Pruébalo en línea!

-2 bytes gracias a Giuseppe.

Perl 6 , 37 bytes

{[R,]($_,{@(.[]Z-.skip)}...1)[*;*-1]}

Pruébalo en línea!

Se reduce repetidamente por sustracción por elementos, y luego devuelve el último número de cada lista a la inversa.

Explicación:

{                                  }  # Anonymous code block
      $_,               ...   # Create a sequence starting from the input
         {             }      # Where each element is
            .[]Z-.skip          # Each element minus the next element
          @(          )         # Arrayified
                           1  # Until the list has one element left
 [R,]                                # Reverse the sequence
     (                     )[*;   ]  # For every list
                               *-1   # Take the last element

Python 2 , 78 bytes

lambda n,*a:R(lambda r,v:R(lambda x,w:x+[w-x[-1]],r,[v]),a,[n])[::-1]
R=reduce

Pruébalo en línea!

C # (compilador interactivo de Visual C #) , 164 bytes

a=>{int x=a.Length;var l=new int[x][];for(int i=0;i<x;i++){l[i]=new int[x];l[i][0]=a[i];for(int j=0;j<i;j++)l[i][j+1]=l[i-1][j]-l[i][j];}return l.Last().Reverse();}

Pruébalo en línea!

Carbón de leña , 19 bytes

Ｆθ«ＰＩ§θ±¹↑ＵＭθ⁻§θ⊖λκ

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

Ｆθ«

Recorra una vez por cada término en la lista original.

ＰＩ§θ±¹↑

Imprima el último término de la lista, pero mueva el cursor al comienzo de la línea anterior, de modo que los términos se muestren en orden inverso.

ＵＭθ⁻§θ⊖λκ

Calcule los deltas, insertando un valor ficticio al principio para que podamos usar una operación que no cambie la longitud de la lista.

APL + WIN, 34 o 28 bytes

v←⊂⌽⎕⋄1↓⌽↑¨⍎∊'v',(∊⍴¨v)⍴⊂',-2-/¨v'

Pruébalo en línea! Cortesía de Dyalog Classic.

Solicita el vector del lado derecho.

o implementando el enfoque de @ Lynn:

0⍕⌽(⌹⍉n∘.!n←0,⍳¯1+⍴n)+.×⌽n←⎕

¡Pruébelo en línea! Cortesía de Dyalog Classic

Solicita el vector del lado derecho.

Adjunto , 29 bytes

{y.=Delta@-_If[_,$@y'_@-1,y]}

Pruébalo en línea!

Simplemente itera la Deltafunción hasta que esté vacía. Mucho más corto que la PeriodicStepssolución muy detallada ...

C, 76 bytes

i=0;int*f(int*a,int n){for(;i<n;a[i++]=a[i]-a[i+1]);if(!n)return a;f(a,n-1);}  

entrada : (*a = pointer to array, n = last element's index of that array)
salida :return int* = output

Explicación
va del lado derecho hacia arriba, ya que los últimos elementos son los mismos tanto en la entrada como en la salida, la función interior del bucle simplemente encuentra los siguientes números más altos en el triángulo que gradualmente llega a la parte superior dejando la respuesta intacta al final.

sin golf (de C ++)

#include <iostream>
#define SIZE_F 5

int*recFind(int*a, int n) {
    int i = 0;
    while (i < n)
        a[i++] = a[i] - a[i+1];
    if (!n) return a;
        recFind(a, n - 1);
}
int main()
{
    int first[SIZE_F],*n;
    for (int i = 0; i < SIZE_F; i++)
        std::cin >> first[i];

    n = recFind(first, SIZE_F - 1);//size - 1
    for (int i = 0; i < SIZE_F; i++)
        std::cout << n[i];
}

Japt , 11 9 bytes

Nc¡=äa
yÌ

Intentalo

2 bytes guardados gracias a Oliver.

12 11 bytes

_äa}hUÊN yÌ

Intentalo

1 byte guardado gracias a Oliver.

Julia 0.6 , 44 bytes

x->reverse([(j=x[end];x=-diff(x);j)for i=x])

Pruébalo en línea!

El mismo principio iterativo que mi respuesta R.

Julia 0.6 , 55 bytes

x->inv([binomial(i,j)for i=(l=length(x)-1:-1:0),j=l])*x

Pruébalo en línea!

@ Algoritmo de Lynn (inverso de la matriz de Pascal multiplicado por la entrada).