Deltas inversos de uma matriz

Sua tarefa é, dada uma matriz de números inteiros de 32 bits assinados, recompilar com seus deltas inversos. Por exemplo, a lista

1  3  4  2  8

mantém os deltas:

  2  1 -2  6

que são então negados, produzindo:

 -2 -1  2 -6

e recompilado, produzindo:

1 -1 -2  0 -6

como o resultado final.

Entrada / Saída

Você receberá uma lista / matriz / tabela / tupla / pilha / etc. de números inteiros assinados como entrada por qualquer método de entrada padrão.

Você deve imprimir os dados modificados novamente, de qualquer forma aceitável, seguindo o método de inversão delta acima.

Você receberá N entradas 0 < N < 10onde cada número se enquadra dentro da faixa-1000 < X < 1000

Casos de teste

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

• Você não está restrito ao método baseado em delta: se você puder descobrir o método mais fácil (que não deve ser muito difícil) , estará livre para usá-lo.
• Conforme mencionado acima, você sempre receberá pelo menos 1 entrada e não mais que 9.
• O primeiro número da saída deve sempre ser o primeiro número da entrada; se esse não for o caso, seu método está incorreto.
• Somente saída de entrada padrão é aceita
• Aplicam-se brechas padrão
• Isso é código-golfe , então a menor contagem de bytes vence!
• Diverta-se!

Temos um vencedor.

A resposta da geléia de Dennis em um minúsculo 3 bytes levou para casa o ouro, devido ao fato de que tenho a impressão de que não pode ser derrotado.

Fiquei levemente decepcionado por não ter conseguido ver uma resposta com base nas especificações originais; no entanto, mais tarde posso dar uma recompensa precisamente por isso.

Geléia , 7 3 bytes

ḤḢ_

Experimente online!

fundo

Os deltas de (a, b, c, d) são b - a , c - b e d - c . A redução cumulativa (a, b - a, c - b, d - c) pela subtraçãog produz a - (b - a) = 2a - b , 2a - b - (c - b) = 2a - c , e 2a - c - (d - c) = 2a - d , então o resultado correto é (2a - a, 2a - b, 2a - c, 2a - d) .

Como 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]

Teste em Ideone .

Como funciona

Os deltas de (a, b, c, d) são b - a , c - b e d - c . A redução cumulativa (a, b - a, c - b, d - c) pela subtraçãog produz a - (b - a) = 2a - b , 2a - b - (c - b) = 2a - c , e 2a - c - (d - c) = 2a - d , então o resultado correto é (2a - a, 2a - b, 2a - c, 2a - d) .

Mathematica, 8 bytes

2#-{##}&

Função sem nome, levando um número indeterminado de argumentos. Isso usa uma maneira "fácil": nega toda a lista e adiciona o dobro do primeiro elemento (original).

Chamado, por exemplo, como 2#-{##}&[1,3,4,2,8]; retorna uma lista como {1,-1,-2,0,-6}.

JavaScript (ES6), 21

Thx @Dennis

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

05AB1E , 4 bytes

¬·s-

Experimente online! ou como um conjunto de testes

Explicação

¬     # 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:]]

Isso usa o "método mais fácil".

Pitão, 5 bytes

-LyhQ

Intérprete Online!

R, 23 18 17 bytes

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

auto-vetorização e impressão padrão para o resgate!

Ruby, 23 bytes

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

Não é 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

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

Experimente Online!

Explicação:

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

Mesma solução que Dennis, obrigado pela sua idéia 2a - x.

Guardou um byte graças a Christian Severs.

Pyke, 5 4 bytes

h}m-

Experimente aqui!

PHP, 48 bytes

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

Usando a técnica de Dennis. Use como:

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

Versão não de Dennis 55 bytes:

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

APL, 8 bytes

+\⊃,2-/+

Explicação:

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

Casos de teste:

      ( +\⊃,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│
└───────┴────────────┴──────────────────┘

Labirinto , 34 bytes

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

Experimente online!

Usa a abordagem do @Dennis(2a - a, 2a - b, 2a - c, 2a - d) .

Os ladrilhos amarelos são para controle de fluxo. Nesta linguagem de programação 2D, o programa inicia no canto superior esquerdo, movendo-se para o leste para iniciar. Nas junções, a direção é determinada pelo sinal do topo da pilha principal. Azulejos em branco são paredes.

Verde

Esta seção salva 2a na pilha auxiliar.

• ? Obtenha o primeiro número e empurre-o para o topo da pilha principal
• : Duplique a parte superior da pilha
• _2 Empurre dois para o topo da pilha
• *Estourar y, estourar x, empurrarx*y
• } Mova o topo da pilha principal para o topo da pilha auxiliar.
• _ Empurre zero para o topo da pilha

