Deltas inversos de una matriz

Su tarea es, dada una matriz de enteros con signo de 32 bits, recompilarlo con sus deltas inversos. Por ejemplo, la lista

1  3  4  2  8

sostiene los deltas:

  2  1 -2  6

que luego se niegan, produciendo:

 -2 -1  2 -6

y recompilado, produciendo:

1 -1 -2  0 -6

como resultado final

De entrada y salida

Se le dará una lista / matriz / tabla / tupla / pila / etc. de enteros con signo como entrada a través de cualquier método de entrada estándar.

Debe generar los datos modificados una vez más en cualquier forma aceptable, siguiendo el método de inversión delta anterior.

Recibirá N entradas 0 < N < 10donde cada número cae dentro del rango-1000 < X < 1000

Casos de prueba

5 6 7 8          -> 5 4 3 2
1 3 4 2 8        -> 1 -1 -2 0 -6
32 18 25 192 199 -> 32 46 39 -128 -135

Notas

• No está restringido al método basado en delta: si puede resolver el método más fácil (que no debería ser demasiado difícil) , puede usarlo libremente.
• Como se indicó anteriormente, siempre recibirá al menos 1 entrada y no más de 9.
• El primer número de la salida siempre debe ser el primer número de la entrada, si este no es el caso, su método es incorrecto.
• Solo se acepta la entrada de salida estándar
• Se aplican lagunas estándar
• Este es el código de golf , por lo que gana el conteo de bytes más bajo.
• ¡Que te diviertas!

Tenemos un ganador.

Dennis 's Jelly Answer at Tiny 3 Bytes se ha llevado a casa el oro, debido al hecho de que tengo la impresión de que no puede ser vencido.

Estaba un poco decepcionado porque no pude ver una respuesta basada en la especificación original, sin embargo, más tarde podría ofrecer una recompensa por eso.

Jalea , 7 3 bytes

ḤḢ_

Pruébalo en línea!

Antecedentes

Los deltas de (a, b, c, d) son b - a , c - b , y d - c . Reducción acumulativa (a, b - a, c - b, d - c) por sustracción de rendimientos a - (b - a) = 2a - b , 2a - b - (c - b) = 2a - c , y 2a - c - (d - c) = 2a - d , entonces el resultado correcto es (2a - a, 2a - b, 2a - c, 2a - d) .

Cómo funciona

ḤḢ_  Main link. Argument: A (array)

Ḥ    Unhalve; multiply all integers in A by 2.
 Ḣ   Head; extract first element of 2A.
  _  Subtract the elements of A from the result.

Python 2, 30 bytes

lambda x:[x[0]*2-n for n in x]

Pruébalo en Ideone .

Cómo funciona

Los deltas de (a, b, c, d) son b - a , c - b , y d - c . La reducción acumulativa (a, b - a, c - b, d - c) por sustraccióng produce a - (b - a) = 2a - b , 2a - b - (c - b) = 2a - c , y 2a - c - (d - c) = 2a - d , entonces el resultado correcto es (2a - a, 2a - b, 2a - c, 2a - d) .

Mathematica, 8 bytes

2#-{##}&

Función sin nombre que toma un número indeterminado de argumentos. Esto utiliza una forma "fácil": niega la lista completa y agrega dos veces el primer elemento (original).

Llamado por ejemplo como 2#-{##}&[1,3,4,2,8]; devuelve una lista como {1,-1,-2,0,-6}.

JavaScript (ES6), 21

Thx @Dennis

l=>l.map(v=>l[0]*2-v)

05AB1E , 4 bytes

¬·s-

Pruébalo en línea! o como un conjunto de pruebas

Explicación

¬     # head of input list
 ·    # multiplied by 2
  s   # swap with input list
   -  # subtract

Python, 44 bytes

lambda l:[l[0]]+[x-(x-l[0])*2for x in l[1:]]

Esto utiliza el "método más fácil".

Pyth, 5 bytes

-LyhQ

Intérprete en línea!

R, 23 18 17 bytes

x=scan();2*x[1]-x

¡vectorización automática e impresión predeterminada al rescate!

Ruby, 23 bytes

->l{l.map{|x|l[0]*2-x}}

