배열의 역 델타

배열 의 역 델타 연속

당신의 임무는 부호있는 32 비트 정수의 배열을 취하고 델타를 뒤집어 다시 컴파일하는 것입니다.

예

목록,

18  19  17  20  16

델타가 있습니다.

   1  -2   3  -4

반대로하면 다음과 같은 결과가 나타납니다.

  -4   3  -2   1

그런 다음 수율을 사용하여 다시 컴파일 할 때 :

18  14  17  15  16

반환 값이어야합니다.

재 컴파일은 C배열의 첫 번째 값인 을 가져 오는 것으로 구성됩니다 . 이 경우 18델타를 순서대로 적용합니다. 그래서 18 + -4제공 14, 14 + 3제공 17및에 있도록.

입출력

리스트 / 배열 / 테이블 / 튜플 / 스택 / 등이 제공됩니다. 표준 입력 방법을 통해 입력 된 부호있는 정수

위의 델타 반전 방법에 따라 수정 된 데이터를 허용 가능한 형식으로 다시 출력해야합니다.

0 < N < 10각 숫자가 범위 내에있는 N 개의 입력을받습니다.-1000 < X < 1000

테스트 사례

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

노트

• 위에서 언급했듯이 항상 최소 1 개의 입력을 받고 9를 넘지 않아야합니다.
• 출력의 첫 번째와 마지막 숫자는 항상 입력의 숫자와 일치합니다.
• 표준 입력 출력 만 허용
• 표준 허점 적용
• 이것은 code-golf 이므로 가장 낮은 바이트 수가 이깁니다!
• 즐기세요!

그리고 승자는...

데니스! 누가 먼저 1 위를 차지했는지, 더 짧은 솔루션으로 자신을 이겼으며, 1 위와 2 위를 모두 제공했습니다!

그들의 젤리와 함께 ais523 에 대한 존경스러운 언급은 , Dennis가 그들 바로 앞에 들어 가지 않는다면 2 위 를 차지했 을 것입니다.

젤리 , 5 바이트

.ịS_Ṛ

이것은 Glen O의 Julia answer 알고리즘을 사용합니다 .

온라인으로 사용해보십시오!

작동 원리

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

젤리 , 6 바이트

I;ḢṚ+\

온라인으로 사용해보십시오!

작동 원리

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.

줄리아, 24 바이트

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

이것이 문제를 해결하는 "영리한"방법입니다. 배열의 음수 반전은 "델타"가 반전 된 후 잘못된 위치에서 시작 / 종료된다는 사실을 수정하면됩니다.

눈사람 1.0.2, 72 바이트

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

온라인으로 사용해보십시오!

이것은 현재 영구 입력을 입력 및 출력하는 서브 루틴입니다.

((
  }       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
))

자바 스크립트 (ES6), 45 37 바이트

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

@JHM의 Mathematica 답변 포트. (내가 직접 파생 할 수는 있지만 이번 밤에는 그렇지 않다고 확신한다.) 편집 : @ edc65 덕분에 8 바이트가 절약되었다.

매스 매 티카, 23 바이트

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

명명되지 않은 기능. 결과는 간단하다 : reverse ((first element) + (last element)-(each element)).

파이썬 2, 96 74 54 44 바이트

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

입력은 대괄호로 묶인 배열로 제공됩니다. 출력 형식이 동일합니다.

내가 전에했던 것보다 훨씬 더 간단한 방법을 사용하여 22 42 바이트 를 절약 한 @Kade에게 감사드립니다 !

목록 이해에서 인덱스 카운터를 제거하여 10 바이트를 절약 한 @ Sherlock9에게 감사드립니다!

이제 더 이상 골프를 타면 "44를 넘어 44"라는 문제가 발생합니다. ; _;

05AB1E , 8 바이트

¬s¤sR(++

온라인으로 사용해보십시오!

내 MATL 답변의 번역, 두 번째 접근법.

¬    % 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 바이트

편집 : 이제 Glen O의 Julia 답변의 접근 방식을 사용하십시오.

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

늙은:

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

입력을 읽고 델타를 계산하고 첫 번째 요소와 연결하고 누적 합계를 계산합니다.

MATL , 8 바이트

1)GdPhYs

온라인으로 사용해보십시오!

이것은 정의를 직접 적용한 것입니다. [18 19 17 20 16]예를 들어 입력 을 고려하십시오 .

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]

다른 접근 방식, 동일한 바이트 수 :

P_G5L)s+

onllne 사용해보십시오!

원래 배열의 첫 번째 항목과 마지막 항목을 더한 반전 및 부정 배열.

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

apt, 8 바이트

Ô®nUÌ+Ug

온라인으로 실행

Pyth-10 바이트

sM._+hQ_.+

테스트 스위트 .

아희 (Aheui) , 3 * 21 자 + 2 "\ n"= 65 바이트

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

스택 아의 입력을 가정합니다. 출력은 스택 안에 저장됩니다.

이 코드를 사용하려면 다음을 수행하십시오.

이 코드의 첫 줄 끝에 문자 벙길이 (n)-시간을 추가하십시오 (즉, 입력이 7 개의 정수이면 7 번 삽입하십시오). 각 프롬프트마다 하나의 정수를 입력하십시오.

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

여기 사용해보십시오! (코드를 복사하여 붙여 넣기)

예

의 경우 1, 2, 3, 4, 5:

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

다음 입력 1, 2, 3, 4, 및 5(5 지시가있을 것입니다).

대체 버전 (65 바이트)

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

C # 42 바이트

를 취하고 int[]를 반환합니다 IEnumerable<int>.

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

(이것은 실제로 JHM 버전의 포팅 된 버전입니다.)

TSQL, 200 바이트

입력으로 사용되는 테이블 변수

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

사용해보십시오

PHP, 60 56 52 바이트

@ user59178 덕분에 -4 바이트

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

명령 줄 인수에서 작동하고 밑줄을 구분 기호로 사용합니다. 로 실행
php -r '<code>' <space separated numbers>

펄 6 ,  48 33  30 바이트

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

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

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

시도 해봐

넓히는:

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

는 *-1또한 유형 WhateverCode의 람다 표현 *유일한 위치 파라미터이다.

줄리아 0.4 , 32 바이트

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

온라인으로 사용해보십시오!

BASH, 71 바이트

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

C ++ 14, 103 바이트

람다 이름으로 입력을 요구하는 것은 갖도록 rbegin, rend, back및 push_back용기 등 vector, deque또는 list.

Glen O의 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;}

언 골프 및 사용법 :

#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";
}

하스켈, 33 바이트

JHM과 동일한 논리를 사용합니다.

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

잘 읽을 수 있습니다.

볼록형 , 10 바이트

_î\(@¥+¡p;

온라인으로 사용해보십시오!

클로저, 101 바이트

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

대부분의 설명을 따릅니다.

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

자바 7, 96 바이트

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;}

설명:

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

테스트 코드 :

여기에서 시도하십시오.

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 })));
  }
}

산출:

[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 바이트 ^SBCS

익명의 암묵적 접두사 기능.

+\⊃,∘⌽2-⍨/⊢

온라인으로 사용해보십시오!

+\ 누적 합계

⊃ 인수의 첫 번째 요소

, 다음
∘ 으로
⌽ 환입

2-⍨/ 쌍의 차이

⊢ 논쟁 거리