Delta inversi di una matrice

Il tuo compito è, dato un array di numeri interi a 32 bit con segno, ricompilarlo con i suoi delta inversi. Ad esempio, l'elenco

1  3  4  2  8

contiene i delta:

  2  1 -2  6

che vengono quindi negati, producendo:

 -2 -1  2 -6

e ricompilato, producendo:

1 -1 -2  0 -6

come risultato finale.

Input Output

Ti verrà dato un elenco / array / table / tuple / stack / etc. di numeri interi con segno come input tramite qualsiasi metodo di input standard.

È necessario inviare nuovamente i dati modificati in qualsiasi forma accettabile, seguendo il metodo di inversione delta sopra riportato.

Riceverai N input in 0 < N < 10cui ogni numero rientra nell'intervallo-1000 < X < 1000

Casi test

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

Appunti

• Non sei limitato al metodo basato su delta: se riesci a trovare il metodo più semplice (che non dovrebbe essere troppo difficile) , sei libero di usarlo.
• Come indicato sopra, riceverai sempre almeno 1 input e non più di 9.
• Il primo numero dell'output deve essere sempre il primo numero dell'input, in caso contrario, il metodo non è corretto.
• È accettata solo l'uscita di ingresso standard
• Si applicano scappatoie standard
• Questo è code-golf , quindi vince il conteggio di byte più basso!
• Divertiti!

Abbiamo un vincitore.

Dennis 's Jelly Answer at a Tiny 3 Bytes ha portato a casa l'oro, a causa del fatto che ho l'impressione che non possa essere battuto.

Sono stato leggermente deluso dal fatto che non sono riuscito a vedere una risposta basata sulle specifiche originali, tuttavia, potrei in seguito dare una taglia proprio a questo.

Gelatina , 7 3 byte

ḤḢ_

Provalo online!

sfondo

I delta di (a, b, c, d) sono b - a , c - b e d - c . Riducendo cumulativamente (a, b - a, c - b, d - c) mediante sottrazione g si ottiene a - (b - a) = 2a - b , 2a - b - (c - b) = 2a - c , e 2a - c - (d - c) = 2a - d , quindi il risultato corretto è (2a - a, 2a - b, 2a - c, 2a - d) .

Come funziona

ḤḢ_  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 byte

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

Provalo su Ideone .

Come funziona

I delta di (a, b, c, d) sono b - a , c - b e d - c . Riducendo cumulativamente (a, b - a, c - b, d - c) mediante sottrazione g si ottiene a - (b - a) = 2a - b , 2a - b - (c - b) = 2a - c , e 2a - c - (d - c) = 2a - d , quindi il risultato corretto è (2a - a, 2a - b, 2a - c, 2a - d) .

Mathematica, 8 byte

2#-{##}&

Funzione senza nome che accetta un numero indeterminato di argomenti. Questo utilizza un modo "semplice": annulla l'intero elenco e aggiunge due volte il primo elemento (originale).

Chiamato ad esempio come 2#-{##}&[1,3,4,2,8]; restituisce un elenco come {1,-1,-2,0,-6}.

JavaScript (ES6), 21

Grazie @Dennis

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

05AB1E , 4 byte

¬·s-

Provalo online! o come una suite di test

Spiegazione

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

Python, 44 byte

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

Questo utilizza il "metodo più semplice".

Pyth, 5 byte

-LyhQ

Interprete online!

R, 23 18 17 byte

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

auto-vettorializzazione e stampa predefinita in soccorso!

Rubino, 23 byte

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

Non particolarmente originale.

Perl 6 ,  40  16 byte

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

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

Allargato:

{ # 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 byte

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

Provalo online!

Spiegazione:

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 byte

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

Stessa soluzione di Dennis, grazie per la tua idea di 2a - x.

Salvato un byte grazie a Christian Severs.

Pyke, 5 4 byte

h}m-

Provalo qui!

PHP, 48 byte

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

Usando la tecnica di Dennis. Usa come:

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

Versione non Dennis 55 byte:

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

APL, 8 byte

+\⊃,2-/+

Spiegazione:

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

Casi test:

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

Labyrinth , 34 byte

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

Provalo online!

Usa l' approccio di @Dennis(2a - a, 2a - b, 2a - c, 2a - d) .

Le tessere gialle servono per il controllo del flusso. In questo linguaggio di programmazione 2D, il programma inizia dalla tessera in alto a sinistra che si sposta verso est per iniziare. Alle giunzioni, la direzione è determinata dal segno della parte superiore della pila principale. Le piastrelle vuote sono pareti.

verde

Questa sezione salva 2a nello stack ausiliario.

• ? Ottieni il primo numero e spingilo in cima allo stack principale
• : Duplica la parte superiore della pila
• _2 Spingi due in cima alla pila
• *Pop y, pop x, pushx*y
• } Spostare la parte superiore della pila principale nella parte superiore della pila ausiliaria.
• _ Spingere zero in cima alla pila

