Deltas inversos de una matriz

Una continuación de los deltas inversos de una matriz

Su tarea es tomar una matriz de enteros de 32 bits con signo, recompilarlo con sus deltas invertidos.

Ejemplo

La lista,

18  19  17  20  16

tiene los deltas:

   1  -2   3  -4

que, cuando se invierte, produce:

  -4   3  -2   1

luego, cuando se vuelve a compilar, usando rendimientos:

18  14  17  15  16

cuál debería ser su valor de retorno.

La recompilación consiste en tomar el C, que es el primer valor de la matriz. En este caso, 18y aplicando los deltas en orden. Entonces 18 + -4da 14, 14 + 3da 17, y así sucesivamente.

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

1 2 3 4 5      -> 1 2 3 4 5
18 19 17 20 16 -> 18 14 17 15 16
5 9 1 3 8 7 8  -> 5 6 5 10 12 4 8
6 5 4 1 2 3    -> 6 7 8 5 4 3

Notas

• Como se indicó anteriormente, siempre recibirá al menos 1 entrada y no más de 9.
• El primer y último número de su salida siempre coincidirá con el de la entrada.
• 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!

Y el ganador es...

Dennis! Quien primero tomó el primer lugar, luego se golpeó con una solución más corta, ¡dándose el primer y el segundo lugar!

Mención honorífica a ais523 con su Jelly, que si no fuera por Dennis entrando justo antes que ellos, habría ocupado el segundo lugar.

Jalea , 5 bytes

.ịS_Ṛ

Este utiliza el algoritmo de respuesta de Julia Glen O .

Pruébalo en línea!

Cómo funciona

.ịS_Ṛ  Main link. Argument: A (array)

.ị     At-index 0.5; retrieve the values at the nearest indices (0 and 1). Since
       indexing is 1-based and modular, this gives the last and first element.
  S    Compute their sum.
    Ṛ  Yield A, reversed.
   _   Subtract the result to the right from the result to the left.

Jalea , 6 bytes

I;ḢṚ+\

Pruébalo en línea!

Cómo funciona

I;ḢṚ+\  Main link. Argument: A (array)

I       Increments; compute the deltas of A.
  Ḣ     Head; yield the first element of A.
 ;      Concatenate the results to both sides.
   Ṛ    Reverse the resulting array.
    +\  Compute the cumulative sum of the reversed array.

Julia, 24 bytes

!x=x[end]+x[]-reverse(x)

Esta es la forma "inteligente" de resolver el problema. El reverso negativo de la matriz tiene los "deltas" invertidos, y luego solo necesita corregir el hecho de que comienza / termina en los lugares equivocados.

Muñeco de nieve 1.0.2, 72 bytes

