Đảo ngược Deltas của một mảng

Tiếp tục nghịch đảo Deltas của một mảng

Nhiệm vụ của bạn là lấy 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 được đảo ngược.

Thí dụ

Danh sách,

18  19  17  20  16

có đồng bằng:

   1  -2   3  -4

mà, khi đảo ngược, mang lại:

  -4   3  -2   1

sau đó khi biên dịch lại, sử dụng sản lượng:

18  14  17  15  16

mà nên là giá trị trở lại của bạn.

Biên dịch lại bao gồm lấy C, là giá trị đầu tiên của mảng. Trong trường hợp này 18, và áp dụng đồng bằng cho nó theo thứ tự. Vì vậy, 18 + -4cho 14, 14 + 3cho 17, và như vậy.

Đầ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 chấp nhận được 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

1 2 3 4 5      -> 1 2 3 4 5
18 19 17 20 16 -> 18 14 17 15 16
5 9 1 3 8 7 8  -> 5 6 5 10 12 4 8
6 5 4 1 2 3    -> 6 7 8 5 4 3

Ghi chú

• 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 và cuối cùng của đầu ra của bạn, sẽ luôn khớp với số đầu vào.
• 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ẻ!

Và người chiến thắng là...

Dennis! Ai là người đầu tiên chiếm vị trí thứ nhất, sau đó tự đánh bại mình bằng một giải pháp ngắn hơn, cho mình cả vị trí thứ nhất và thứ hai!

Nói một cách trân trọng đến ais523 với Jelly của họ, rằng nếu không nhờ Dennis vào ngay trước họ, sẽ giữ vị trí thứ hai.

Thạch , 5 byte

.ịS_Ṛ

Này sử dụng các thuật toán từ Julia câu trả lời Glen O của .

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

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

.ịS_Ṛ  Main link. Argument: A (array)

.ị     At-index 0.5; retrieve the values at the nearest indices (0 and 1). Since
       indexing is 1-based and modular, this gives the last and first element.
  S    Compute their sum.
    Ṛ  Yield A, reversed.
   _   Subtract the result to the right from the result to the left.

Thạch , 6 byte

I;ḢṚ+\

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

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

I;ḢṚ+\  Main link. Argument: A (array)

I       Increments; compute the deltas of A.
  Ḣ     Head; yield the first element of A.
 ;      Concatenate the results to both sides.
   Ṛ    Reverse the resulting array.
    +\  Compute the cumulative sum of the reversed array.

Julia, 24 byte

!x=x[end]+x[]-reverse(x)

Đây là cách "thông minh" để giải quyết vấn đề. Mặt trái của mảng có "deltas" bị đảo ngược, và sau đó bạn chỉ cần sửa thực tế là nó bắt đầu / kết thúc ở những vị trí sai.

Người tuyết 1.0.2, 72 byte

