22

पूर्णांकों की सूची की अंतर सूची निरंतर सदस्यों की सूची अंतर है।

उदाहरण के लिए अंतर की सूची

1, 3, 2 ,4

है

2, -1, 2

आपका कार्य एक अंतर सूची को इनपुट के रूप में लेना है और यदि मूल सूची को छांटा गया है तो अंतर सूची कैसी दिखेगी, इसका उत्पादन करना है।

उदाहरण के लिए अंतर सूची

2, 1, -2, -1

एक सूची का प्रतिनिधित्व कर सकते हैं

2 4 5 3 2

जिसे जब क्रमबद्ध किया जाता है

2 2 3 4 5

जिसकी अंतर सूची है

0 1 1 1

यह कोड-गोल्फ है इसलिए उत्तर बाइट में कम बाइट के साथ बेहतर स्कोर किए जाएंगे।

code-golf array-manipulation

— गेहूं का जादूगर
स्रोत

क्या समाधान अद्वितीय होने की गारंटी है?

— H.PWiz

@ H.PWiz हाँ वे हैं।

— गेहूं जादूगर

सम्बंधित।

— पूरी तरह से

1

@ H.PWiz क्विक प्रूफ: एक सूची पहले तत्व मान के साथ संयुक्त अंतर सूची (DL) से पूरी तरह से पुनर्निर्माण योग्य है, इसलिए L से (FV, DL) में एक-से-एक रूपांतरण है। किसी भी राशि से FV बढ़ाना L के प्रत्येक तत्व में उस राशि को जोड़ने के समान है और इसलिए यह L की छंटाई को बदल नहीं सकता है यदि वह तुलना उपयुक्त रूप से एकरस है। (दूसरे शब्दों में, यह तब तक छँटाई को प्रभावित नहीं करता है जब तक कि आप जो संख्या जोड़ रहे हैं वह पूर्णांक अतिप्रवाह है)।

— सीआर ड्रॉस्ट

1

क्या आप कुछ और परीक्षण मामलों को जोड़ सकते हैं? मैं [-2, 100, -2, -1]उदाहरण के लिए , अलग-अलग आउटपुट देने वाले कुछ समाधानों पर ध्यान देता हूं ।

— झबरा

16

05AB1E , 4 बाइट्स

