Delta Terbalik dari Array

Tugas Anda adalah, diberi array integer 32 bit yang ditandatangani, kompilasi ulang dengan delta kebalikannya. Misalnya, daftarnya

1  3  4  2  8

memegang delta:

  2  1 -2  6

yang kemudian dinegasikan, menghasilkan:

 -2 -1  2 -6

dan dikompilasi ulang, menghasilkan:

1 -1 -2  0 -6

sebagai hasil akhir.

Input output

Anda akan diberikan daftar / array / tabel / tuple / stack / dll. bilangan bulat yang ditandatangani sebagai input melalui metode input standar apa pun.

Anda harus mengeluarkan data yang dimodifikasi sekali lagi dalam bentuk apa pun yang dapat diterima, mengikuti metode inversi delta di atas.

Anda akan menerima input N di 0 < N < 10mana setiap angka berada dalam kisaran-1000 < X < 1000

Uji Kasus

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

Catatan

• Anda tidak terbatas pada metode berbasis delta: jika Anda dapat menemukan metode yang lebih mudah (yang seharusnya tidak terlalu sulit) , Anda bebas untuk menggunakannya.
• Seperti yang dinyatakan di atas, Anda akan selalu menerima setidaknya 1 input, dan tidak lebih dari 9.
• Angka pertama dari output harus selalu menjadi angka pertama dari input, jika ini tidak terjadi, metode Anda salah.
• Hanya Output Input Standar yang diterima
• Celah standar berlaku
• Ini adalah kode-golf , jadi byte-count terendah menang!
• Selamat bersenang-senang!

Kami punya pemenang.

Dennis 's Jelly Answer di Tiny 3 Bytes telah membawa pulang emas, karena fakta bahwa saya di bawah kesan itu tidak dapat dikalahkan.

Saya agak kecewa saya tidak bisa melihat jawaban berdasarkan spesifikasi asli, namun, saya kemudian dapat memberi hadiah pada hal itu.

Jelly , 7 3 byte

ḤḢ_

Cobalah online!

Latar Belakang

Delta (a, b, c, d) adalah b - a , c - b , dan d - c . Secara kumulatif mengurangi (a, b - a, c - b, d - c) dengan mengurangi hasil a - (b - a) = 2a - b , 2a - b - (c - b) = 2a - c , dan 2a - c - (d - c) = 2a - d , jadi hasil yang benar adalah (2a - a, 2a - b, 2a - c, 2a - d) .

Bagaimana itu bekerja

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

Cobalah Ideone .

Bagaimana itu bekerja

Delta (a, b, c, d) adalah b - a , c - b , dan d - c . Secara kumulatif mengurangi (a, b - a, c - b, d - c) dengan mengurangi hasil a - (b - a) = 2a - b , 2a - b - (c - b) = 2a - c , dan 2a - c - (d - c) = 2a - d , jadi hasil yang benar adalah (2a - a, 2a - b, 2a - c, 2a - d) .

Mathematica, 8 byte

2#-{##}&

Fungsi tanpa nama mengambil jumlah argumen yang tidak ditentukan. Ini menggunakan cara "mudah": meniadakan seluruh daftar dan menambahkan dua kali elemen pertama (asli).

Dipanggil misalnya suka 2#-{##}&[1,3,4,2,8]; mengembalikan daftar like {1,-1,-2,0,-6}.

JavaScript (ES6), 21

Thx @Dennis

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

05AB1E , 4 byte

¬·s-

Cobalah online! atau sebagai Test suite

Penjelasan

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

Ini menggunakan "Metode yang lebih mudah".

Pyth, 5 byte

-LyhQ

Penerjemah Online!

R, 23 18 17 byte

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

auto-vectorisation dan cetak default untuk penyelamatan!

Ruby, 23 byte

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

Tidak terlalu orisinal.

Perl 6 ,  40  16 byte

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

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

Diperluas:

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

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

Cobalah secara Online!

Penjelasan:

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

Solusi yang sama seperti Dennis, terima kasih atas ide Anda 2a - x .

Disimpan satu byte berkat Christian Severs.

Pyke, 5 4 byte

h}m-

Coba di sini!

PHP, 48 byte

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

Menggunakan teknik dari Dennis. Gunakan seperti:

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

Versi non-Dennis 55 byte:

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

APL, 8 byte

+\⊃,2-/+

Penjelasan:

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

Kasus uji:

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

Labirin , 34 byte

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

Cobalah online!

Menggunakan @Dennis 's (2a - a, 2a - b, 2a - c, 2a - d)pendekatan.

Ubin kuning untuk aliran kontrol. Dalam bahasa pemrograman 2D ini, program dimulai pada ubin paling kiri atas yang bergerak ke timur untuk memulai. Di persimpangan, arah ditentukan oleh tanda bagian atas tumpukan utama. Ubin kosong adalah dinding.

hijau

Bagian ini menyimpan 2a ke tumpukan pembantu.

• ? Dapatkan nomor pertama dan dorong ke atas tumpukan utama
• : Gandakan bagian atas tumpukan
• _2 Dorong dua ke atas tumpukan
• *Pop y, pop x, pushx*y
• } Pindahkan bagian atas tumpukan utama ke bagian atas tumpukan tambahan.
• _ Tekan nol ke atas tumpukan