((}#0AaGwR#`wRaCaZ`0NdE`aN0AaG:dU,0aA|1aA,nS;aM`0wRaC|#0aA*|:#nA*#;aM*))

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

Đây là một chương trình con nhận đầu vào từ và đầu ra cho permavar hiện tại.

((
  }       enable variables b, e, and g
  #       store the input in variable b
  0AaG    remove the first element (take indices > 0)
  wR      wrap the array in another array
  #`wRaC  concatenate with the original input array
  aZ      zip (transpose); we now have pairs of elements
  `0NdE   obtain the number -1 (by decrementing 0)
  `aN     reverse the zipped array
  0AaG    remove first (there is one fewer delta than array elements)
  :       map over the array of pairs:
    dU     duplicate; we now have b=[x,y] e=[x,y]
    ,0aA   move the copy and get the first element; b=x g=[x,y]
    |1aA   get the second element from the copy; b=y g=x
    ,nS    subtract; we now have b=y-x which is returned from the map
  ;aM     (map)
  `0wRaC  prepend a zero (in preparation for the next step)
  |#0aA   get the first element of the original array
  *       store this in the permavar
  |:      map over the array of deltas with 0 prepended:
    #       store the permavar in e
    nA      add the delta and the permavar
    *#      make this the new value of the permavar
  ;aM     (map)
  *       "return" the resulting array from the subroutine
))

JavaScript (ES6), 45 37 byte

a=>a.reverse(z=a[0]).map(e=>z+a[0]-e)

Cổng câu trả lời Mathicala của @ JHM. (Tôi chắc chắn rằng tôi có thể tự lấy được nó, nhưng không phải vào thời điểm này trong đêm.) Chỉnh sửa: Đã lưu 8 byte nhờ @ edc65.

Toán học, 23 byte

#&@@#+Last@#-Reverse@#&

Hàm không tên. Kết quả chỉ đơn giản là: đảo ngược ((phần tử đầu tiên) + (phần tử cuối cùng) - (mỗi phần tử)).

Python 2, 96 74 54 44 byte

lambda l:[l[0]+l[-1]-j for j in l][::-1]

Đầu vào được đưa ra dưới dạng một mảng được bao quanh bởi dấu ngoặc vuông. Đầu ra có cùng định dạng.

Cảm ơn @Kade đã lưu 22 42 byte bằng cách sử dụng một phương pháp đơn giản hơn nhiều so với bất kỳ điều gì tôi đang làm trước đây!

Cảm ơn @ Sherlock9 vì đã tiết kiệm 10 byte bằng cách loại bỏ bộ đếm chỉ mục khỏi mức hiểu danh sách!

Tuyệt vời, bây giờ nếu tôi chơi golf nữa, tôi sẽ gặp vấn đề "gạch bỏ 44 vẫn là 44". ; _;

05AB1E , 8 byte

¬s¤sR(++

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

Dịch câu trả lời MATL của tôi, cách tiếp cận thứ hai.

¬    % Implicit input. Head, without consuming the input
s    % Swap
¤    % Tail, without consuming the input
s    % Swap
R(   % Reverse and negate
++   % Add head and tail of input to reversed and negated input. Implicitly display

R, 37 30 byte

Chỉnh sửa: Bây giờ sử dụng cách tiếp cận trong câu trả lời Julia của Glen O

x=scan();x[1]+tail(x,1)-rev(x)

Cũ:

x=scan();cumsum(c(x[1],rev(diff(x))))

Đọc đầu vào, tính toán deltas, nối với phần tử đầu tiên và tính tổng tích lũy.

MATL , 8 byte

1)GdPhYs

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

Đây là ứng dụng trực tiếp của định nghĩa. Hãy xem xét đầu vào [18 19 17 20 16]là một ví dụ.

1)     % Implicit input. Get its first entry
       % STACK: 18
G      % Push input again
       % STACK: 18, [18 19 17 20 16]
d      % Consecutive differences
       % STACK: 18, [1 -2 3 -4]
P      % Reverse
       % STACK: 18, [-4 3 -2 1]
h      % Concatenate
       % STACK: [18 -4 3 -2 1]
Ys     % Cumulative sum. Implicitly display
       % STACK: [18 14 17 15 16]

Cách tiếp cận khác nhau, cùng một số byte:

P_G5L)s+

Hãy thử nó!

Mảng đảo ngược và phủ định cộng với các mục đầu tiên và cuối cùng của mảng ban đầu.

P_     % Implicit inut. Reverse and negate
G      % Push input again
5L)s   % Sum of first and last entries
+      % Add to reversed and negated array. Implicitly display

Japt, 8 byte

Ô®nUÌ+Ug

Chạy nó trực tuyến

Pyth - 10 byte

sM._+hQ_.+

Phòng thử nghiệm .

(Aheui) , 3 * 21 ký tự + 2 "\ n" = 65 byte

빪쑥쌳텆슉폎귁삯씬희
뿓팤팧쎢싺솎
싺싹삭당뽔

Giả sử đầu vào trong ngăn xếp 아. Đầu ra sẽ được lưu trữ trong ngăn xếp.

Nếu bạn muốn thử mã này:

Ở cuối dòng đầu tiên của mã này, hãy thêm 벙độ dài ký tự (n) -times (tức là nếu đầu vào là 7 số nguyên, hãy chèn nó 7 lần). Đối với mỗi dấu nhắc, nhập một số nguyên:

어우
우어
빪쑥쌳텆슉폎귁삯씬희
뿓팤팧쎢싺솎
싺싹삭당뽔

Hãy thử nó ở đây! (sao chép và dán mã)

Thí dụ

Dành cho 1, 2, 3, 4, 5:

어우벙벙벙벙벙
우어
빪쑥쌳텆슉폎귁삯씬희
뿓팤팧쎢싺솎
싺싹삭당뽔

và sau đó gõ 1, 2, 3, 4, và 5(sẽ có 5 nhắc nhở).

Phiên bản thay thế (65 byte)

빠쑥쌳터슉펴ㅇ삯씬희
뿌파파쎢싺솎
싺싹삭다뽀

C # 42 byte

Mất một int[]và trả lại một IEnumerable<int>.

a=>a.Select(v=>a[0]+a.Last()-v).Reverse();

(Đây thực sự chỉ là một phiên bản được chuyển của phiên bản JHM ..)

TSQL, 200 byte

Biến bảng được sử dụng làm đầu vào

DECLARE @ table(a int, b int identity)

INSERT @ values(5),(9),(1),(3),(8),(7),(8);

WITH c as(SELECT*,rank()over(order by b desc)z FROM @)SELECT g+isnull(sum(-f)over(order
by b),0)FROM(SELECT sum(iif(c.b=1,c.a,0))over()g,d.a-lead(d.a)over(order by d.b)f,c.b
FROM c,c d WHERE c.b=d.z)d

Dùng thử

PHP, 60 56 52 byte

-4 byte nhờ @ user59178

for($a=$argv;--$argc;)echo$a[1]+end($a)-$a[$argc],_;

hoạt động trên các đối số dòng lệnh, sử dụng dấu gạch dưới làm dấu phân cách. Chạy với
php -r '<code>' <space separated numbers>

Perl 6 ,  48 33  30 byte

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

{.reverse.map: {.[0]+.[*-1]-$^a}}

{[R,] .map: {.[0]+.[*-1]-$^a}}

Thử nó

Mở rộng:

{  # bare block lambda with implicit parameter ｢$_｣

  [R,]               # reduce the following using the comma operator [R]eversed
                     # (short way to do the same thing as ｢reverse｣)

    .map:            # map the input (implicit method call on ｢$_｣

      {              # bare block lambda with placeholder parameter ｢$a｣

          .[     0 ] # the first value of ｢$_｣ (implicit “method” call)
        + .[ * - 1 ] # add the last value of ｢$_｣ (implicit “method” call)
        -     $^a    # declare the parameter and subtract it from the above
      }
}

Đây *-1cũng là một biểu thức lambda của kiểu AnyCode, trong đó *là tham số vị trí duy nhất.

Julia 0,4 , 32 byte

!x=[x[];x|>diff|>flipud]|>cumsum

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

BASH, 71 byte

s=$1
echo $s
for i in `seq ${#@} -1 2`;{
echo $[s=s+${!i}-${@:i-1:1}]
}

C ++ 14, 103 byte

Như lambda giấu tên, đòi hỏi đầu vào của nó có rbegin, rend, backvà push_backnhư container vector, dequehoặc list.

Sử dụng cách tiếp cận từ Glen O's câu trả lời Julia

[](auto c){decltype(c)d;for(auto i=c.rbegin()-1;++i!=c.rend();)d.push_back(c[0]+c.back()-*i);return d;}

Ungolfed và cách sử dụng:

#include<iostream>
#include<vector>

//declare generic function, return is deduced automatically
auto f=[](auto c){
  //create fresh container of the same type as input
  decltype(c)d;

  //iterate through the reverse container
  for(auto i=c.rbegin()-1;++i!=c.rend();)
    //add the first and last element minus the negative reverse
    d.push_back(c[0]+c.back()-*i);
  return d;
}
;


int main(){
  std::vector<int> a={18,  19,  17,  20,  16};
  auto b = f(a);
  for(auto&x:b)
    std::cout << x << ", ";
  std::cout<<"\n";
}

Haskell, 33 byte

Sử dụng logic tương tự như JHM:

f a=map(head a+last a-)$reverse a

Khá dễ đọc là tốt.

Lồi , 10 byte

_î\(@¥+¡p;

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

Clojure, 101 byte

(fn[c](conj(map #(-(first c)%)(reductions +(reverse(map #(apply - %)(partition 2 1 c)))))(first c))))

Khá nhiều theo mô tả:

(def f (fn[c]
         (conj
           (->> c
                (partition 2 1)
                (map #(apply - %))
                reverse
                (reductions +)
                (map #(-(first c)%)))
           (first c))))

Java 7, 96 byte

int[]c(int[]a){int l=a.length,i=1,r[]=a.clone();for(;i<l;r[i]=r[i-1]+a[l-i]-a[l-++i]);return r;}

Giải trình:

int[] c(int[] a){     // Method with integer-array parameter and integer-array return-type
  int l=a.length,     //  Length of input array
      i=1,            //  Index (starting at 1, although Java is 0-indexed)
      r[]=a.clone();  //  Copy of input array
  for(; i<l;          //  Loop over the array
    r[i] =            //   Replace the value at the current index in the copied array with:
      r[i-1]          //    The previous value in this copied array
      + a[l - i]      //    plus the opposite value in the input array
      - a[l - ++i])   //    minus the value before the opposite value in the input array (and increase the index)
  ;                   //  End the loop (implicit / no body)
  return r;           //  Return the result array
}                     // End of method

Mã kiểm tra:

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

class M{
  static int[]c(int[]a){int l=a.length,i=1,r[]=a.clone();for(;i<l;r[i]=r[i-1]+a[l-i]-a[l-++i]);return r;}

  public static void main(String[] a){
    System.out.println(java.util.Arrays.toString(c(new int[]{ 18,19,17,20,16 })));
    System.out.println(java.util.Arrays.toString(c(new int[]{ 1,2,3,4,5 })));
    System.out.println(java.util.Arrays.toString(c(new int[]{ 5,9,1,3,8,7,8 })));
    System.out.println(java.util.Arrays.toString(c(new int[]{ 6,5,4,1,2,3 })));
  }
}

Đầu ra:

[18, 14, 17, 15, 16]
[1, 2, 3, 4, 5]
[5, 6, 5, 10, 12, 4, 8]
[6, 7, 8, 5, 4, 3]

APL (Dyalog Unicode) , 11 byte ^SBCS

Chức năng tiền tố ẩn danh.

+\⊃,∘⌽2-⍨/⊢

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

+\ tổng tích lũy của

⊃ yếu tố đầu tiên của đối số

, tiếp
∘ bởi
⌽  sự đảo ngược của

2-⍨/ sự khác biệt theo cặp

⊢ tranh luận