.¥{¥

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

व्याख्या

.¥{¥
.¥   # Undelta the input list
  {  # Sort it
   ¥ # And get the deltas

— Datboi
स्रोत

Undelta05AB1E में सबसे आला बिल्ट-इन है। o0

— totallyhuman

2

आहह बकवास, मुझे हरा दो। मैं हमेशा undelta का उपयोग करना चाहता हूँ।

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

16

Undeltaಠ ___ ಠ

— व्यवसाय बिल्ली

1

"अंडेल्टा" बस संचयी योग है, है ना?

— जरगब

2

@Zgarb अंडरलेटा सूची के पहले तत्व के रूप में 0 जोड़ रहा है, फिर जैसा आपने कहा है, संचयी राशि या रिवर्स डेल्टा।

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

9

पम्प्न 3 के साथ नेम्पी , 56 54 53 बाइट्स

@ बायर ( sortमानक के बजाय नेम्पी ) के लिए 2 बाइट्स धन्यवाद sorted। धन्यवाद बंद 1 बाइट के लिए @notjagan (चलती 0में cumsum)

lambda x:diff(sort(cumsum([0]+x)))
from numpy import*

कोड एक अनाम फ़ंक्शन को परिभाषित करता है जो एक सूची या Numpy सरणी इनपुट करता है और एक Numpy सरणी आउटपुट करता है।

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

— लुइस मेंडो
स्रोत

1

वाह, आपने आज मुझे कुछ नया सिखाया है। मेरा दृष्टिकोण numpyबहुत लंबा था। मैं कल इसे वापस आऊंगा, क्योंकि मैं आपको पहले से ही छाया हुआ देखता हूं। बहुत अच्छा!

— श्री एक्सकोडर

@ Mr.Xcoder धन्यवाद! मैं Numpy में कोई विशेषज्ञ नहीं हूं, मैंने सिर्फ वही किया है जो मैंने Matlab में किया है: diff(sort([0 cumsum(x)]))(Matlab में, [ ]सहमति है)

— लुइस मेंडो

कर्तव्य पूरा!

— श्री Xcoder

-1 बाइट ले जाकर 0में cumsum।

— नॉटजागन

5

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

Differences@Sort@Accumulate@Join[{1},#]&

— J42161217
स्रोत

Differences@Sort@FoldList[+##&,1,#]&

— alephalpha

4

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

0;+\ṢI

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

— आउटगोल्फर को एरिक करें
स्रोत

4

भूसी , 4 बाइट्स

Ẋ-O∫

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

explaination

      -- implicit input, e.g                               [2,1,-2,-1]
   ∫  -- cumulative sum                                    [0,2,3,1,0]
  O   -- sort                                              [0,0,1,2,3]
Ẋ     -- apply function to all adjacent pairs in the list  [(0,0),(0,1),(1,2),(2,3)]
 -    --   subtract                                        [0,1,1,1]

— H.PWiz
स्रोत

एक और भाषा जिसमें अंडाल्ट है? या कुछ कट्टरपंथी बिल्ट-इन?

— मिस्टर एक्सकोडर

@श्री। Xcoder ऐसा होता है कि कम्सम अंडरल्टा के समान है

— एच.पी.विज़

@ H.PWiz वास्तव में वह नहीं है जिसे हम कमसुम कहते हैं ... जब तक कि आप खाली उपसर्ग को ध्यान में नहीं रखते हैं।

— आउटगॉल्फ

@EriktheOutgolfer हां, यह वही है जो भूसी करती है, जैसा कि scanl(+)0हास्केल में है।

— H.PWiz 16

4

अजगर , 9 बाइट्स

-1 बाइट के लिए @EriktheOutgolfer का धन्यवाद ।

.+S+0sM._

परीक्षण सूट।

अजगर , 10 बाइट्स

.+S.u+YNQ0

इसे ऑनलाइन आज़माएं! या अधिक परीक्षण मामलों का प्रयास करें ।

— श्री Xcoder
स्रोत

जैसा कि मेरे (हटाए गए) उत्तर में, आप -1 के +0sM._बजाय उपयोग कर सकते हैं .u+YNQ0।

— आउटगॉल्फ

@EriktheOutgolfer आपने इसे क्यों हटाया?

— श्री Xcoder

सोचा कि मूल विचार भी आपके जैसा ही था।

— आउटगॉल्फ

@EriktheOutgolfer ठीक है, फिर धन्यवाद

— श्री Xcoder

m=+Zके लिए एक ही लंबाई संस्करण है sM._, लेकिन दुख की बात है कि यह किसी भी छोटे हो सकता है नहीं लगता है।

— FryAmTheEggman

4

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

सहेजे गए 1 बाइट @ETHproductions के लिए धन्यवाद

a=>a.map(n=>t-=n,p=t=0).sort((a,b)=>b-a).map(n=>p-(p=n))

डेमो

कोड स्निपेट दिखाएं

let f =

a=>a.map(n=>t-=n,p=t=0).sort((a,b)=>b-a).map(n=>p-(p=n))

console.log(JSON.stringify(f([2, 1, -2, -1])))

Expand snippet

— Arnauld
स्रोत

.sort((a,b)=>a-b)यही डेल्टास पाने का तरीका है? घटाव के साथ छाँटकर? : पी

— बमुश्किल

@totallyhuman पहले डेल्टास map()देता है। यह कोड उन्हें सॉर्ट करता है। दूसरा नक्शा नए डेल्टास का पुनर्निर्माण करता है। जेएस sort()विधि डिफ़ॉल्ट रूप से शाब्दिक आदेश का उपयोग करती है। तो, हमें नंबर> 9 (दुख की बात है) के लिए इस विशेष कॉलबैक की आवश्यकता है।

— अरनौलड

यह -p+(p=n)मेरे गियर को पीसता है, लेकिन दुख की बात है कि कोई बेहतर तरीका नहीं है ... जब तक ...

— ETHproductions

बिल्ली क्या है, मैंने सबमिट बटन नहीं दबाया> _ <लेकिन फिर भी, मुझे लगता है कि आप उस संपादन के साथ एक बाइट बचा सकते हैं ...

— ETHproductions

@ETHproductions धन्यवाद :-)

— Arnauld

3

जावा 8, 123 बाइट्स

मानक समाधान: संचयी योग इनपुट, सॉर्ट, फिर अलग। कोई पर्याप्त कार्यान्वयन चालें भी नहीं।

l->{int s=l.length,d[]=new int[s+1],i=0;while(i<s)d[i+1]=d[i]+l[i++];for(java.util.Arrays.sort(d);i-->0;)l[i]=d[i+1]-d[i];}

कास्ट किया Consumer<int[]>। आउटपुट उत्परिवर्तित इनपुट है।

यह ऑनलाइन की कोशिश करो

अघोषित लंबोदर

l -> {
    int
        s = l.length,
        d[] = new int[s + 1],
        i = 0
    ;
    while (i < s)
        d[i + 1] = d[i] + l[i++];
    for (java.util.Arrays.sort(d); i-- > 0; )
        l[i] = d[i + 1] - d[i];
}

स्वीकृतियाँ

-3 बाइट्स का धन्यवाद ओलिवियर ग्रेजोइरे , अपवित्र ऑटोइन्क्रेशन के मास्टर
-1 बाइट धन्यवाद नेवे को

— जेकब
स्रोत

1

आप उन पदों को फिर से व्यवस्थित करके 3 बाइट्स गोल्फ कर सकते हैं जहां आप अपनी वेतन वृद्धि और अपनी समग्र गणना करते हैं:

l->{int s=l.length,d[]=new int[s+1],i=0;for(;i<s;)d[i+1]=d[i]+l[i++];java.util.Arrays.sort(d);for(i=0;i<s;)l[i]=-d[i]+d[++i];}

(कॉपी / पेस्ट करते समय एसई के अदृश्य वर्णों से सावधान रहें)

— ओलिवियर ग्रेजायर

1

मेरी नई शीर्षक के लिए धन्यवाद;) यहाँ जश्न मनाने के लिए अधिक घटती अपवित्रता है for(;i>0;)l[i-1]=d[i]-d[--i];(पिछले पाश)

— ओलिवर Grégoire

मैंने बस उस लूप को फिर से काम में लिया था, for(;i-->0;)l[i]=d[i+1]-d[i];जो एक ही लंबाई में था। आने के लिए अद्यतन करें।

— जकॉब

2

आप का उपयोग करके 1 बाइट बचा सकते हैं

l->{int s=l.length,d[]=new int[s+1],i=0;while(i<s)d[i+1]=d[i]+l[i++];for(java.util.Arrays.sort(d);i-->0;l[i]=d[i+1]-d[i]);}

।

— नेवई

हाँ, बिल्कुल। धन्यवाद!

— जैकब

2

ब्रेकीलॉग , 15 बाइट्स

a₀ᶠ+ᵐ,0o{s₂↔-}ᶠ

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

— आउटगोल्फर को एरिक करें
स्रोत

2

आर , 31 32 बाइट्स

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

के लिए जारको से +5 बाइट्स cat

cat(diff(sort(diffinv(scan()))))

स्टड से पढ़ता है, स्टडआउट को लिखता है। किसी दिए गए शुरुआती मूल्य (0 बाय डिफॉल्ट) diffinvका उलटा है diff। चूंकि यह diffफिर से एड है, इसलिए यह कोई मायने नहीं रखता कि वह मूल्य क्या है।

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

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

— ग्यूसेप
स्रोत

यही मेरे मन में भी था। हालांकि मुद्रण को संभालने की आवश्यकता है, क्योंकि इसे एक पूर्ण कार्यक्रम के रूप में चलाने (के माध्यम से source) यह कुछ भी आउटपुट नहीं करता है।

— JAD

1

यदि आप diffinvइसके बजाय उपयोग cumsumकरते हैं, तो आपको शून्य को प्रीप्रेंड करने की आवश्यकता नहीं है।

— user2390246

@ user2390246 वाह, बहुत अच्छा! टीआईएल डिफिन्विन के बारे में।

— Giuseppe

मैं भी! मैं सिर्फ यह देखने के लिए एक त्वरित खोज कर रहा था कि क्या कोई पिछले उत्तर थे जिन्हें मैं इसे लागू कर सकता था।

— user2390246

1

पायथन 2 , 83 बाइट्स

l,r=input(),[1]
for i in l:r+=[r[-1]+i]
r.sort()
print[b-a for a,b in zip(r,r[1:])]

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

भयानक समाधान।

— totallyhuman
स्रोत

यह वास्तव में भयानक नहीं है

— श्री एक्सकोडर

+=सूचियों पर पायथन का ऑपरेटर किसी भी चलने योग्य के साथ काम करता है, इसलिए आप r+=r[-1]+i,इसके बजाय r+=[r[-1]+i]एक बाइट का उपयोग कर सकते हैं और बचा सकते हैं ।

— जोनाथन फ्रेच

1

पर्ल 6 , 46 बाइट्स

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

कोशिश करो

विस्तारित:

{  # bare block lambda with implicit signature :(*@_)

  [\+](         # triangle reduce using &infix:«+»
    0,          # start with 0
    |@_         # Slip in the arguments from the outer block
  )             #                  (0, 2, 3, 1, 0)

  .sort         # sort the results (0,0,1,2,3)
  .rotor(2=>-1) # group in twos    ((0,0),(0,1),(1,2),(2,3))
  .flat         # flatten          (0,0,0,1,1,2,2,3)
  .map(*R-*)    # grab 2 values at a time, and subtract first from second
                # (0, 1, 1, 1)
}

— ब्रैड गिल्बर्ट b2gills
स्रोत

1

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

import Data.List
g=sort.scanl(+)0
h l|k<-g l=map(\(x,y)->x-y)$zip(tail$k)k

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

सीधा।

— jferard
स्रोत

3

=<<समारोह से मोनद काम आता है: (zipWith(-)=<<tail).sort.scanl(+)0

— nimi

@ निम्मी बहुत अच्छी। मैं भिक्षुओं का विशेषज्ञ नहीं हूं, लेकिन मुझे सोचना चाहिए था zipWith।

— जिगार्ड

1

टीआई-बेसिक (TI-84 Plus CE), 23 बाइट्स

Prompt X
augment({0},cumSum(_LX→X
SortA(_LX
ΔList(_LX

उपयोगकर्ता इनपुट के लिए संकेत। सूची को एक अग्रणी के साथ इनपुट किया जाना चाहिए {, इसके द्वारा अलग किए गए नंबर के साथ ,, और एक वैकल्पिक अनुगामी के साथ }।

टीआई-बेसिक एक टोकन भाषा है ; ΔList(और cumSum(दो-बाइट टोकन हैं, उपयोग किए जाने वाले अन्य सभी टोकन एक-एक बाइट हैं।

उदाहरण रन ( NAMEप्रोग्राम के नाम और {4,-2,7,-4,0}इनपुट के रूप में):

prgmNAME
X=?{4,-2,7,-4,0}
               {2 2 1 0 4}

स्पष्टीकरण:

Prompt X                  # 3 bytes, get list input, store in _LX
augment({0},cumSum(_LX→X   # 12 bytes, 
          # store the list ({0} prepended to the cumulative sum of _LX) to _LX
SortA(_LX                  # 4 bytes, sort _LX ascending
ΔList(_LX                  # 4 bytes, implicitly print the difference list of _LX

— pizzapants184
स्रोत

क्या आपको जरूरत है L?

— ज़ाचारि

@ Zacharý आप एक सूची को संग्रहीत करते समय उन्हें छोड़ सकते हैं, लेकिन जब सूची के बजाय संख्यात्मक चर X का उल्लेख करेंगे तो उन्हें छोड़ देना होगा

— pizzapants184

1

C ++ (gcc) , 136 बाइट्स

अनाम जेनेरिक लैम्ब्डा के रूप में, इनपुट मान लेना std::listऔर संदर्भ पैरामीटर के माध्यम से वापस आना।

[](auto&L){auto r=L.begin(),l=L.insert(r,0);while(r!=L.end())*r+++=*l++;for(L.sort(),l=r=--L.end();--l!=L.begin();*r---=*l);L.erase(l);}

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

Ungolfed:

[](auto&L){
 auto r=L.begin(),
      l=L.insert(r,0); //adds a zero right in front
 while(r!=L.end())
   *r++ += *l++;       //sum left to right
 for(
  L.sort(),            //sorting invalidates the iterators
  l=r=--L.end();       //so, reinit
  --l!=L.begin();      //decrement l beforehand 
  *r-- -= *l           //diff right to left
 );
 L.erase(l);           //l==L.begin(), so this removes the temporary 0
}

— कार्ल नेफ
स्रोत

1

पायथ, 8 बाइट्स

.+S+M.uP

प्रदर्शन

.+S+M.uP
.+S+M.uPNQ    Implicit variables
     .u  Q    Apply the following function to the input repeatedly until it
              stops changing, then output the list of values, including the
              starting value.
       PN     Remove the last element. No-op if the list is empty.
   +M         Sum each list. This gives the cumulative sums in reverse order,
              including a 0 at the end for the empty list.
  S           Sort
.+            Deltas

— isaacg
स्रोत

+1 यह संचयी निश्चित बिंदु के साथ एक स्वच्छ समाधान है। मैंने व्यक्तिगत रूप से भी ऐसा नहीं सोचा था।

— श्री Xcoder

1

टीआई-बेसिक, 20 बाइट्स

cumSum(augment({0},Ans->L1
SortA(L1
ΔList(L1

— Timtech
स्रोत

1

पर्ल 5 , 87 + 1 (-ए) = 88 बाइट्स

$a[0]=1;push@a,$a[-1]+$_ for@F;@a=sort{$a<=>$b}@a;print$a[0]-$_,$"while($_=shift@a)&&@a

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

— Xcali
स्रोत

1

VB.NET (.NET 4.5), 109 बाइट्स

Sub A(n)
Dim c=n.count-1
For i=1To c
n(i)+=n(i-1)
Next
n.Sort()
For i=c To 1 Step-1
n(i)-=n(i-1)
Next
End Sub

एक फ़ंक्शन जो इनपुट के रूप में एक सूची की अपेक्षा करता है और इसे सीधे संशोधित करता है। मूल पैरामीटर का उपयोग आउटपुट के लिए किया जा सकता है

सूची के माध्यम से आगे जोड़कर एक मूल सूची को फिर से बनाता है (प्रथम तत्व के रूप में एक निहित 0 मानता है)
मूल सूची को सॉर्ट करता है
अंतर को पीछे की ओर ले जाता है (इसलिए मुझे अलग सूची का ध्यान रखने की आवश्यकता नहीं है) (0 के निहित पहले तत्व का अर्थ है पहला अंतर सबसे छोटे तत्व के समान है)

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

— ब्रायन जे
स्रोत

क्या आप TIO लिंक को अपडेट करना चाहेंगे?

— टेलर स्कॉट

@TaylorScott किस तरह से अपडेट करें?

— ब्रायन जे

आपका TIO लिंक आपके उत्तर की तुलना में पूरी तरह से अलग कोड दिखाता है

— टेलर स्कॉट

1

@TaylorScott आह ... मैं देख रहा हूँ। मुझे कुछ समायोजन करना पड़ा क्योंकि टीआईओ मोनो का उपयोग करता है, लेकिन मैं .NET 4.5 कंपाइलर का उपयोग कर रहा था

— ब्रायन जे

1

APL (Dyalog) , 15 14 बाइट्स

-1 बाइट धन्यवाद ngn करने के लिए ।

(¯2-/⍋⊃¨⊂)0,+\

+\ संचयी योग

0, एक शून्य प्रिपेंड करें

(...) उस पर निम्नलिखित tacit फ़ंक्शन लागू करें:

⊂ संलग्न करें (ताकि हम कई आइटम ले सकें)

⍋⊃¨ प्रत्येक सूचक को उस से लेने वाले तर्क को छाँटने दें

¯2-/ उलट जोड़ीदार अंतर

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

Dyalog '17 उपयोगकर्ता की बैठक में कोड गोल्फ हैकथॉन प्रतिभागियों द्वारा पाया गया मूल समाधान :

¯2-/l[⍋l←+\0,⎕]

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

⎕ इनपुट के लिए संकेत

0, एक शून्य प्रिपेंड करें

+\ संचयी योग

l← के रूप में स्टोर l

⍋ उन सूचकांकों को खोजें जो क्रमबद्ध होंगे l

l[... ] कि सूचकांक में उपयोग करेंl

¯2-/ उलट जोड़ीदार अंतर

— Adám को दर्शाता है
स्रोत

1

मुझे नहीं पता कि क्या हैकाथॉन में इसकी अनुमति दी गई थी, लेकिन यदि आप इसे बिंदु-मुक्त शैली में फिर से लिखते हैं तो आप एक चार को बचा सकते हैं: (char2- / ⍋⊃¨⊂) 0, + \

— ngn

@ng कार्यशाला का यह हिस्सा प्रतिभागियों को पीपीसीजी के साथ शुरू करने का प्रयास कर रहा था, इसलिए यहां नियम पीपीसीजी के थे। धन्यवाद।

— आदम

1

MATL , 6 बाइट्स

0hYsSd

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

0       # push 0
 h      # horizontal concatenate with implicit input
  Ys    # cumulative sum
    S   # sort
     d  # diff (implicit output)

— ग्यूसेप
स्रोत

0

गैया , 7 बाइट्स

1¤++⊣ȯọ

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

व्याख्या

1¤+      Prepend 1
   +⊣    Cumulative sums
     ȯ   Sort
      ọ  Deltas

— बिजनेस कैट
स्रोत

0

के , 16 बाइट्स

1_-':{x@<x}@+\0,

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

              0, /prepend a 0
            +\   /cumulative sum
     {x@<x}@     /sort
1_-':            /differences list

— zgrep
स्रोत

0

जाप , 10 बाइट्स

iT å+ n än

झसे आज़माओ

— झबरा
स्रोत

0

रोड़ा , 42 बाइट्स

{i=0{[0];[i]if i+=_}|sort|slide 2|[_2-_1]}

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

यह पर्ल 6 उत्तर के समान है । .sortहै |sort, .rotor(2=>-1).flatहै |slide 2 और .map(*R-*)है|[_2-_1] ।

स्पष्टीकरण:

{
  i=0 /* initialize variable i */
  /* the following block recreates the original list from differences: */
  {
    [0];       /* push 0 to the stream */
    [i]if i+=_ /* add every number in the stream to i and push i back */
  }|
  sort|    /* sort the numbers */
  slide 2| /* for values i1, i2, i3, ... in the stream
              push pairs i1, i2, i2, i3, ... */
  [_2-_1]  /* calculate difference of numbers in each pair in the stream */
}

कथन [i]if i+=_के बराबर है

for sfv do
  if i += sfv do
    push(i)
  done
done

+=ऑपरेटर धारा के मूल्यों धक्का नहीं है, इसलिए यह truthy है। मैं {|j|i+=j;[i]}_जोड़ को जोड़ने और बयान को आगे बढ़ाने के लिए किसी तरह के ब्लॉक (जैसे। ) का इस्तेमाल कर सकता था , लेकिन ifयह छोटा है।

— fergusq
स्रोत

0

जूलिया 0.6.0 (34 बाइट्स)

आर और पायथन 3 में जो कुछ किया गया है, उसकी बहुत ज्यादा नकल है

x->diff(sort(cumsum(vcat([0],x))))

— Goysa
स्रोत

0

जे, 10 बाइट्स

/:~&.(+/\)

व्याख्या

"सॉर्ट अंडर स्कैन सम": जे में, अंडर कॉन्सक्यूपेशन &.इनपुट के अपने अधिकार में परिवर्तन को लागू करता है, फिर इसके बाईं ओर (इस मामले में सॉर्ट /:~) पर क्रिया को लागू करता है और फिर रिवर्स ट्रांसफॉर्म करता है। यही है, जे समझता है कि एक स्कैन राशि को कैसे पलट दिया जाए, जो कि वास्तव में यहां आवश्यक है: क्रमिक अंतर वे इनपुट हैं, जो स्कैन-सारांशित होने पर, उस स्कैन-राशि का उत्पादन करेंगे।

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

— जोनाह
स्रोत

एक अंतर सूची को क्रमबद्ध करें

05AB1E , 4 बाइट्स

व्याख्या

पम्प्न 3 के साथ नेम्पी , 56 54 53 बाइट्स

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

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

भूसी , 4 बाइट्स

explaination

अजगर , 9 बाइट्स

अजगर , 10 बाइट्स

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

डेमो

जावा 8, 123 बाइट्स

अघोषित लंबोदर

स्वीकृतियाँ

ब्रेकीलॉग , 15 बाइट्स

आर , 31 32 बाइट्स

पायथन 2 , 83 बाइट्स

पर्ल 6 , 46 बाइट्स

विस्तारित:

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

टीआई-बेसिक (TI-84 Plus CE), 23 बाइट्स

C ++ (gcc) , 136 बाइट्स

पायथ, 8 बाइट्स

टीआई-बेसिक, 20 बाइट्स

पर्ल 5 , 87 + 1 (-ए) = 88 बाइट्स

VB.NET (.NET 4.5), 109 बाइट्स

APL (Dyalog) , 15 14 बाइट्स

MATL , 6 बाइट्स

गैया , 7 बाइट्स

व्याख्या

के , 16 बाइट्स

जाप , 10 बाइट्स

रोड़ा , 42 बाइट्स

जूलिया 0.6.0 (34 बाइट्स)

जे, 10 बाइट्स

व्याख्या