No particularmente original.

Perl 6 ,  40  16 bytes

{[\+] .[0],|.rotor(2=>-1).map({[-] @_})}

{.map(.[0]*2-*)}

Expandido:

{ # bare block lambda with single implicit parameter ｢$_｣ ( input is a List )

  [\[+]]  # triangle reduce the following using ｢&infix:<+>｣

    .[0], # the first value

    |(    # Slip this list into outer one ( Perl 6 doesn't auto flatten )

      .rotor( 2 => -1 ) # take the input 2 at a time, backing up 1
      .map({ [-] @_ })  # reduce the pairs using ｢&infix:<->｣

    )
}

{ # bare block lambda with single implicit parameter ｢$_｣ ( input is a List )

  .map(          # map over the inputs
    .[0] * 2 - * # take the first value multiply by 2 and subtract the current value
    #          ^- this makes the statement a WhateverCode, and is the input
  )
}

Brain-Flak , 76 Bytes

([][()]){{}(({})<(({}){}[{}]<>)<>>)([][()])}{}({}<<>([]){{}({}<>)<>([])}<>>)

Pruébalo en línea!

Explicación:

Part 1:
(      )                                        # Push:
 []                                             # the height of the stack
   [()]                                         # minus 1
        {                                  }    # While the height - 1 != 0:
         {}                                     # Pop the height
           (({})<                               # Hold onto the top value, but put it back.
                                                # This ensures that the top value is always
                                                # what was the first element of input
                 (            )                 # Push:
                  ({}){}                        # Top * 2
                        [{}]                    # minus the next element
                            <> <>               # onto the other stack

                                 >)             # Put back the element we held onto.
                                   (      )     # Push:
                                    []          # The height of the stack
                                      [()]      # Minus 1  
                                            {}  # Pop the counter used for the height
Part 2:
({}<                                            # Hold onto the top element.
                                                # This was the first number for input
                                                # so it needs to end up on top
    <>                                          # Switch stacks
      ([])                                      # Push the height of the stack
          {              }                      # While the height != 0:
           {}                                   # Pop the height
             (    )                             # Push:
              {}                                # The top element of this stack
                <>                              # onto the other stack
                   <>                           # and switch back
                     ([])                       # Push the new height of the stack
                          <>                    # After every element has switched stacks
                                                # (which reverses their order),
                                                # switch stacks
                            >)                  # Push the first element back on

Haskell, 20 19 bytes

f(x:r)=x:map(2*x-)r

La misma solución que Dennis, gracias por su idea de 2a - x.

Guardado un byte gracias a Christian Severs.

Pyke, 5 4 bytes

h}m-

Pruébalo aquí!

PHP, 48 bytes

for(;''<$c=$argv[++$i];)echo-$c+2*$a=$a??$c,' ';

Usando la técnica de Dennis. Usar como:

php -r "for(;''<$c=$argv[++$i];)echo-$c+2*$a=$a??$c,' ';" 1 3 4 2 8

Versión de 55 bytes no Dennis:

for(;''<$c=$argv[++$i];$l=$c)echo$a+=($l??$c*2)-$c,' ';

APL, 8 bytes

+\⊃,2-/+

Explicación:

+\           ⍝ running sum of
  ⊃          ⍝ first item of list
   ,         ⍝ followed by
    2-/      ⍝ differences between every pair in
       +     ⍝ input list

Casos de prueba:

      ( +\⊃,2-/+ ) ¨ (5 6 7 8) (1 3 4 2 8) (32 18 25 192 199)
┌───────┬────────────┬──────────────────┐
│5 4 3 2│1 ¯1 ¯2 0 ¯6│32 46 39 ¯128 ¯135│
└───────┴────────────┴──────────────────┘

Laberinto , 34 bytes

