Deltas inverses d'un tableau

Votre tâche consiste à, étant donné un tableau d'entiers 32 bits signés, le recompiler avec ses deltas inverses. Par exemple, la liste

1  3  4  2  8

détient les deltas:

  2  1 -2  6

qui sont ensuite annulés, donnant:

 -2 -1  2 -6

et recompilé, donnant:

1 -1 -2  0 -6

comme résultat final.

Entrée sortie

Vous recevrez une liste / tableau / table / tuple / pile / etc. des entiers signés en entrée via toute méthode d'entrée standard.

Vous devez à nouveau générer les données modifiées sous toute forme acceptable, en suivant la méthode d'inversion delta ci-dessus.

Vous recevrez N entrées 0 < N < 10où chaque numéro se situe dans la plage-1000 < X < 1000

Cas de 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

Remarques

• Vous n'êtes pas limité à la méthode basée sur le delta: si vous pouvez trouver la méthode la plus simple (qui ne devrait pas être trop difficile) , vous êtes libre de l'utiliser.
• Comme indiqué ci-dessus, vous recevrez toujours au moins 1 entrée et pas plus de 9.
• Le premier numéro de la sortie doit toujours être le premier numéro de l'entrée, si ce n'est pas le cas, votre méthode est incorrecte.
• Seule la sortie d'entrée standard est acceptée
• Des échappatoires standard s'appliquent
• C'est le golf de code , donc le nombre d'octets le plus bas gagne!
• S'amuser!

Nous avons un gagnant.

Dennis 's Jelly Answer at a Tiny 3 Bytes a remporté la médaille d'or, car j'ai l'impression qu'elle ne peut pas être battue.

J'ai été légèrement déçu de ne pas avoir pu voir une réponse basée sur les spécifications d'origine, cependant, je pourrais plus tard mettre une prime dessus.

Gelée , 7 3 octets

ḤḢ_

Essayez-le en ligne!

Contexte

Les deltas de (a, b, c, d) sont b - a , c - b et d - c . La réduction cumulative (a, b - a, c - b, d - c) par soustractiong donne a - (b - a) = 2a - b , 2a - b - (c - b) = 2a - c et 2a - c - (d - c) = 2a - d , donc le résultat correct est (2a - a, 2a - b, 2a - c, 2a - d) .

Comment ça fonctionne

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

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

Testez-le sur Ideone .

Comment ça fonctionne

Les deltas de (a, b, c, d) sont b - a , c - b et d - c . La réduction cumulative (a, b - a, c - b, d - c) par soustractiong donne a - (b - a) = 2a - b , 2a - b - (c - b) = 2a - c et 2a - c - (d - c) = 2a - d , donc le résultat correct est (2a - a, 2a - b, 2a - c, 2a - d) .

Mathematica, 8 octets

2#-{##}&

Fonction sans nom prenant un nombre indéterminé d'arguments. Cela utilise une méthode "simple": annule la liste entière et ajoute deux fois le premier élément (d'origine).

Appelé par exemple comme 2#-{##}&[1,3,4,2,8]; renvoie une liste comme {1,-1,-2,0,-6}.

JavaScript (ES6), 21

Thx @Dennis

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

05AB1E , 4 octets

¬·s-

Essayez-le en ligne! ou comme suite de tests

Explication

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

Python, 44 octets

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

Cela utilise la "méthode plus simple".

Pyth, 5 octets

-LyhQ

Interprète en ligne!

R, 23 18 17 octets

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

auto-vectorisation et impression par défaut à la rescousse!

Rubis, 23 octets

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

Pas particulièrement original.

Perl 6 ,  40  16 octets

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

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

Étendu:

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

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

Essayez-le en ligne!

Explication:

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 octets

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

Même solution que Dennis, merci pour ton idée 2a - x.

Enregistrement d'un octet grâce à Christian Severs.

Pyke, 5 4 octets

h}m-

Essayez-le ici!

PHP, 48 octets

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

En utilisant la technique de Dennis. Utilisez comme:

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

Version non Dennis 55 octets:

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

APL, 8 octets

+\⊃,2-/+

Explication:

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

Cas de 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│
└───────┴────────────┴──────────────────┘

Labyrinthe , 34 octets

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

Essayez-le en ligne!

Utilise l' approche de @Dennis(2a - a, 2a - b, 2a - c, 2a - d) .

Les tuiles jaunes sont pour le contrôle du flux. Dans ce langage de programmation 2D, le programme démarre à la tuile la plus en haut à gauche se déplaçant vers l'est pour commencer. Aux intersections, la direction est déterminée par le signe du haut de la pile principale. Les carreaux vierges sont des murs.

vert

Cette section enregistre 2a dans la pile auxiliaire.

• ? Obtenez le premier numéro et poussez-le en haut de la pile principale
• : Dupliquez le haut de la pile
• _2 Poussez deux vers le haut de la pile
• *Pop y, pop x, pushx*y
• } Déplacez le haut de la pile principale vers le haut de la pile auxiliaire.
• _ Poussez zéro vers le haut de la pile

