एरे का उलटा डेल्टास

Question

एरे का उलटा डेल्टास

एरे के विलोम डेल्टास की निरंतरता

आपका कार्य हस्ताक्षरित 32 बिट पूर्णांकों की एक सरणी लेना है, इसे अपने डेल्टा के साथ फिर से जोड़ दें।

उदाहरण

सूचि,

18  19  17  20  16

डेल्टा है:

   1  -2   3  -4

जो, जब उलट जाता है, पैदावार:

  -4   3  -2   1

फिर जब recompiled, पैदावार का उपयोग:

18  14  17  15  16

जो आपका रिटर्न मान होना चाहिए।

रीकॉम्पेलिंग में लेने के होते हैं C, जो कि सरणी का पहला मूल्य है। इस मामले में 18, और इसे क्रम में deltas लागू करने के लिए। तो 18 + -4देता है 14, 14 + 3देता है 17, और इसी तरह।

इनपुट आउटपुट

आपको एक सूची / सारणी / टेबल / ट्यूपल / स्टैक / आदि दी जाएगी। किसी भी मानक इनपुट पद्धति के माध्यम से इनपुट के रूप में हस्ताक्षरित पूर्णांक।

उपरोक्त डेल्टा विधि का पालन करते हुए, आपको संशोधित डेटा को किसी भी स्वीकार्य रूप में एक बार फिर से आउटपुट करना होगा।

आपको एन इनपुट प्राप्त होगा 0 < N < 10जहां प्रत्येक संख्या सीमा के भीतर आती है-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 से अधिक नहीं।
• आपके आउटपुट की पहली और अंतिम संख्या, हमेशा इनपुट से मेल खाएगी।
• केवल मानक इनपुट आउटपुट स्वीकार किया जाता है
• मानक खामियां लागू होती हैं
• यह कोड-गोल्फ है , इसलिए सबसे कम बाइट-काउंट जीतता है!
• मज़े करो!

और विजेता है...

डेनिस! जिसने पहले स्थान पर पहला स्थान हासिल किया, फिर एक छोटे से समाधान के साथ खुद को हराया, खुद को पहला और दूसरा स्थान दिया!

अपने जेली के साथ ais523 के लिए माननीय उल्लेख , कि अगर उनके सामने बस डेनिस को पाने के लिए नहीं, दूसरे स्थान पर होता।

Comments

इन डेल्टा चुनौतियों ने केवल यह साबित किया है कि गणित में अनावश्यक डेल्टा कैसे होते हैं।

— अताको

गणित में कैसे अनावश्यक डेल्टास होते हैं गणित की सबसे महत्वपूर्ण शाखाओं में से एक पर आधारित है (infinitesimally small) deltas

— लुइस मेंडो

मैं अभी भी खुश नहीं हूँ

— ATaco

मैं नहीं कर सकता सी ppcg पर एक गणितीय चुनौती ...: पी

— मुकुल कुमार

Answer 1

जेली , 5 बाइट्स

.ịS_Ṛ

यह ग्लेन ओ के जूलिया उत्तर से एल्गोरिथ्म का उपयोग करता है ।

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

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

Comments

डेनिस प्लीज

— निधि मोनिका का मुकदमा

Answer 2

जेली , 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.

Comments

डेनिस कृपया

— ATaco

लगता है कि आपने मुझे कुछ मिनटों के लिए हराया। हैरानी की बात है, हमारे कार्यक्रम भी समान नहीं हैं (आपके पास Ṛजहां मेरे पास है U)। मुझे नहीं पता कि यह उन्हें डुप्लिकेट पर विचार न करने के लिए अलग बनाता है।

@ ais523 Uvectorizes जबकि Ṛनहीं करता है, लेकिन फ्लैट सरणियों के लिए उनके व्यवहार के समान है।

— डेनिस

मुझे लगता है कि मैं अपना उत्तर हटा दूंगा, तब (जब तक कि मैं अपने दम पर "सही" उत्तर के साथ आने में कामयाब नहीं हो जाता, तब तक थोड़ा नाराज रहा, और यहाँ एकमात्र वास्तविक मुद्दा यह है कि कोई और पहले उसी उत्तर को खोजने में कामयाब रहा) ।

ASCII के प्रारूप में 6 बाइट्स के रूप में क्या निकलता है? जुबांटु पर प्लामा कहता है कि यह 10 बाइट्स है, और जूलिया Ḣ0x1e22 के Ṛरूप में और 0x1e5a के रूप में स्टोर करता है , जिनमें से प्रत्येक को 3 बाइट्स की आवश्यकता होती है।

