Nghịch đảo Deltas của một mảng

Nhiệm vụ của bạn là, đưa ra một mảng các số nguyên 32 bit đã ký, biên dịch lại nó với các đồng bằng nghịch đảo của nó. Ví dụ, danh sách

1  3  4  2  8

giữ đồng bằng:

  2  1 -2  6

mà sau đó bị phủ nhận, mang lại:

 -2 -1  2 -6

và biên dịch lại, mang lại:

1 -1 -2  0 -6

là kết quả cuối cùng.

Đầu ra đầu vào

Bạn sẽ được cung cấp một danh sách / mảng / bảng / tuple / stack / vv. số nguyên đã ký làm đầu vào thông qua bất kỳ phương thức nhập chuẩn nào.

Bạn phải xuất dữ liệu đã sửa đổi một lần nữa dưới bất kỳ hình thức có thể chấp nhận nào, theo phương pháp đảo ngược delta ở trên.

Bạn sẽ nhận được N đầu vào trong 0 < N < 10đó mỗi số nằm trong phạm vi-1000 < X < 1000

Các trường hợp thử nghiệm

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

Ghi chú

• Bạn không bị hạn chế đối với phương pháp dựa trên delta: nếu bạn có thể tìm ra phương pháp dễ dàng hơn (không quá khó) , bạn có thể sử dụng nó một cách thoải mái.
• Như đã nêu ở trên, bạn sẽ luôn nhận được ít nhất 1 đầu vào và không quá 9.
• Số đầu tiên của đầu ra phải luôn là số đầu tiên của đầu vào, nếu không phải là trường hợp này, phương thức của bạn không chính xác.
• Chỉ đầu ra đầu vào tiêu chuẩn được chấp nhận
• Áp dụng sơ hở tiêu chuẩn
• Đây là môn đánh gôn , vì vậy số byte thấp nhất sẽ thắng!
• Chúc vui vẻ!

Chúng ta có một người chiến thắng.

Câu trả lời Jelly của Dennis tại Tiny 3 Byte đã mang về vàng, do thực tế là tôi đang bị ấn tượng rằng nó không thể bị đánh bại.

Tôi đã hơi thất vọng vì tôi đã không nhận được câu trả lời dựa trên thông số ban đầu, tuy nhiên, sau đó tôi có thể đưa tiền thưởng vào chính xác điều đó.

Thạch , 7 3 byte

ḤḢ_

Hãy thử trực tuyến!

Lý lịch

Đồng bằng của (a, b, c, d) là b - a , c - b và d - c . Giảm dần (a, b - a, c - b, d - c) bằng phép trừ thu được a - (b - a) = 2a - b , 2a - b - (c - b) = 2a - c và 2a - c - (d - c) = 2a - d , do đó, kết quả đúng là (2a - a, 2a - b, 2a - c, 2a - d) .

Làm thế nào nó hoạt động

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

Kiểm tra nó trên Ideone .

Làm thế nào nó hoạt động

Đồng bằng của (a, b, c, d) là b - a , c - b và d - c . Giảm dần (a, b - a, c - b, d - c) bằng phép trừ thu được a - (b - a) = 2a - b , 2a - b - (c - b) = 2a - c và 2a - c - (d - c) = 2a - d , do đó, kết quả đúng là (2a - a, 2a - b, 2a - c, 2a - d) .

Toán học, 8 byte

2#-{##}&

Hàm không tên lấy một số lượng đối số không xác định. Điều này sử dụng một cách "dễ dàng": phủ nhận toàn bộ danh sách và thêm hai lần yếu tố đầu tiên (ban đầu).

Gọi ví dụ như 2#-{##}&[1,3,4,2,8]; trả về một danh sách như thế {1,-1,-2,0,-6}.

JavaScript (ES6), 21

Thx @Dennis

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

05AB1E , 4 byte

¬·s-

Hãy thử trực tuyến! hoặc như một bộ thử nghiệm

Giải trình

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

Điều này sử dụng "Phương pháp dễ dàng hơn".

Bình thường, 5 byte

-LyhQ