arancia

Questa sezione sottrae 2a dal numero corrente, annulla il risultato, emette il risultato, ottiene il carattere successivo (il delimitatore), esce se EOF, emette una nuova riga, ottiene il numero successivo.

• "Noop. Se proveniente da nord, la parte superiore dello stack sarà zero e il programma continuerà a sud. Se venendo da ovest, la parte superiore dello stack sarà una e il programma girerà a destra (proseguendo verso sud)
• ;Scarta la parte superiore della pila. Poiché lo zero o uno viene utilizzato solo per il flusso di controllo, è necessario eliminarli
• { Spostare la parte superiore della pila ausiliaria (2a) nella parte superiore della pila principale
• : Duplica la parte superiore dello stack principale
• } Spostare la parte superiore della pila principale nella parte superiore della pila ausiliaria
• -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`
• ! Pop in cima allo stack e output come un numero
• , Spingi il personaggio successivo (che sarà il delimitatore) o negativo se EOF
• )Incrementa la parte superiore della pila. Se l'ultimo carattere è EOF, la parte superiore dello stack ora sarà zero e il programma continuerà dritto fino @all'uscita. Se l'ultimo carattere era un delimitatore, la parte superiore dello stack sarà positiva facendo girare il programma a destra e continuando verso est fino al\
• \ Invia una nuova riga
• ? Ottieni il prossimo numero
• _1 Spingine uno in cima alla pila per girare a destra all'incrocio

Labyrinth , 24 byte

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

Il formato di input e output è un elenco separato da avanzamenti di riga (sebbene il formato di input sia in realtà molto più flessibile). Il programma termina con un errore.

Provalo online!

Ho altre due soluzioni con questo numero di byte, che funzionano sostanzialmente allo stesso modo ma usano un flusso di controllo leggermente diverso.

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

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

Spiegazione

Il puntatore dell'istruzione (IP) inizia a spostarsi verso est lungo la prima riga, ma tutti i comandi precedenti ?sono sostanzialmente no-op sullo stato globale, poiché non stiamo usando comandi di profondità dello stack da nessuna parte. Quindi il codice inizia davvero ?verso ovest, poiché l'IP si gira quando raggiunge il vicolo cieco.

Il codice quindi inizia con il seguente bit lineare di codice:

?:}:+}

Questo semplicemente ci configura con una copia di 2autilizzare la [2a - a, 2a - b, 2a - c, ...]formula.

?   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.

Entriamo ora nel ciclo principale del programma, usando un trucco abbastanza standard per scorrere una singola riga di codice:

<...>

Nota che lo stack sarà vuoto ogni volta che lo colpiamo, <quindi sappiamo che otterremo degli zeri lì. L' <allora ruota l'intera linea a sinistra, prendendo la IP con essa, in modo da ottenere questo:

...><

L'IP deve quindi spostarsi a sinistra, dove >sposta la linea nella sua posizione originale (per prepararla alla prossima iterazione). Quindi la linea viene semplicemente eseguita da destra a sinistra, quindi un'iterazione a ciclo singolo è questa:

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

Il problema quando si lavora con un ciclo di questo tipo è che non è possibile lavorare con qualsiasi forma di esecuzione condizionale, poiché Labyrinth non ha un modo per saltare il codice. Pertanto, termineremo il programma con una divisione per zero quando colpiamo EOF. Ecco una ripartizione di ogni iterazione di 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 byte

Come lambda senza nome che modifica il suo input:

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

Usando la tecnica di Dennis. Funziona con qualsiasi contenitore come int[]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 byte

Formato di input: [1 2 3 4]. Usa la formula semplice.

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

Spiegazione:

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

Ci scusiamo per nessun link di prova. Immagino che a SE non piacciano i collegamenti con parentesi all'interno.

Pushy , 9 byte

{&}2*K~-_

Dare argomenti come valori separati da virgole on line cmd: $ pushy invdeltas.pshy 1,3,4,2,8. Ecco la ripartizione, con stack di esempio:

           % 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: questo può essere di 8 byte se è consentito l'output all'indietro: @&2*K~-_

Perl, 26 + 3 ( -plaflag) = 29 byte

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

o

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

usando:

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

Dyalog APL , 5 byte

-+2×⊃

questo è un treno 5, analizza come due treni nidificati 3 ("forchette"): -+(2×⊃)

legge come: la negazione ( -) dell'intero array più ( +) due volte ( 2×) il primo elemento ( ⊃)

ised, 11 byte

2*$1_0-$1

Invocazione: ised --l 'file with input.txt' '2*$1_0-$1

(modifica: corretto rubando l'algebra da Dennis)

Meraviglia , 17 byte

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

Non sono sicuro del perché non l'ho pubblicato prima. Uso:

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

Più leggibile:

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