— Glen O

Answer 3

जूलिया, 24 बाइट्स

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

यह समस्या को हल करने का "चतुर" तरीका है। सरणी के नकारात्मक रिवर्स में "डेल्टास" उल्टा है, और फिर आपको बस इस तथ्य को ठीक करने की आवश्यकता है कि यह गलत स्थानों पर शुरू / समाप्त होता है।

Answer 4

स्नोमैन 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
))

Answer 5

जावास्क्रिप्ट (ईएस 6), 45 37 बाइट्स

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

पोर्ट ऑफ @ जेएचएम का गणितज्ञ उत्तर। (मुझे यकीन है कि मैं इसे स्वयं प्राप्त कर सकता था, लेकिन रात के इस समय नहीं।) संपादित करें: @ edc65 के लिए 8 बाइट्स धन्यवाद।

Comments

क्या कोई कारण है जिसकी आपको आवश्यकता है [...और ]?

— मामा फन रोल

@MamaFunRoll अन्यथा यह संशोधित हो जाएगा a, जिसे बाद में कार्यक्रम में उपयोग किया जाता है

— कॉनर ओ'ब्रायन

ओह ठीक है, उस बारे में भूल गए: पी

— मामा फन रोल

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

— edc65

@ edc65 बाह, मैं विचार करने के लिए कल रात पर्याप्त जाग रहा था z=a[0], लेकिन मैं [...]और हटाना भूल गया (,i,b)।

— नील

Answer 6

गणितज्ञ, २३ बाइट्स

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

कार्य करते हैं। परिणाम बस है: रिवर्स ((पहला तत्व) + (अंतिम तत्व) - (प्रत्येक तत्व))।

Answer 7

पायथन 2, 96 74 54 44 बाइट्स

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

इनपुट को चौकोर कोष्ठक से घिरे एक सरणी के रूप में दिया गया है। आउटपुट एक ही प्रारूप में है।

पहले से जो कुछ भी मैं कर रहा था उससे कहीं अधिक सरल विधि का उपयोग करके 22 42 बाइट बचाने के लिए @Kade का धन्यवाद !

सूची बोध से सूचकांक काउंटर को समाप्त करके 10 बाइट्स बचाने के लिए @ शर्लक 9 का धन्यवाद!

महान, अब अगर मैं इसे और गोल्फ करता हूँ तो मुझे "पार किया गया 44 अभी भी 44" की समस्या है। ; _;

Comments

lambda l:[l[0]+l[-1]-l[i]for i in range(len(l))][::-1]54 बाइट्स के बारे में क्या ? :) (गणना के लिए ग्लेन ओ को श्रेय)

— केड

अरे वाह, मैंने यह कैसे पता नहीं लगाया। धन्यवाद! :)

— हाइपरएनुट्रिनो 14

एलेक्स, आप अपने जवाब के रूप में उस लंबोतरा फ़ंक्शन का उपयोग कर सकते हैं :)

— केड

क्या। ओह। ठीक है शुक्रिया! :)

— हाइपरएन्यूट्रीनो

इसके बजाय l[i]for i in range(len(l)), आप j for j in l14 बाइट्स को बचाने के लिए उपयोग कर सकते हैं ।

— शेरलाक

Answer 8

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

Comments

होशियार मैं क्या कोशिश कर रहा था:¬s¥Rvy)}

— मैजिक ऑक्टोपस Urn

Answer 9

आर, 37 30 बाइट्स

संपादित करें: अब ग्लेन ओ के जूलिया उत्तर में दृष्टिकोण का उपयोग कर

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

पुराना:

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

इनपुट पढ़ता है, डेल्टास की गणना करता है, पहले तत्व के साथ मिलाता है और संचयी योग की गणना करता है।

Answer 10

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+

इसे चालू करने की कोशिश करो!

उलट और नकारात्मक सरणी प्लस मूल सरणी की पहली और आखिरी प्रविष्टियाँ।

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

Answer 11

जाप, 8 बाइट्स

Ô®nUÌ+Ug

इसे ऑनलाइन चलाएं

Comments

वास्तव में मैं क्या था :)

— शैगी

Answer 12

पायथ - 10 बाइट्स

sM._+hQ_.+

टेस्ट सूट ।

Answer 13

Ui (Aheui) , 3 * 21 वर्ण + 2 "\ n" = 65 बाइट्स

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