Phiên dịch trực tuyến!

R, 23 18 17 byte

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

tự động véc tơ và in mặc định để giải cứu!

Ruby, 23 byte

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

Không đặc biệt nguyên bản.

Perl 6 ,  40  16 byte

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

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

Mở rộng:

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

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

Hãy thử trực tuyến!

Giải trình:

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

Giải pháp tương tự như Dennis, cảm ơn bạn đã biết 2a - x.

Đã lưu một byte nhờ Christian Severs.

Pyke, 5 4 byte

h}m-

Hãy thử nó ở đây!

PHP, 48 byte

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

Sử dụng kỹ thuật từ Dennis. Sử dụng như:

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

Phiên bản 55 byte không phải Dennis:

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

APL, 8 byte

+\⊃,2-/+

Giải trình:

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

Các trường hợp thử nghiệm:

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

Mê cung , 34 byte

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

Hãy thử trực tuyến!

Sử dụng phương pháp của @Dennis(2a - a, 2a - b, 2a - c, 2a - d) .

Các gạch màu vàng là cho dòng chảy kiểm soát. Trong ngôn ngữ lập trình 2D này, chương trình bắt đầu ở ô trên cùng bên trái di chuyển về phía đông để bắt đầu. Tại các điểm nối, hướng được xác định bởi dấu hiệu của đỉnh ngăn xếp chính. Gạch trống là bức tường.

màu xanh lá

Phần này tiết kiệm 2a cho ngăn xếp phụ trợ.

• ? Lấy số đầu tiên và đẩy nó lên trên cùng của ngăn xếp chính
• : Nhân đôi đỉnh của ngăn xếp
• _2 Đẩy hai lên đỉnh ngăn xếp
• *Pop y, pop x, đẩyx*y
• } Di chuyển đỉnh của ngăn xếp chính đến đỉnh của ngăn xếp phụ.
• _ Đẩy số 0 lên trên cùng của ngăn xếp

trái cam

Phần này trừ 2a từ số hiện tại, phủ định kết quả, đưa ra kết quả, lấy ký tự tiếp theo (dấu phân cách), thoát nếu EOF, xuất ra một dòng mới, lấy số tiếp theo.

