एक ऐरे की डेल्टास को क्रमबद्ध और फिर से लागू करें

Question

ऐसा लगता है कि एक सुसंगत फ़ंक्शन का उपयोग करके डेल्टास का कोई भी सरल संशोधन लगभग हमेशा किसी अन्य छोटे तरीके से किया जा सकता है , डेनिस । इस प्रकार, एकमात्र समाधान मैं इसे कठिन बनाने की कल्पना कर सकता हूं, किसी प्रकार के असंगत कार्य को शुरू करना है।

छंटाई।

आपका कार्य पूर्णांक का एक सरणी लेना है, उनके डेल्टास को छांटना और पूर्णांक को नया सरणी देना है।

ईजी।

इनपुट के लिए:

1  5 -3  2  9

निम्नलिखित डेल्टास प्राप्त करें:

  4 -8  5  7

फिर, इन डेल्टास को छाँटें, उपज:

 -8  4  5  7

और उन्हें फिर से, जो देता है:

1 -7 -3  2  9

इनपुट आउटपुट

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

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

आपको एन इनपुट प्राप्त होगा 0 < N < 10जहां प्रत्येक संख्या सीमा के भीतर आती है-1000 < X < 1000

परीक्षण के मामलों

1 5 -3 2 9   -> 1 -7 -3 2 9
-5 -1 -6 5 8 -> -5 -10 -7 -3 8
-8 1 -7 1 1  -> -8 -16 -16 -8 1
8 -9 3 0 -2  -> 8 -9 -12 -14 -2
-5 -2 -5 5 0 -> -5 -10 -13 -10 0
-1 9 -1 -7 9 -> -1 -11 -17 -7 9

टिप्पणियाँ

• जैसा कि ऊपर कहा गया है, आप हमेशा कम से कम 1 इनपुट प्राप्त करेंगे, और 9 से अधिक नहीं।
• आपके आउटपुट की पहली और अंतिम संख्या, हमेशा इनपुट से मेल खाएगी।
• केवल मानक इनपुट आउटपुट स्वीकार किया जाता है
• मानक खामियां लागू होती हैं
• यह कोड-गोल्फ है , इसलिए सबसे कम बाइट-काउंट जीतता है!
• मज़े करो!

Comments

IMO आपको दूसरा हेडर (पोस्ट के शरीर में एक) को हटा देना चाहिए। यह थोड़े बदसूरत है और बस जगह लेता है, और यह शीर्षक की एक प्रति है (जो इसके ऊपर 20 px की तरह है)।

— R

Answer 1

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

IṢ;@Ḣ+\

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

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

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

I        Increments; compute the deltas.
 Ṣ       Sort them.
    Ḣ    Head; pop and yield the first element of A.
  ;@     Concatenate with swapped arguments.
     +\  Take the cumulative sum.

Answer 2

MATL , 8 बाइट्स

1)GdShYs

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

1)   % Implicit input. Get its first entry
G    % Push input again
d    % Differences
S    % Sort
h    % Concatenate
Ys   % Cumulative sum. Implicit display

Answer 3

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