?:_2*}
@    _
)\?_1"
,    ;
!`-}:{

Pruébalo en línea!

Utiliza el enfoque de @Dennis(2a - a, 2a - b, 2a - c, 2a - d) .

Las baldosas amarillas son para controlar el flujo. En este lenguaje de programación 2D, el programa comienza en el mosaico superior izquierdo que se mueve hacia el este para comenzar. En los cruces, la dirección está determinada por el signo de la parte superior de la pila principal. Los azulejos en blanco son paredes.

Verde

Esta sección guarda 2a en la pila auxiliar.

• ? Obtenga el primer número y empújelo a la parte superior de la pila principal
• : Duplicar la parte superior de la pila.
• _2 Empuja dos hacia la parte superior de la pila
• *Pop y, pop x, pushx*y
• } Mueva la parte superior de la pila principal a la parte superior de la pila auxiliar.
• _ Empuja cero a la parte superior de la pila

naranja

Esta sección resta 2a del número actual, niega el resultado, emite el resultado, obtiene el siguiente carácter (el delimitador), sale si EOF, emite una nueva línea, obtiene el siguiente número.

• "Noop Si viene desde el norte, la parte superior de la pila será cero y el programa continuará hacia el sur. Si viene desde el oeste, la parte superior de la pila será una y el programa girará a la derecha (continuando hacia el sur)
• ;Desecha la parte superior de la pila. Como el cero o uno solo se usa para controlar el flujo, debemos descartarlos
• { Mueva la parte superior de la pila auxiliar (2a) a la parte superior de la pila principal
• : Duplicar la parte superior de la pila principal
• } Mueva la parte superior de la pila principal a la parte superior de la pila auxiliar
• -Pop y, pop x, pushx-y
• \`` Negate the top of the stack. This and the previous three operations have the effect of- (x-2a) = 2a-x`
• ! Haga estallar la parte superior de la pila y envíela como un número.
• , Empuje el siguiente carácter (que será el delimitador) o negativo si EOF
• )Incrementa la parte superior de la pila. Si el último carácter es EOF, entonces la parte superior de la pila ahora será cero y el programa continuará directamente hasta la @salida. Si el último carácter era un delimitador, entonces la parte superior de la pila será positiva, haciendo que el programa gire a la derecha y continúe hacia el este hasta el\
• \ Salida de una nueva línea
• ? Obtén el siguiente número
• _1 Empuja uno hacia la parte superior de la pila para girar a la derecha en el cruce

Laberinto , 24 bytes

+:}:?
}
<}}?;%):,\!-{:{>

El formato de entrada y salida son listas separadas por salto de línea (aunque el formato de entrada es en realidad mucho más flexible). El programa termina con un error.

Pruébalo en línea!

Tengo otras dos soluciones en este recuento de bytes, que funcionan básicamente igual pero usan un flujo de control algo diferente.

:+:}:?
{
,}-!
?  {
:";\@

{:+:}:?
_
<>__-?:;%):,\!

Explicación

El puntero de instrucciones (IP) comienza a moverse hacia el este a lo largo de la primera línea, pero todos los comandos anteriores ?son básicamente no operacionales en el estado global, ya que no estamos usando comandos de profundidad de pila en ninguna parte. Entonces, el código realmente comienza en el ?oeste, ya que la IP se da vuelta cuando llega al callejón sin salida.

Por lo tanto, el código comienza con el siguiente bit lineal de código:

?:}:+}

Esto simplemente nos configura con una copia de 2apara usar la [2a - a, 2a - b, 2a - c, ...]fórmula.

?   Read first integer a.
:}  Move a copy off to the auxiliary stack.
:+  Multiply a by 2 (by adding it to itself).
}   Move that off to the auxiliary stack as well.

Ahora ingresamos al bucle principal del programa, utilizando un truco bastante estándar para recorrer una sola línea de código:

<...>

Tenga en cuenta que la pila estará vacía cada vez que toquemos, <por lo que sabemos que obtendremos ceros allí. La <gira entonces toda la línea izquierda, tomando la IP con ella, por lo que tenemos esto:

...><

La IP debe moverse hacia la izquierda, donde la >línea vuelve a su lugar original (para prepararla para la próxima iteración). Luego, la línea simplemente se ejecuta de derecha a izquierda, por lo que una iteración de bucle simple es esta:

{:{-!\,:)%;?}}

El problema al trabajar con un bucle de este tipo es que no puede trabajar con ninguna forma de ejecución condicional, ya que Labyrinth no tiene una forma de omitir código. Por lo tanto, terminaremos el programa con una división por cero cuando lleguemos a EOF. Aquí hay un desglose de cada iteración de bucle.

{:   Pull 2a back to the main stack and make a copy.
{    Pull the latest value i of the input list back to main as well.
-    Compute 2a-i/
!\   Print it with a trailing linefeed.
,    Read a character. If there are input elements left, this will be some
     form of separator character, and therefore a positive value x. However,
     at the end of the program, this will give -1.
:)   Make an incremented copy.
%    Try to to compute x%(x+1). This will error out at EOF.
;    Discard the result of the division.
?    Read the next input value.
}}   Move that and the remaining copy of 2a back to the auxiliary stack.

C ++ 14, 36 bytes

Como lambda sin nombre modificando su entrada:

[](auto&c){for(auto&x:c)x=2*c[0]-x;}

Usando la técnica de Dennis. Funciona para cualquier contenedor comoint[] o vector<int>.

Uso:

#include<iostream>

auto f=
[](auto&c){for(auto&x:c)x=2*c[0]-x;}
;

int main(){
  int a[] = {1,  3,  4,  2,  8};
  f(a);
  for(auto&x:a)
    std::cout << x << ", ";
  std::cout<<"\n";
}

CJam, 16 bytes

Formato de entrada: [1 2 3 4]. Utiliza la fórmula fácil.

l~_(2*/;a/,@@*.-

Explicación:

l~_(2*/;a/,@@*.-
l~_                     e#Read input twice into an array. Stack: [1 2 3 4] [1 2 3 4]
   (                    e#Get first element of the array. Stack: [1 2 3 4] [2 3 4] 1
    2*                  e#Multiply by two. Stack: [1 2 3 4] [2 3 4] 2
      /;                e#Discard second element. Stack: [1 2 3 4] 2
        a               e#Wrap into an array. Stack: [1 2 3 4] [2]
         /,             e#Rotate and get length. Stack: [2] [1 2 3 4] 4
           @@           e#Rotate twice. Stack: [1 2 3 4] 4 [2]
            *           e#Repeat len times. Stack: [1 2 3 4] [2 2 2 2]
             .-         e#Vectorized substraction. Stack: [-1 0 1 2]
                        e#Implictly print

Perdón por el enlace de prueba. Supongo que a SE no le gustan los enlaces con corchetes dentro.

Pushy , 9 bytes

{&}2*K~-_

Dar argumentos como valores separados por comas en la línea cmd: $ pushy invdeltas.pshy 1,3,4,2,8. Aquí está el desglose, con ejemplo de pila:

           % Implicit: Input on stack              [1, 3, 4, 2, 8]
{&}        % Copy first item, put at end of stack  [1, 3, 4, 2, 8, 1]
   2*      % Multiply by 2                         [1, 3, 4, 2, 8, 2]
     K~    % Negate everything on stack            [-1, -3, -4, -2, -8, -2]
       -   % Subtract last item from all           [1, -1, -2, 0, -6]
        _  % Print whole stack

Nota: esto puede ser de 8 bytes si se permite la salida hacia atrás: @&2*K~-_

Perl, 26 + 3 ( -plabandera) = 29 bytes

$_="@{[map$F[0]*2-$_,@F]}"

o

$_=join$",map$F[0]*2-$_,@F

Utilizando:

perl -plae '$_="@{[map$F[0]*2-$_,@F]}"' <<< "32 18 25 192 199"

Dyalog APL , 5 bytes

-+2×⊃

este es un tren de 5, se analiza como dos trenes de 3 trenes anidados ("horquillas"): -+(2×⊃)

se lee como: la negación ( -) de toda la matriz más ( +) dos veces ( 2×) el primer elemento ( ⊃)

ised, 11 bytes

2*$1_0-$1

Invocación: ised --l 'file with input.txt' '2*$1_0-$1

(editar: corregido robando el álgebra de Dennis)

Maravilla , 17 bytes

@->#@- *2:0#1#0#0

No estoy seguro de por qué no publiqué esto antes. Uso:

(@->#@- *2:0#1#0#0)[5 6 7 8]

Más legible:

@(map @
  - (
    * 2 get 0 #1
  ) #0
) #0