laranja

Esta seção subtrai 2a do número atual, nega o resultado, gera o resultado, obtém o próximo caractere (o delímetro), sai se EOF, gera uma nova linha, obtém o próximo número.

• "Noop. Se vier do norte, o topo da pilha será zero e o programa continuará para o sul. Se vier do oeste, o topo da pilha será um e o programa girará para a direita (continuando para o sul)
• ;Descarte a parte superior da pilha. Como o zero ou um é usado apenas para controle de fluxo, precisamos descartar esses
• { Mova o topo da pilha auxiliar (2a) para o topo da pilha principal
• : Duplique a parte superior da pilha principal
• } Mova a parte superior da pilha principal para a parte superior da pilha auxiliar
• -Estourar y, estourar x, empurrarx-y
• \`` Negate the top of the stack. This and the previous three operations have the effect of- (x-2a) = 2a-x`
• ! Coloque a parte superior da pilha e a produza como um número
• , Empurre o próximo caractere (que será o delimitador) ou negativo se EOF
• )Incremente o topo da pilha. Se o último caractere for EOF, a parte superior da pilha agora será zero e o programa continuará direto para a @saída. Se o último caractere for um delimitador, a parte superior da pilha será positiva, fazendo com que o programa vire à direita e continue para o leste até o\
• \ Saída de uma nova linha
• ? Obter o próximo número
• _1 Empurre um para o topo da pilha para virar à direita no cruzamento

Labirinto , 24 bytes

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

O formato de entrada e saída são listas separadas por alimentação de linha (embora o formato de entrada seja realmente muito mais flexível). O programa termina com um erro.

Experimente online!

Eu tenho duas outras soluções nessa contagem de bytes, que funcionam basicamente da mesma forma, mas usam um fluxo de controle um pouco diferente.

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

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

Explicação

O ponteiro de instrução (IP) começa a se mover para o leste ao longo da primeira linha, mas todos os comandos anteriores ?são basicamente não operacionais no estado global, já que não estamos usando comandos de profundidade da pilha em lugar algum. Então o código realmente começa no? oeste, já que o IP muda quando atinge o beco sem saída.

O código, portanto, começa com o seguinte bit linear de código:

?:}:+}

Isso simplesmente nos configura com uma cópia 2apara usar a [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.

Agora entramos no loop principal do programa, usando um truque bastante padrão para percorrer uma única linha de código:

<...>

Observe que a pilha estará vazia sempre que pressionarmos o <botão, então sabemos que obteremos zeros lá. Em <seguida, ele gira a linha inteira para a esquerda, levando o IP com ela, então obtemos o seguinte:

...><

O IP deve então se mover para a esquerda, onde a >linha muda de volta para o seu local original (para prepará-lo para a próxima iteração). Então a linha é simplesmente executada da direita para a esquerda, para uma iteração de loop único:

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

O problema ao trabalhar com um loop desse tipo é que você não pode trabalhar com nenhuma forma de execução condicional, pois o Labyrinth não tem como ignorar o código. Portanto, encerraremos o programa com uma divisão por zero quando atingirmos o EOF. Aqui está um detalhamento de cada iteração do loop.

{:   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 sem nome, modificando sua entrada:

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

Usando a técnica de Dennis. Funciona para qualquer contêiner como int[]ou 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]. Usa a fórmula fácil.

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

Explicação:

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

Desculpe por nenhum link de teste. Eu acho que o SE não gosta de links com colchetes dentro.

Pushy , 9 bytes

{&}2*K~-_

Dar argumentos como valores separados por vírgulas na linha cmd: $ pushy invdeltas.pshy 1,3,4,2,8. Aqui está o detalhamento, com a pilha de exemplo:

           % 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: isso pode ter 8 bytes se a saída reversa for permitida: @&2*K~-_

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

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

ou

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

Usando:

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

Dyalog APL , 5 bytes

-+2×⊃

este é um trem de cinco, analisa como dois trens aninhados ("garfos"): -+(2×⊃)

lê assim: a negação ( -) de toda a matriz mais ( +) duas vezes ( 2×) o primeiro elemento ( ⊃)

11 bytes

2*$1_0-$1

Invocação: ised --l 'file with input.txt' '2*$1_0-$1

(editar: corrigido roubando a álgebra de Dennis)

Maravilha , 17 bytes

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

Não sei por que não postei isso antes. Uso:

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

Mais legível:

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