Orange

Cette section soustrait 2a du nombre actuel, annule le résultat, sort le résultat, obtient le caractère suivant (le délimiteur), quitte si EOF, sort une nouvelle ligne, obtient le numéro suivant.

• "Noop. Si vous venez du nord, le sommet de la pile sera nul et le programme continuera au sud. Si vous venez de l'ouest, le sommet de la pile sera un et le programme tournera à droite (en continuant vers le sud)
• ;Jetez le haut de la pile. Étant donné que le zéro ou l'un est uniquement utilisé pour le flux de contrôle, nous devons les éliminer
• { Déplacez le haut de la pile auxiliaire (2a) vers le haut de la pile principale
• : Dupliquez le haut de la pile principale
• } Déplacez le haut de la pile principale vers le haut de la pile auxiliaire
• -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 »
• ! Affichez le haut de la pile et affichez-le sous forme de nombre
• , Appuyez sur le caractère suivant (qui sera le délimiteur) ou négatif si EOF
• )Incrémentez le haut de la pile. Si le dernier caractère est EOF, alors le haut de la pile sera maintenant nul et le programme continuera directement vers le @et quittez. Si le dernier caractère était un délimiteur, alors le haut de la pile sera positif, ce qui fera que le programme tournera à droite et continuera vers l'est jusqu'à\
• \ Sortie d'une nouvelle ligne
• ? Obtenez le prochain numéro
• _1 Poussez l'un vers le haut de la pile afin de tourner à droite à la jonction

Labyrinthe , 24 octets

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

Les formats d'entrée et de sortie sont des listes séparées par des sauts de ligne (bien que le format d'entrée soit en réalité beaucoup plus flexible). Le programme se termine avec une erreur.

Essayez-le en ligne!

J'ai deux autres solutions à ce nombre d'octets, qui fonctionnent essentiellement de la même manière mais utilisent un flux de contrôle quelque peu différent.

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

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

Explication

Le pointeur d'instruction (IP) commence à se déplacer vers l'est le long de la première ligne, mais toutes les commandes avant le ?sont fondamentalement sans opération sur l'état global, car nous n'utilisons aucune commande de profondeur de pile nulle part. Donc, le code commence vraiment à l' ?ouest, car l'IP se retourne lorsqu'il atteint l'impasse.

Le code commence donc par le bit de code linéaire suivant:

?:}:+}

Cela nous configure simplement avec une copie de 2apour utiliser la [2a - a, 2a - b, 2a - c, ...]formule.

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

Nous entrons maintenant dans la boucle principale du programme, en utilisant une astuce assez standard pour parcourir une seule ligne de code:

<...>

Notez que la pile sera vide à chaque fois que nous toucherons, <donc nous savons que nous y aurons des zéros. Le fait <ensuite pivoter toute la ligne vers la gauche, en prenant l'IP avec lui, nous obtenons donc ceci:

...><

L'IP doit ensuite se déplacer vers la gauche, où le >ramène la ligne à sa place d'origine (pour la préparer pour la prochaine itération). Ensuite, la ligne est simplement exécutée de droite à gauche, donc une seule itération de boucle est la suivante:

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

Le hic lorsque vous travaillez avec une boucle de ce type est que vous ne pouvez pas travailler avec n'importe quelle forme d'exécution conditionnelle, car Labyrinth n'a pas de moyen d'ignorer le code. Par conséquent, nous terminerons le programme avec une division par zéro lorsque nous atteindrons EOF. Voici une ventilation de chaque itération de boucle.

{:   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 octets

Comme lambda sans nom modifiant son entrée:

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

En utilisant la technique de Dennis. Fonctionne pour n'importe quel conteneur comme int[]ou vector<int>.

Usage:

#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 octets

Format d' entrée: [1 2 3 4]. Utilise la formule facile.

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

Explication:

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

Désolé pour aucun lien de test. Je suppose que SE n'aime pas ses liens avec des crochets à l'intérieur.

Arrogant , 9 octets

{&}2*K~-_

Donnez des arguments sous forme de valeurs séparées par des virgules sur la ligne cmd: $ pushy invdeltas.pshy 1,3,4,2,8 . Voici la répartition, avec un exemple de pile:

           % 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

Remarque: cela peut être de 8 octets si la sortie en arrière est autorisée: @&2*K~-_

Perl, 26 + 3 ( -plaindicateur) = 29 octets

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

ou

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

En utilisant:

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

Dyalog APL , 5 octets

-+2×⊃

c'est un 5 trains, il analyse comme deux 3 trains imbriqués ("fourches"): -+(2×⊃)

se lit comme: la négation ( -) de l'ensemble du tableau plus ( +) deux fois ( 2×) le premier élément ( ⊃)

isé, 11 octets

2*$1_0-$1

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

(modifier: corrigé en volant l'algèbre de Dennis)

Wonder , 17 octets

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

Je ne sais pas pourquoi je n'ai pas posté ça plus tôt. Usage:

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

Plus lisible:

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