FoldList[Plus,#&@@#,Sort@Differences@#]&

शुद्ध कार्य इनपुट के रूप में (कोई भी) सूची ले रहा है और एक सूची लौटा रहा है। FoldList[Plusएक संख्या (इस मामले में, #&@@#इनपुट का पहला तत्व) के साथ शुरू होता है और बार-बार स्वयं-व्याख्यात्मक सूची के तत्वों को जोड़ता है Sort@Differences@#। यह बिल्ट-इन के व्यवहार की नकल करता है Accumulate, लेकिन पहले नंबर को हाथ से मतभेदों की सूची में लाने की आवश्यकता होगी, जो बाइट-काउंट को उच्च बनाता है (जहां तक ​​मैं बता सकता हूं)।

Answer 4

05AB1E , 9 बाइट्स

-4 एमिग्ना के लिए धन्यवाद

¬=s¥{vy+=

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

¬         # Get the head
 =        # Print
  s¥{     # Get sorted Deltas
     vy   # For each
       += # Add to the previous value and print

Comments

आप 4 बाइट्स बचा सकते हैं¬=s¥{vy+=

— Emigna

Answer 5

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

l=input();p=0;d=[]
r=l[0],
for e in l:d+=e-p,;p=e
for e in sorted(d[1:]):r+=r[-1]+e,
print r

Answer 6

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

import Data.List
f l@(a:b)=scanl1(+)$a:(sort$zipWith(-)b l)

टूट - फूट:

f l@(a:b) =           --we create a function f that takes as input a list l with head a and tail b
zipWith(-)b l        --we make a new list with the deltas
sort$                    --sort it
a:                          --prepend a to the list
scanl1(+)$          --create a new list starting with a and adding the deltas to it cumulatively

Comments

scanl(+)a$sort...

— निमी

Answer 7

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

([p,...a])=>[s=p,...a.map(e=>p-(p=e)).sort((a,b)=>b-a).map(e=>s-=e)]

जावास्क्रिप्ट में यह एक विलोम के व्युत्क्रम डेल्टास की गणना करने के लिए गोल्फर बन जाता है । इसके बाद अवरोही क्रम में क्रमबद्ध किया जाता है और पहले तत्व से संचयी रूप से घटाया जाता है।

Answer 8

पायथन 2 ,

90 बाइट्स

x=input()
print[sum(sorted(map(int.__sub__,x[1:],x[:-1]))[:i])+x[0]for i in range(len(x))]

84 बाइट्स

लैम्ब्डा का उपयोग करने पर 6 बाइट्स बचाए। ओव्स के लिए धन्यवाद!

lambda x:[sum(sorted(map(int.__sub__,x[1:],x[:-1]))[:i])+x[0]for i in range(len(x))]

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

कोड को तोड़कर,

>>> x
[1, 5, -3, 2, 9]
>>> map(int.__sub__,x[1:],x[:-1]) #delta
[4, -8, 5, 7]
>>> sorted(map(int.__sub__,x[1:],x[:-1])) #sorted result
[-8, 4, 5, 7]
>>> [sorted(map(int.__sub__,x[1:],x[:-1]))[:i]for i in range(len(x))]
[[], [-8], [-8, 4], [-8, 4, 5], [-8, 4, 5, 7]]
>>> [sum(sorted(map(int.__sub__,x[1:],x[:-1]))[:i])+x[0]for i in range(len(x))]
[1, -7, -3, 2, 9]

हैप्पी कोडिंग!

Comments

मैं इसे करने के लिए एक रास्ता खोजने की कोशिश कर रहा था!

— क्विंटोपिया

आप इसे एक फ़ंक्शन में परिवर्तित करके कुछ बाइट्स बचा सकते हैं:lambda x:[sum(sorted(map(int.__sub__,x[1:],x[:-1]))[:i])+x[0]for i in range(len(x))]

— ओवर्स

Answer 9

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

(p,M=[p[0]])=>p.map((a,b)=>p[b+1]-a).sort((a,b)=>a-b).map((a,b)=>M=[...M,M[b]+a])[p.length-2]

Answer 10

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

p=input()
d=[p[i+1]-p[i] for i in range(len(p)-1)]
o=p[:1]
for n in sorted(d):o+=o[-1]+n,
print o

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

Comments

आप 96 बाइट्स के लिए सूची [p[i+1]-p[i]for i in range(len(p)-1)]

— बोध

Answer 11

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

.u+NYS.+QhQ

यह सिर्फ बयान में वर्णित स्पष्ट बात करता है।

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

      .+Q    Take the deltas of the input
     S       sort it
.u           Cumulative reduce
  +NY        using addition
         hQ  starting with the first element of the input

आगे गोल्फ स्वागत के लिए सुझाव।

Answer 12

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

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

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

Answer 13

PHP, 89 बाइट्स

for($a=$argv;n|$i=$a[++$x+1];)$d[]=$i-$a[$x];for(sort($d);$x-$y++;)echo$a[1]+=$d[$y-2],_;

इस तरह से चलाएं:

php -nr 'for($a=$argv;n|$i=$a[++$x+1];)$d[]=$i-$a[$x];for(sort($d);$x-$y++;)echo$a[1]+=$d[$y-2],",";' 1  5 -3  2  9;echo
> 1_-7_-3_2_9_

व्याख्या

for(
  $a=$argv;          # Set input to $a.
  n | $i=$a[++$x+1]; # Iterate over input.
)
  $d[] = $i-$a[$x];  # Add an item to array $d, with the difference between
                       the current and previous item.

for(
  sort($d);          # Sort the delta array.
  $x-$y++;           # Loop as many times as the previous loop.
)
  echo
    $a[1]+=$d[$y-2], # Print the first input item with the delta applied
                     # cumulatively. First iteration takes $d[-1], which
                     # is unset, so results in 0.
    _;               # Print underscore as separator.

Answer 14

अजगर 2 सुन्न के साथ, 67 56 बाइट्स

from numpy import*
lambda l:cumsum(l[:1]+sorted(diff(l)))

सुन्न को डेल्टास की गणना करने दें, उन्हें सॉर्ट करें, पहले तत्व को छांटें, और संचयी योगों को सुन्न करें। काफी सस्ता?

Comments

करने के लिए आयात बदलकर 3 बाइट्स सहेजें from numpy import*और n.cumsumकरने के लिए cumsumऔर n.diffकरने के लिएdiff

— OVS

धन्यवाद। आप यह बता सकते हैं कि जब से मैंने अजगर को गोल्फ किया, तब से सभी मानक चाल भूल गए।

— क्विंटोपिया

Answer 15

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

{[\+] @_[0],|sort @_[1..*]Z-@_}

कोशिश करो

विस्तारित:

{
  [\+]            # triangle produce values using &infix<+>
    @_[0],        # starting with the first argument
    |             # slip the following into this list
      sort        # sort the following

         # generate the list of deltas

         @_[1..*] # the arguments starting with the second one
         Z[-]     # zipped using &infix:<->
         @_       # the arguments
}

Answer 16

बैच, 197 बाइट्स

@set n=%1
@set s=
:l
@set/ad=5000+%2-%1
@set s=%s% %d%
@shift
@if not "%2"=="" goto l
@echo %n%
@for /f %%a in ('"(for %%b in (%s%)do @echo %%b)|sort"') do @set/an+=%%a-5000&call echo %%n%%

sort संख्यात्मक रूप से क्रमबद्ध नहीं होता है, इसलिए मैं 5000 तक सभी अंतरों को पूर्वाग्रह करता हूं।

Answer 17

बैश + सॉर्ट, 102 बाइट्स

echo $1
n=$1
shift
for e in $*
do
echo $((e-n))
n=$e
done|sort -n|while read e
do
echo $((n+=e))
done

sh + सॉर्ट + एक्सप, 106 बाइट्स

echo $1
n=$1
shift
for e in $*
do
expr $e - $n
n=$e
done|sort -n|while read e
do
n="$n + $e"
expr $n
done

Answer 18

क्लोजर, 46 बाइट्स

#(reductions +(first %)(sort(map -(rest %)%)))

एक दिन मैं क्लर्ज भाषा बनाने जा रहा हूं, जिसमें क्लोजर की तुलना में छोटे नाम हैं।