स्टैक में इनपुट मानता है 아। आउटपुट स्टैक in में संग्रहीत किया जाएगा।

यदि आप इस कोड को आज़माना चाहते हैं:

इस कोड की पहली पंक्ति के अंत में, चरित्र की 벙लंबाई (n) -times जोड़ें (अर्थात यदि इनपुट 7 पूर्णांक है, तो इसे 7 बार डालें)। प्रत्येक संकेत के लिए, एक पूर्णांक लिखें:

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

यहाँ यह कोशिश करो! (कोड को कॉपी और पेस्ट करें)

उदाहरण

के लिए 1, 2, 3, 4, 5:

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

और फिर टाइप करें 1, 2, 3, 4, और5 (वहाँ 5 संकेतों का हो जाएगा)।

वैकल्पिक संस्करण (65 बाइट्स)

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

Comments

आप सिर्फ कहते हैं 65 bytes in UTF-8या कुछ और क्यों नहीं ?

— mbomb007

@ mbomb007 क्योंकि कुछ लोग नहीं जानते कि कोरियाई वर्ण 3 बाइट्स हैं।

— जुंगह्वान मिन

Answer 14

C # 42 बाइट्स

एक लेता है int[]और एक रिटर्न देता है IEnumerable<int>।

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

(यह वास्तव में JHM के संस्करण का केवल एक पोर्ट किया गया संस्करण है ..)

Answer 15

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

कोशिश करके देखो

Answer 16

PHP, 60 56 52 बाइट्स

-4 बाइट्स @ user59178 के लिए धन्यवाद

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

कमांड लाइन तर्कों पर काम करता है, विभाजक के रूप में अंडरस्कोर का उपयोग करता है। साथ दौड़ो
php -r '<code>' <space separated numbers>

Comments

क्या कोई कारण है कि आप $nनियंत्रण चर के रूप में उपयोग क्यों नहीं करते हैं ? मैंने उस तरह के संस्करण की कोशिश की और यह 4 बाइट्स छोटा था और काम करने लगा।

— 15:59 पर user59178

Answer 17

पर्ल 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भी प्रकार का एक लंबोदर अभिव्यक्ति है जो कुछ भी है, जहां *एकमात्र स्थितीय पैरामीटर है।

Comments

उन लोगों के लिए स्पष्टीकरण जो पर्ल नहीं बोलते हैं?

— साइओस

@Cyoce सबसे छोटे संस्करण के लिए जोड़ा गया। यह किसी को समझाने की आवश्यकता होगी जो पर्ल 5 को भी जानता था। यदि आप [\+]पहले उदाहरण से सोच रहे थे , क्या त्रिकोण कम है [\+] 3,-1,1,-5→ (3,2,3,-2)और [\,] 3,-1,1,-5→((3,), (3,-1), (3,-1,1), (3,-1,1,-5))

— ब्रैड गिल्बर्ट b2gills

Answer 18

जूलिया 0.4 , 32 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 19

BASH, 71 बाइट्स

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

Answer 20

सी ++ 14, 103 बाइट्स

अनाम लैम्ब्डा के रूप में, अपने इनपुट की आवश्यकता होती है के लिए rbegin, rend, backऔर push_backकंटेनरों की तरह vector, dequeया list।

ग्लेन ओ के जूलिया जवाब से दृष्टिकोण का उपयोग करना

[](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";
}

Answer 21

हास्केल, 33 बाइट्स

JHM के समान तर्क का उपयोग करता है:

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

काफी पठनीय है।

Comments

आप का उपयोग करके 3 बाइट्स बचा सकता है (!!0)के लिए headऔर का उपयोग कर (<$>)के लिए map: यह ऑनलाइन कोशिश करो!

— ।

Answer 22

उत्तल , 10 बाइट्स

_î\(@¥+¡p;

इसे ऑनलाइन आज़माएं!

Answer 23

क्लोजर, 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))))

Answer 24

जावा 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]

Answer 25

एपीएल (Dyalog यूनिकोड) , 11 बाइट्स ^SBCS

बेनामी tacit उपसर्ग समारोह।

+\⊃,∘⌽2-⍨/⊢

इसे ऑनलाइन आज़माएं!

+\ का संचयी योग

⊃ तर्क का पहला तत्व

, इसके बाद
∘ से
⌽ का प्रत्यावर्तन

2-⍨/ के जोड़ीदार अंतर

⊢ बहस