((}#0AaGwR#`wRaCaZ`0NdE`aN0AaG:dU,0aA|1aA,nS;aM`0wRaC|#0aA*|:#nA*#;aM*))

Pruébalo en línea!

Esta es una subrutina que toma entradas y salidas del permavar actual.

((
  }       enable variables b, e, and g
  #       store the input in variable b
  0AaG    remove the first element (take indices > 0)
  wR      wrap the array in another array
  #`wRaC  concatenate with the original input array
  aZ      zip (transpose); we now have pairs of elements
  `0NdE   obtain the number -1 (by decrementing 0)
  `aN     reverse the zipped array
  0AaG    remove first (there is one fewer delta than array elements)
  :       map over the array of pairs:
    dU     duplicate; we now have b=[x,y] e=[x,y]
    ,0aA   move the copy and get the first element; b=x g=[x,y]
    |1aA   get the second element from the copy; b=y g=x
    ,nS    subtract; we now have b=y-x which is returned from the map
  ;aM     (map)
  `0wRaC  prepend a zero (in preparation for the next step)
  |#0aA   get the first element of the original array
  *       store this in the permavar
  |:      map over the array of deltas with 0 prepended:
    #       store the permavar in e
    nA      add the delta and the permavar
    *#      make this the new value of the permavar
  ;aM     (map)
  *       "return" the resulting array from the subroutine
))

JavaScript (ES6), 45 37 bytes

a=>a.reverse(z=a[0]).map(e=>z+a[0]-e)

Puerto de la respuesta de Mathematica de @ JHM. (Estoy seguro de que podría haberlo derivado yo mismo, pero no a esta hora de la noche). Editar: Guardado 8 bytes gracias a @ edc65.

Mathematica, 23 bytes

#&@@#+Last@#-Reverse@#&

Función sin nombre El resultado es simplemente: inverso ((primer elemento) + (último elemento) - (cada elemento)).

Python 2, 96 74 54 44 bytes

lambda l:[l[0]+l[-1]-j for j in l][::-1]

La entrada se da como una matriz rodeada de corchetes. La salida está en el mismo formato.

¡Gracias a @Kade por guardar 22 42 bytes usando un método mucho más simple que lo que estaba haciendo antes!

¡Gracias a @ Sherlock9 por guardar 10 bytes al eliminar el contador de índice de la comprensión de la lista!

Genial, ahora si sigo jugando golf me saldrá el problema "tachado 44 sigue siendo 44". ; _;

05AB1E , 8 bytes

¬s¤sR(++

Pruébalo en línea!

Traducción de mi respuesta MATL, segundo enfoque.

¬    % Implicit input. Head, without consuming the input
s    % Swap
¤    % Tail, without consuming the input
s    % Swap
R(   % Reverse and negate
++   % Add head and tail of input to reversed and negated input. Implicitly display

R, 37 30 bytes

Editar: ahora usando el enfoque en la respuesta de Julia de Glen O

x=scan();x[1]+tail(x,1)-rev(x)

Antiguo:

x=scan();cumsum(c(x[1],rev(diff(x))))

Lee entradas, calcula deltas, concatena con el primer elemento y calcula la suma acumulativa.

MATL , 8 bytes

1)GdPhYs

Pruébalo en línea!

Esta es la aplicación directa de la definición. Considere la entrada [18 19 17 20 16]como un ejemplo.

1)     % Implicit input. Get its first entry
       % STACK: 18
G      % Push input again
       % STACK: 18, [18 19 17 20 16]
d      % Consecutive differences
       % STACK: 18, [1 -2 3 -4]
P      % Reverse
       % STACK: 18, [-4 3 -2 1]
h      % Concatenate
       % STACK: [18 -4 3 -2 1]
Ys     % Cumulative sum. Implicitly display
       % STACK: [18 14 17 15 16]

Enfoque diferente, mismo conteo de bytes:

P_G5L)s+

Pruébalo onllne!

Matriz invertida y negada más la primera y última entrada de la matriz original.

P_     % Implicit inut. Reverse and negate
G      % Push input again
5L)s   % Sum of first and last entries
+      % Add to reversed and negated array. Implicitly display

Japt, 8 bytes

Ô®nUÌ+Ug

Ejecútalo en línea

Pyth - 10 bytes

sM._+hQ_.+

Test Suite .

아희 (Aheui) , 3 * 21 caracteres + 2 "\ n" = 65 bytes

빪쑥쌳텆슉폎귁삯씬희
뿓팤팧쎢싺솎
싺싹삭당뽔

Asume la entrada en la pila 아. La salida se almacenará en la pila 안.

Si quieres probar este código:

Al final de la primera línea de este código, agregue la 벙longitud del carácter (n) veces (es decir, si la entrada es 7 enteros, insértelo 7 veces). Para cada solicitud, escriba un número entero:

어우
우어
빪쑥쌳텆슉폎귁삯씬희
뿓팤팧쎢싺솎
싺싹삭당뽔

Pruébalo aquí! (copia y pega el código)

Ejemplo

Para 1, 2, 3, 4, 5:

어우벙벙벙벙벙
우어
빪쑥쌳텆슉폎귁삯씬희
뿓팤팧쎢싺솎
싺싹삭당뽔

y escriba 1, 2, 3, 4, y 5(habrá 5 indicaciones).

Versión alternativa (65 bytes)

빠쑥쌳터슉펴ㅇ삯씬희
뿌파파쎢싺솎
싺싹삭다뽀

C # 42 bytes

Toma un int[]y devuelve un IEnumerable<int>.

a=>a.Select(v=>a[0]+a.Last()-v).Reverse();

(En realidad, esta es solo una versión portada de la versión de JHM ...)

TSQL, 200 bytes

Variable de tabla utilizada como entrada

DECLARE @ table(a int, b int identity)

INSERT @ values(5),(9),(1),(3),(8),(7),(8);

WITH c as(SELECT*,rank()over(order by b desc)z FROM @)SELECT g+isnull(sum(-f)over(order
by b),0)FROM(SELECT sum(iif(c.b=1,c.a,0))over()g,d.a-lead(d.a)over(order by d.b)f,c.b
FROM c,c d WHERE c.b=d.z)d

Pruébalo

PHP, 60 56 52 bytes

-4 bytes gracias a @ user59178

for($a=$argv;--$argc;)echo$a[1]+end($a)-$a[$argc],_;

opera en argumentos de línea de comando, usa guión bajo como separador. Corre con
php -r '<code>' <space separated numbers>

Perl 6 ,  48 33  30 bytes

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

{.reverse.map: {.[0]+.[*-1]-$^a}}

{[R,] .map: {.[0]+.[*-1]-$^a}}

Intentalo

Expandido:

{  # bare block lambda with implicit parameter ｢$_｣

  [R,]               # reduce the following using the comma operator [R]eversed
                     # (short way to do the same thing as ｢reverse｣)

    .map:            # map the input (implicit method call on ｢$_｣

      {              # bare block lambda with placeholder parameter ｢$a｣

          .[     0 ] # the first value of ｢$_｣ (implicit “method” call)
        + .[ * - 1 ] # add the last value of ｢$_｣ (implicit “method” call)
        -     $^a    # declare the parameter and subtract it from the above
      }
}

También *-1es una expresión lambda de tipo WhateverCode, donde *es el único parámetro posicional.

Julia 0.4 , 32 bytes

!x=[x[];x|>diff|>flipud]|>cumsum

Pruébalo en línea!

BASH, 71 bytes

s=$1
echo $s
for i in `seq ${#@} -1 2`;{
echo $[s=s+${!i}-${@:i-1:1}]
}

C ++ 14, 103 bytes

Como lambda sin nombre, lo que requiere su entrada para tener rbegin, rend, backy push_backal igual que los contenedores vector, dequeo list.

Usando el enfoque de la respuesta de Julia de Glen O

[](auto c){decltype(c)d;for(auto i=c.rbegin()-1;++i!=c.rend();)d.push_back(c[0]+c.back()-*i);return d;}

Sin golf y uso:

#include<iostream>
#include<vector>

//declare generic function, return is deduced automatically
auto f=[](auto c){
  //create fresh container of the same type as input
  decltype(c)d;

  //iterate through the reverse container
  for(auto i=c.rbegin()-1;++i!=c.rend();)
    //add the first and last element minus the negative reverse
    d.push_back(c[0]+c.back()-*i);
  return d;
}
;


int main(){
  std::vector<int> a={18,  19,  17,  20,  16};
  auto b = f(a);
  for(auto&x:b)
    std::cout << x << ", ";
  std::cout<<"\n";
}

Haskell, 33 bytes

Utiliza la misma lógica que JHM:

f a=map(head a+last a-)$reverse a

Muy legible también.

Convexo , 10 bytes

_î\(@¥+¡p;

Pruébalo en línea!

Clojure, 101 bytes

(fn[c](conj(map #(-(first c)%)(reductions +(reverse(map #(apply - %)(partition 2 1 c)))))(first c))))

Más o menos sigue la descripción:

(def f (fn[c]
         (conj
           (->> c
                (partition 2 1)
                (map #(apply - %))
                reverse
                (reductions +)
                (map #(-(first c)%)))
           (first c))))

Java 7, 96 bytes

int[]c(int[]a){int l=a.length,i=1,r[]=a.clone();for(;i<l;r[i]=r[i-1]+a[l-i]-a[l-++i]);return r;}

Explicación:

int[] c(int[] a){     // Method with integer-array parameter and integer-array return-type
  int l=a.length,     //  Length of input array
      i=1,            //  Index (starting at 1, although Java is 0-indexed)
      r[]=a.clone();  //  Copy of input array
  for(; i<l;          //  Loop over the array
    r[i] =            //   Replace the value at the current index in the copied array with:
      r[i-1]          //    The previous value in this copied array
      + a[l - i]      //    plus the opposite value in the input array
      - a[l - ++i])   //    minus the value before the opposite value in the input array (and increase the index)
  ;                   //  End the loop (implicit / no body)
  return r;           //  Return the result array
}                     // End of method

Código de prueba:

Pruébalo aquí

class M{
  static int[]c(int[]a){int l=a.length,i=1,r[]=a.clone();for(;i<l;r[i]=r[i-1]+a[l-i]-a[l-++i]);return r;}

  public static void main(String[] a){
    System.out.println(java.util.Arrays.toString(c(new int[]{ 18,19,17,20,16 })));
    System.out.println(java.util.Arrays.toString(c(new int[]{ 1,2,3,4,5 })));
    System.out.println(java.util.Arrays.toString(c(new int[]{ 5,9,1,3,8,7,8 })));
    System.out.println(java.util.Arrays.toString(c(new int[]{ 6,5,4,1,2,3 })));
  }
}

Salida:

[18, 14, 17, 15, 16]
[1, 2, 3, 4, 5]
[5, 6, 5, 10, 12, 4, 8]
[6, 7, 8, 5, 4, 3]

APL (Dyalog Unicode) , ^{SBCS de} 11 bytes

Función de prefijo tácito anónimo.

+\⊃,∘⌽2-⍨/⊢

Pruébalo en línea!

+\ suma acumulativa de

⊃ el primer elemento del argumento

, seguido
∘ por
⌽ la reversión de

2-⍨/ la diferencia por pares de

⊢ el argumento