निकटतम दूरी का योग ज्ञात कीजिए

Question

इस कार्य के लिए आपके कोड को पूर्णांक एक्स और वाई की दो क्रमबद्ध सरणियों को इनपुट के रूप में लेना चाहिए। यह एक्स में प्रत्येक पूर्णांक के बीच की पूर्ण दूरी की राशि और वाई में इसकी निकटतम संख्या की गणना करना चाहिए।

उदाहरण:

X = (1 5,9)
Y = (3,4,7)

दूरी 2 + 1 + 2 है।

X = (1,2,3)
Y = (0,8)

दूरी 1 + 2 + 3 है।

आपका कोड किसी भी तरह से इनपुट ले सकता है जो सुविधाजनक है।

मुख्य प्रतिबंध यह है कि आपका कोड दो सरणियों की लंबाई के योग में रैखिक समय में चलना चाहिए। । (आप मान सकते हैं कि दो पूर्णांक जोड़ने में लगातार समय लगता है।)

Comments

क्या हम सरणियों के बजाय सूचियों या धाराओं का उपयोग कर सकते हैं?

— तदर्थ गार्फ हंटर

@CatWizard हाँ आप कर सकते हैं!

— अनुश

कैसे 1 + 2 + 3व्युत्पन्न होता है X = (1,2,3)और Y = (0,8)?

— अतिथि

@ guest271314 निकटतम नंबर दो में से प्रत्येक के 1, 2और 3में Yहै 0। इस प्रकार मतभेद हैं 1-0, 2-0, 3-0।

— डायलन

@FreezePhoenix के बाद से दोनों सूचियों हल कर रहे हैं आप क्योंकि आप पुनरावृति सूची पर हे में कर सकते हैं (n + m), , एक बार प्रत्येक तत्व का दौरा, और जब तक आप तत्व का ट्रैक रखने Y j के सबसे करीब एक्स मैं , आप कर सकते हैं Y j और Y j + 1 के खिलाफ जाँच करें क्योंकि उनमें से एक X I + 1 के सबसे करीब है$X$$Y_j$$X_i$$Y_j$$Y_{j+1}$$X_{i+1}$

— Giuseppe

Answer 1

हास्केल , 70 64 बाइट्स

a%b=abs$a-b
x@(a:b)#y@(c:d)|e:_<-d,a%c>a%e=x#d|1>0=a%c+b#y
_#_=0

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

व्याख्या