jeruk

Bagian ini mengurangi 2a dari angka saat ini, meniadakan hasil, menampilkan hasilnya, mendapatkan karakter berikutnya (delimeter), keluar jika EOF, mengeluarkan baris baru, mendapatkan nomor berikutnya.

• "Noop. Jika datang dari utara, bagian atas tumpukan akan menjadi nol dan program akan berlanjut ke selatan. Jika datang dari barat, bagian atas tumpukan akan menjadi satu dan program akan berbelok ke kanan (melanjutkan ke selatan)
• ;Buang bagian atas tumpukan. Karena nol atau satu hanya digunakan untuk aliran kontrol, kita perlu membuangnya
• { Pindahkan bagian atas tumpukan pembantu (2a) ke bagian atas tumpukan utama
• : Gandakan bagian atas tumpukan utama
• } Pindahkan bagian atas tumpukan utama ke bagian atas tumpukan tambahan
• -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 bagian atas tumpukan dan output sebagai angka
• , Tekan karakter berikutnya (yang akan menjadi pembatas) atau negatif jika EOF
• )Tambahkan bagian atas tumpukan. Jika karakter terakhir adalah EOF, maka bagian atas tumpukan sekarang akan menjadi nol dan program akan terus lurus ke @dan keluar. Jika karakter terakhir adalah delimeter, maka bagian atas tumpukan akan positif menyebabkan program berbelok ke kanan dan terus ke timur ke\
• \ Keluarkan baris baru
• ? Dapatkan nomor selanjutnya
• _1 Dorong satu ke atas tumpukan untuk berbelok ke kanan di persimpangan

Labirin , 24 byte

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

Format input dan output adalah daftar yang terpisah baris (meskipun format input sebenarnya jauh lebih fleksibel). Program berakhir dengan kesalahan.

Cobalah online!

Saya punya dua solusi lain pada hitungan byte ini, yang bekerja pada dasarnya sama tetapi menggunakan aliran kontrol yang agak berbeda.

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

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

Penjelasan

Instruksi penunjuk (IP) mulai bergerak ke timur di sepanjang baris pertama, tetapi semua perintah sebelum pada ?dasarnya tidak ada-ops di negara global, karena kita tidak menggunakan perintah stack depth di mana saja. Jadi kodenya benar - benar dimulai dari? barat, karena IP berbalik ketika menyentuh jalan buntu.

Karenanya kode tersebut dimulai dengan sedikit kode linear berikut:

?:}:+}

Ini cukup membuat kami dengan salinan 2auntuk menggunakan [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.

Kita sekarang memasuki loop utama program, menggunakan trik yang cukup standar untuk mengulang melalui satu baris kode:

<...>

Perhatikan bahwa tumpukan akan kosong setiap kali kita menekan tombol < sehingga kita tahu kita akan mendapatkan nol di sana. The <kemudian berputar seluruh baris kiri, mengambil IP dengan itu, jadi kami mendapatkan ini:

...><

IP kemudian harus bergerak ke kiri, di mana > menggeser garis kembali ke tempat asalnya (untuk mempersiapkannya untuk iterasi berikutnya). Kemudian garis dieksekusi dari kanan ke kiri, sehingga iterasi loop tunggal adalah ini:

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

Tangkapan ketika bekerja dengan loop dari jenis ini adalah bahwa Anda tidak dapat bekerja dengan segala bentuk eksekusi bersyarat, karena Labyrinth tidak memiliki cara untuk melewati kode. Karenanya, kami akan menghentikan program dengan pembagian nol ketika kami menekan EOF. Berikut ini adalah rincian dari setiap iterasi 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

Sebagai lambda tanpa nama yang memodifikasi inputnya:

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

Menggunakan teknik dari Dennis. Bekerja untuk wadah seperti int[]atauvector<int> .

Pemakaian:

#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

Format input: [1 2 3 4]. Menggunakan formula yang mudah.

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

Penjelasan:

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

Maaf tidak ada tautan tes. Saya kira SE tidak suka tautannya dengan tanda kurung di dalamnya.

Pushy , 9 byte

{&}2*K~-_

Berikan argumen sebagai comma-dipisahkan pada baris cmd: $ pushy invdeltas.pshy 1,3,4,2,8. Inilah rinciannya, dengan contoh tumpukan:

           % 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

Catatan: ini bisa 8 byte jika output mundur dibolehkan: @&2*K~-_

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

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

atau

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

Menggunakan:

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

Dyalog APL , 5 byte

-+2×⊃

ini adalah 5-kereta, itu diurai seperti dua kereta 3 bersarang ("garpu"): -+(2×⊃)

berbunyi seperti: negasi ( -) dari seluruh array plus ( +) dua kali ( 2×) elemen pertama ( ⊃)

ised, 11 byte

2*$1_0-$1

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

(sunting: dikoreksi dengan mencuri aljabar dari Dennis)

Bertanya-tanya , 17 byte

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

Tidak yakin mengapa saya tidak memposting ini sebelumnya. Pemakaian:

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

Lebih mudah dibaca:

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