• "Không ra đâu. Nếu đến từ phía bắc, đỉnh của ngăn xếp sẽ bằng không và chương trình sẽ tiếp tục về phía nam. Nếu đến từ phía tây, đỉnh của ngăn xếp sẽ là một và chương trình sẽ rẽ phải (tiếp tục về phía nam)
• ;Hủy bỏ đỉnh của ngăn xếp. Vì số 0 hoặc số chỉ được sử dụng cho luồng điều khiển, chúng ta cần loại bỏ chúng
• { Di chuyển đỉnh của ngăn xếp phụ (2a) lên đỉnh của ngăn xếp chính
• : Nhân đôi đỉnh ngăn xếp chính
• } Di chuyển đỉnh của ngăn xếp chính đến đỉnh của ngăn xếp phụ
• -Pop y, pop x, đẩyx-y
• \`` Negate the top of the stack. This and the previous three operations have the effect of- (x-2a) = 2a-x`
• ! Bật đầu ngăn xếp và xuất ra dưới dạng số
• , Đẩy ký tự tiếp theo (sẽ là ký tự phân cách) hoặc ký tự phủ định nếu EOF
• )Tăng đỉnh của ngăn xếp. Nếu ký tự cuối cùng là EOF, thì đỉnh của ngăn xếp bây giờ sẽ bằng 0 và chương trình sẽ tiếp tục đi thẳng đến @và thoát. Nếu ký tự cuối cùng là một vạch, thì đỉnh của ngăn xếp sẽ dương khiến chương trình rẽ phải và tiếp tục đi về hướng đông đến\
• \ Xuất một dòng mới
• ? Lấy số tiếp theo
• _1 Đẩy một cái lên trên cùng của ngăn xếp để rẽ phải ở ngã ba

Mê cung , 24 byte

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

Định dạng đầu vào và đầu ra là các danh sách riêng biệt cho nguồn cấp dữ liệu (mặc dù định dạng đầu vào thực sự linh hoạt hơn rất nhiều). Chương trình kết thúc với một lỗi.

Hãy thử trực tuyến!

Tôi đã có hai giải pháp khác với số byte này, về cơ bản hoạt động giống nhau nhưng sử dụng luồng điều khiển hơi khác nhau.

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

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

Giải trình

Con trỏ lệnh (IP) bắt đầu di chuyển về phía đông dọc theo dòng đầu tiên, nhưng tất cả các lệnh trước ?đó về cơ bản là không có trạng thái trên trạng thái toàn cầu, vì chúng ta không sử dụng các lệnh độ sâu ngăn xếp ở bất cứ đâu. Vì vậy, mã thực sự bắt đầu tại? phía tây, vì IP quay lại khi nó đi vào ngõ cụt.

Do đó, mã bắt đầu với bit mã tuyến tính sau:

?:}:+}

Điều này chỉ đơn giản là thiết lập cho chúng tôi một bản sao 2ađể sử dụng [2a - a, 2a - b, 2a - c, ...]công thức.

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

Bây giờ chúng ta nhập vào vòng lặp chính của chương trình, sử dụng một mẹo khá chuẩn để lặp qua một dòng mã:

<...>

Lưu ý rằng ngăn xếp sẽ trống bất cứ khi nào chúng tôi đạt được <vì vậy chúng tôi biết rằng chúng tôi sẽ nhận được số không ở đó. Sau <đó xoay toàn bộ dòng bên trái, lấy IP với nó, vì vậy chúng tôi nhận được điều này:

...><

IP sau đó phải di chuyển sang trái, nơi >chuyển dòng trở lại vị trí ban đầu (để chuẩn bị cho lần lặp tiếp theo). Sau đó, dòng được thực hiện đơn giản từ phải sang trái, do đó, một vòng lặp duy nhất là thế này:

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

Điều hấp dẫn khi làm việc với một vòng lặp kiểu này là bạn không thể làm việc với bất kỳ hình thức thực thi có điều kiện nào, vì Labyrinth không có cách nào để bỏ qua mã. Do đó, chúng tôi sẽ chấm dứt chương trình với số chia cho 0 khi chúng tôi đạt EOF. Đây là một sự cố của mỗi vòng lặp.

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

Như lambda chưa đặt tên sửa đổi đầu vào của nó:

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

Sử dụng kỹ thuật từ Dennis. Hoạt động cho bất kỳ container như int[]hoặcvector<int> .

Sử dụng:

#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

Định dạng đầu vào : [1 2 3 4]. Sử dụng công thức dễ dàng.

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

Giải trình:

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

Xin lỗi vì không có liên kết kiểm tra. Tôi đoán SE không thích nó liên kết với dấu ngoặc bên trong.

Pushy , 9 byte

{&}2*K~-_

Đưa ra các đối số dưới dạng các giá trị được phân tách bằng dấu phẩy trên dòng cmd : $ pushy invdeltas.pshy 1,3,4,2,8. Đây là sự cố, với ví dụ ngăn xếp:

           % 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

Lưu ý: đây có thể là 8 byte nếu cho phép đầu ra ngược: @&2*K~-_

Perl, 26 + 3 ( -placờ) = 29 byte

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

hoặc là

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

Sử dụng:

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

APL Dyalog , 5 byte

-+2×⊃

đây là 5 tàu, nó phân tích cú pháp như hai tàu 3 lồng ("dĩa"): -+(2×⊃)

đọc như: phủ định ( -) của toàn bộ mảng cộng ( +) hai lần ( 2×) phần tử đầu tiên ( ⊃)

11 byte

2*$1_0-$1

Cầu nguyện: ised --l 'file with input.txt' '2*$1_0-$1

(chỉnh sửa: sửa chữa bằng cách đánh cắp đại số từ Dennis)

Kỳ quan , 17 byte

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

Không chắc chắn tại sao tôi không đăng bài này sớm hơn. Sử dụng:

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

Dễ đọc hơn:

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