पहले हम (%)दो संख्याओं के बीच पूर्ण अंतर को परिभाषित करते हैं। फिर हम (#)दिलचस्प फ़ंक्शन को परिभाषित करते हैं। पहली सूची में हम तब मेल खाते हैं जब दोनों सूची गैर-रिक्त हों:

x@(a:b)#(c:d:e)

यहाँ से हमारे पहले मामले पर हम बाँध dके e:_साथ e:_<-d। यह सुनिश्चित करता है कि dयह गैर-खाली है और यह इसके लिए पहला तत्व है e।

फिर यदि का दूसरा तत्व ( ) पहले की तुलना में करीब (है ) के पहले तत्व के लिए एक्स ( ), हम वापसी के पहले तत्व को हटाने Y और एक ही साथ फिर से बुला एक्स ।$Y$ec$X$ax#d$Y$$X$

यदि हम पैटर्न से मेल खाते हैं, लेकिन हम जो शर्त करते हैं, उसे पास नहीं करते हैं:

a%c+b#y

$X$$X$

$0$$X$$Y$

$O(|X|+|Y|)$

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

$O(\left|X\right|\times\left|Y\right|)$

x#y=sum[minimum$abs.(z-)<$>y|z<-x]

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

Comments

मैंने प्रश्न में स्पष्ट किया कि हम यह मान सकते हैं कि दो पूर्णांक जोड़ने में निरंतर समय लगता है।

— अनुष

Answer 2

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

X,Y=input()
i=j=s=0
while i<len(X):
 v=abs(Y[j]-X[i])
 if j+1<len(Y)and v>=abs(Y[j+1]-X[i]):j+=1
 else:s+=v;i+=1
print s

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

प्रोग्राम बनाम फ़ंक्शन पर जाकर 4 बाइट्स सहेजे गए।

समय-जटिलता की कमी को पूरा करना संभव है क्योंकि दोनों सूचियों को क्रमबद्ध किया गया है। ध्यान दें कि हर बार लूप के चारों ओर, या तो iवृद्धि की जाती है या jबढ़ाई जाती है। इस प्रकार लूप को अधिकांश len(X)+len(Y)समय निष्पादित किया जाता है।

Comments

मैंने इस प्रश्न में स्पष्ट किया कि हम यह मान सकते हैं कि दो पूर्णांकों को जोड़ने में निरंतर समय लगता है।

— अनुष

Answer 3

सी (जीसीसी), 82 बाइट्स

n;f(x,y,a,b)int*x,*y;{for(n=0;a;)--b&&*x*2-*y>y[1]?++y:(++b,--a,n+=abs(*x++-*y));}

यह दो पूर्णांक सरणियों और उनकी लंबाई के रूप में इनपुट लेता है (चूंकि सी के पास उनकी लंबाई अन्यथा प्राप्त करने का कोई तरीका नहीं है)। इसे चलाने के लिए दिखाया जा सकता है O(a+b)क्योंकि लूप के प्रत्येक पुनरावृत्ति पर aया तो bघटाया जाता है, जो तब aपहुंचता है जब पहुंचता है 0(और bनीचे नहीं घटाया जा सकता है 0)।

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

n;                     // define sum as an integer
f(x,y,a,b)             // function taking two arrays and two lengths
int*x,*y;              // use k&r style definitions to shorten function declaration
{
 for(n=0;              // initialize sum to 0
 a;)                   // keep looping until x (the first array) runs out
                       // we'll decrement a/b every time we increment x/y respectively
 --b&&                 // if y has ≥1 elements left (b>1, but decrements in-place)...
 *x*2-*y>y[1]?         // ... and x - y > [next y] - x, but rearranged for brevity...
 ++y:                  // increment y (we already decremented b earlier);
 (++b,                 // otherwise, undo the in-place decrement of b from before...
 --a,n+=abs(*x++-*y))  // decrement a instead, add |x-y| to n, and then increment x
;}

कुछ नोट:

• सरणियों में अनुक्रमित करने के बजाय, संकेत को बढ़ाते हुए और dereferencing सीधे इसके लिए पर्याप्त बाइट्स बचाता है इसके लायक ( *xबनाम x[a]और y[1]बनाम y[b+1])।

• --b&&के लिए शर्त चेकों b>1एक राउंडअबाउट रास्ते में - अगर bहै 1, तो यह शून्य करने के लिए मूल्यांकन करेंगे। चूंकि यह संशोधित होता है b, इसलिए हमें इसे टर्नरी की पहली शाखा (जिसे अग्रिम y) में बदलने की आवश्यकता नहीं है, लेकिन हमें इसे दूसरी (जो अग्रिम x) में बदलने की आवश्यकता है ।

• किसी returnकथन की आवश्यकता नहीं है, क्योंकि काला जादू। (मुझे लगता है कि यह इसलिए है क्योंकि मूल्यांकन किए जाने वाले अंतिम कथन में हमेशा n+=...अभिव्यक्ति होगी, जो उसी रजिस्टर का उपयोग करता है जो रिटर्न मानों के लिए उपयोग किया जाता है।)

Answer 4

रूबी, 88 बाइट्स

->(p,q){a=q.each_cons(2).map{|a|a.sum/a.size}
x=a[0]
p.sum{|n|x=a.pop if n>x
(n-x).abs}}

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

इसके अलावा, मज़े के लिए, एक छोटा अनाम फ़ंक्शन जो जटिलता प्रतिबंधों को पूरा नहीं करता है:

->(a,b){a.map{|x|x-b.min_by{|y|(x-y).abs}}.sum}

Comments

क्या आप सरल शब्दों में समझा सकते हैं कि यह कोड कैसे काम करता है? मैं यह नहीं बता सकता कि यह रैखिक समय में चलता है या नहीं।

— अनुष

यह प्रश्न में पहले परीक्षण के मामले के साथ-साथ इनपुट जैसे कि विफल रहता है [5, 6], [0, 1, 5]।

— दरवाज़े

Answer 5

जावास्क्रिप्ट (Node.js) , 80 बाइट्स

x=>g=(y,i=0,j=0,v=x[i],d=v-y[j],t=d>y[j+1]-v)=>1/v?g(y,i+!t,j+t)+!t*(d>0?d:-d):0

• यह O (| X | + | Y | Y) में चलता है: प्रत्येक रिकर्सन O (1) में चलता है, और यह पुनरावर्ती होता है। X | + + Y बार।
  • x, yसंदर्भ द्वारा पारित किए जाते हैं, जो सामग्री की नकल नहीं करते हैं
• 1/vगलत है, अगर x[i]सीमा से बाहर है, तो सत्य है
• t-> d>y[j+1]-v-> v+v>y[j]+y[j+1]झूठी है जब तक कि निम्नलिखित शर्तें पूरी होती हैं। और जो साधन y[j]करने के लिए संख्या सबसे करीब है vमेंy
  • vसे कम है (y[j]+y[j+1])/2, या
  • y[j+1]सीमा से बाहर है, जो उपज की NaNतुलना में परिवर्तित होता है और होता NaNहैfalse
    • यही कारण है कि हम >1 और बाइट को बचाने के लिए साइन फ्लिप नहीं कर सकते हैं
• tहमेशा एक बूलियन मूल्य होता है, और गणना *करने से पहले 0/ इसे परिवर्तित करें1

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

Answer 6

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

x = {1, 5, 9};
y = {3, 4, 7};

Norm[Flatten[Nearest[y] /@ x] - x]

यदि आपको इनपुट के साथ एक पूरा कार्यक्रम बनाना है, तो:

f[x_,y_]:= Norm[Flatten[Nearest[y] /@ x] - x]

यहां 1,000,000 अंकों तक का समय दिया गया है (प्रत्येक 10,000 का नमूना) y:

रैखिक के करीब।

Comments

यह उत्तर कोड-स्निपेट है क्योंकि आपके इनपुट को पहले से मौजूद चर के रूप में लिया गया है। आप इसे या तो एक उप-दिनचर्या या पूर्ण कार्यक्रम होना चाहिए।

— तदर्थ गार्फ हंटर

मुझे यह भी संदेह है कि यह रैखिक समय में काम करता है, क्या आपके पास इसका कोई औचित्य है कि यह क्यों होना चाहिए? Mathematica इसकी निर्मिति की जटिलता में बल्कि अपारदर्शी हो जाता है।

— तदर्थ गार्फ हंटर