Dizinin Ters Deltaları

Dizinin Ters Deltalarının devamı

Göreviniz imzalı bir 32 bit tamsayı dizisini almak, ters deltaları ile yeniden derlemektir.

Örnek

Liste,

18  19  17  20  16

delta var:

   1  -2   3  -4

ki, ters çevrildiğinde, verim:

  -4   3  -2   1

sonra yeniden derlendiğinde, verimleri kullanarak:

18  14  17  15  16

ki bu sizin dönüş değeriniz olmalıdır.

Yeniden derleme C, dizinin ilk değeri olan alma işleminden oluşur . Bu durumda, 18ve ona deltaları sırayla uygulayarak. Böylece 18 + -4verir 14, 14 + 3verir 17vb.

Giriş çıkış

Bir liste / dizi / tablo / tuple / stack / etc verilecektir. işaretli tamsayılar herhangi bir standart giriş yöntemiyle girdi olarak belirtilir.

Değiştirilen verileri, yukarıdaki delta ters çevirme yöntemini izleyerek kabul edilebilir herhangi bir biçimde bir kez daha çıkarmanız gerekir.

0 < N < 10Her sayının aralık içinde olduğu N girişlerini alacaksınız.-1000 < X < 1000

Test Kılıfları

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

notlar

• Yukarıda belirtildiği gibi, her zaman en az 1, en fazla 9 giriş alırsınız.
• Çıktınızın ilk ve son sayısı her zaman girdiyle aynı olacaktır.
• Sadece standart giriş çıkışı kabul edilir
• Standart boşluklar uygulanır
• Bu kod golf , yani en düşük bayt sayısı kazanır!
• İyi eğlenceler!

Ve kazanan...

Dennis! İlk önce ilk sırada yer alan, daha sonra kısa bir çözümle kendini yenerek, hem birinci hem de ikinci sırayı verdi!

Jelly'leriyle birlikte ais523'e şerefli bir söz, Dennis'in hemen önünden gelmemesi durumunda ikinci sırayı alacaktı.

Jöle , 5 bayt

.ịS_Ṛ

Bu, Glen O'nun Julia'nın cevabındaki algoritmayı kullanır .

Çevrimiçi deneyin!

Nasıl çalışır

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

Jöle , 6 bayt

I;ḢṚ+\

Çevrimiçi deneyin!

Nasıl çalışır

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 bayt

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

Sorunu çözmenin "zekice" yolu budur. Dizinin negatif tersi ters çevrilmiş "delta" ylara sahiptir ve ardından yanlış yerlerde başladığını / bittiğini düzeltmeniz gerekir.

Kardan adam 1.0.2, 72 bayt

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

Çevrimiçi deneyin!

Bu, mevcut permavardan girdi alan ve çıkan bir alt yordamdır.

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

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

@ JHM'nin Mathematica cevabı limanı. (Kendim türetmiş olabileceğime eminim, ama gecenin bu saatinde.) Düzenleme: @ edc65 sayesinde 8 bayt kaydedildi.

Mathematica, 23 bayt

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

Adsız işlev Sonuç şudur: geri ((ilk öğe) + (son öğe) - (her öğe)).

Python 2, 96 74 54 44 bayt

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

Giriş, köşeli ayraçlarla çevrili bir dizi olarak verilir. Çıktı aynı formatta.

Daha önce yaptığımdan çok daha basit bir yöntem kullanarak 22 42 byte tasarruf için @Kade'e teşekkürler !

Liste anlamadaki indeks sayacını elimine ederek 10 byte tasarruf için @ Sherlock9'a teşekkürler!

Harika, şimdi daha fazla golf oynarsam "çarpı 44 hala 44 olur" sorunu göreceğim. ; _;

05AB1E , 8 bayt

¬s¤sR(++

Çevrimiçi deneyin!

MATL cevabımın çevirisi, ikinci yaklaşım.

¬    % 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, 3730 bayt

Düzenleme: Şimdi Glen O'nun Julia cevabındaki yaklaşımı kullanarak

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

Eski:

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

Girdileri okur, deltaları hesaplar, ilk eleman ile birleştirir ve kümülatif toplamı hesaplar.

MATL , 8 bayt

1)GdPhYs

Çevrimiçi deneyin!

Bu tanımın doğrudan uygulamasıdır. [18 19 17 20 16]Bir örnek olarak girişi düşünün .

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]

Farklı yaklaşım, aynı bayt sayısı:

P_G5L)s+

Bir dene!

Tersine çevrilmiş ve olumsuzlanmış dizi artı orijinal dizinin ilk ve son girişleri.

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 bayt

Ô®nUÌ+Ug

Çevrimiçi çalıştır

Pyth - 10 bayt

sM._+hQ_.+

Test Takımı .

아희 (Aheui) , 3 * 21 karakter + 2 "\ n" = 65 bayt

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

Stack yığınında girişi varsayar. Çıkış, 안 yığınında saklanır.

Bu kodu denemek istiyorsanız:

Bu kodun ilk satırının sonuna, karakter 벙uzunluğu (n) -times ekleyin (yani giriş 7 tamsayıysa, 7 defa ekleyin). Her bilgi istemi için bir tamsayı yazın:

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

Burada dene! (kodu kopyalayıp yapıştırın)

Örnek

İçin 1, 2, 3, 4, 5:

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

ve sonra yazın 1, 2, 3, 4, ve 5(5 istemleri olacaktır).

Alternatif Sürüm (65 bayt)

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

C # 42 bayt

Bir alır int[]ve bir döndürür IEnumerable<int>.

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

(Bu aslında JHM'nin versiyonunun sadece bir versiyonudur ..)

TSQL, 200 bayt

Giriş olarak kullanılan tablo değişkeni

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

Denemek

PHP, 60 56 52 bayt

@ User59178 sayesinde -4 bayt

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

komut satırı argümanlarında çalışır, ayırıcı olarak alt çizgi kullanır. İle koş
php -r '<code>' <space separated numbers>

Perl 6 ,  48 33  30 bayt

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

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

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

Dene

Expanded:

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

Aynı *-1zamanda *, sadece konumsal parametre olan WhateverCode türünde bir lambda ifadesidir .

Julia 0.4 , 32 bayt

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

Çevrimiçi deneyin!

BASH, 71 bayt

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

C ++ 14, 103 bayt

İsimsiz lambda olarak, onun giriş gerektiren olması rbegin, rend, backve push_backkaplar gibi vector, dequeya dalist .

Glen O'nun Julia cevabındaki yaklaşımı kullanarak

[](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 ve kullanım:

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

JHM ile aynı mantığı kullanır:

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

Oldukça okunabilir.

Dışbükey , 10 bayt

_î\(@¥+¡p;

Çevrimiçi deneyin!

Clojure, 101 bayt

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

Hemen hemen açıklamayı izler:

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

Java 7, 96 bayt

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

Açıklama:

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

Test kodu:

Burada dene.

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

Çıktı:

[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 bayt ^SBCS

Anonim zımni önek işlevi.

+\⊃,∘⌽2-⍨/⊢

Çevrimiçi deneyin!

+\ kümülatif toplamı

⊃ argümanın ilk elemanı

, takip
∘ edenler tarafından
⌽ tersine dönmesi

2-⍨/ ikili fark

⊢ argüman