पुल और मशाल की समस्या

Question

इस कोड गोल्फ पहेली की प्रेरणा ब्रिज और टॉर्च की समस्या है , जिसमें एक पुल की शुरुआत में घ लोग को कम से कम समय में इसे पार करना होगा।

पकड़ यह है कि ज्यादातर दो लोग एक साथ पार कर सकते हैं, अन्यथा पुल उनके वजन के नीचे कुचल जाएगा, और समूह के पास केवल एक मशाल तक पहुंच है, जिसे पुल को पार करने के लिए ले जाना चाहिए।

पूरी पहेली के प्रत्येक व्यक्ति के पास एक निर्दिष्ट समय होता है जो वे पुल पर चलने के लिए लेते हैं। यदि दो लोग एक साथ पार करते हैं, तो यह जोड़ी सबसे धीमी गति से चलती है।

ऐसे लोगों की संख्या निर्धारित नहीं है जिन्हें पुल पार करना चाहिए; आपका समाधान d के किसी भी मूल्य के लिए काम करना चाहिए ।

आपको इस समस्या के लिए मानक इनपुट का उपयोग करने की आवश्यकता नहीं है, लेकिन समस्या को समझाने के लिए, मैं स्पष्टीकरण के लिए निम्न इनपुट और आउटपुट प्रारूप का उपयोग करूंगा। पहला नंबर, d , पुल के शुरू में लोगों की संख्या है। फिर, कोड d संख्याओं के लिए स्कैन करेगा , प्रत्येक व्यक्ति की गति का प्रतिनिधित्व करेगा।

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

यहाँ कुछ इनपुट मामले और आउटपुट केस और पहले इनपुट केस के लिए स्पष्टीकरण दिए गए हैं। यह आप पर निर्भर है कि इस जानकारी से एक एल्गोरिथ्म प्राप्त करें ताकि कोड के सबसे कम बाइट्स में समस्या को हल किया जा सके।

इनपुट

4
1 2 5 8

उत्पादन

15

इस आउटपुट तक पहुंचने के लिए, लोगों को निम्नलिखित तरीके से पार करना होगा।

A and B cross forward (2 minutes)
A returns (1 minute)
C and D cross forward (8 minutes)
B returns (2 minutes)
A and B cross forward (2 minutes)

यहां आपको अपने तरीके से मार्गदर्शन करने के लिए एक और परीक्षण मामला है।

इनपुट

5
3 1 6 8 12

उत्पादन

29

नियम:

1. मान लें कि इनपुट सॉर्ट नहीं किया जाएगा, और आपको अपने दम पर ऐसा करना होगा (यदि आपको आवश्यकता है)
2. पहेली में लोगों की संख्या 4 पर निर्धारित नहीं है (एन> = 1)
3. प्रत्येक समूह और व्यक्तिगत क्रॉसिंग में एक मशाल होनी चाहिए। केवल एक मशाल है।
4. प्रत्येक समूह में अधिकतम 2 लोग ही शामिल होने चाहिए!
5. नहीं, आप पुल से नहीं कूद सकते और दूसरी तरफ तैर सकते हैं। इस तरह की कोई अन्य ट्रिक नहीं;)।

Comments

XNOR द्वारा पाया जैसा कि नीचे, जैसे परीक्षण मामलों के लिए सुनिश्चित हो 1 3 4 5, जो 14 नहीं 15. लौटना चाहिए

— gladed

1 4 5 6 7इसी तरह की समस्या है। 25 बनाम 26

— शर्लक

यह एक अजीब सवाल जैसा लगता है, लेकिन पहेली में न्यूनतम और अधिकतम लोगों की संख्या क्या है? अपने समाधानों पर काम करते समय, मैंने देखा कि वे केवल N >= 2लोगों को संभालते हैं (मतलब, अजीब तरह से पर्याप्त है कि "1 व्यक्ति को पार करने की आवश्यकता है" के तुच्छ मामले को संभालने के लिए यह अतिरिक्त काम है), इसलिए इस बिंदु पर कुछ स्पष्टीकरण महान होगा। अग्रिम में धन्यवाद।

— शर्लक

@ Sherlock9 मान लें कि आपके समाधान को N> = 1

— baseman101

परीक्षण मामलों से पता चलता है कि हम लंबाई को एक पैरामीटर के रूप में उपयोग कर सकते हैं, लेकिन क्या आप नियमों में अधिक स्पष्ट कर सकते हैं? क्या इनपुट को समय की संख्या और लोगों की संख्या होने की अनुमति है, या बस समय की अनुमति है?

— शर्लक

Answer 1

पायथन 3, 100 99 बाइट्स

एक पुनरावर्ती समाधान

f=lambda s:s[0]+s[-1]+min(2*s[1],s[0]+s[-2])+f(s[:-2])if s.sort()or 3<len(s)else sum(s[len(s)==2:])

इस पेपर के लिए @xnor को धन्यवाद

@Lirtosiast को 2 बाइट्स बचाने के लिए धन्यवाद, @movatica 1 बाइट्स को बचाने और @gladed को इंगित करता है कि मेरा पिछला समाधान काम नहीं करता है

लैम्ब्डा फ़ंक्शन में कुछ का मूल्यांकन करने के लिए निम्न चाल का उपयोग करें s.sort() or s यहां हम सॉर्ट की गणना करते हैं और परीक्षण के परिणाम को वापस करते हैंs.sort()or len(s)>3

Ungolfed

def f(s):
    s.sort()                                   # sort input in place
    if len(s)>3:                               # loop until len(s) < 3
        a = s[0]+s[-1]+min(2*s[1],s[0]+s[-2])  # minimum time according to xnor paper
        return  a + f(s[:-2])                  # recursion on remaining people
    else:
        return sum(s[len(s)==2:])              # add last times when len(s) < 3

परिणाम

>>> f([3, 1, 6, 8, 12])
29
>>> f([1, 2, 5, 8])
15
>>> f([5])
5
>>> f([1])
1
>>> f([1, 3, 4, 5])
14

Comments

आप 1 बाइट बचा सकते हैं और बदल len(s)==2सकते हैंlen(s)<3

— मिस्टर पब्लिक

@ रिपब्लिक आपको एक बग मिल जाता है, मैंने हल बदल दिया है यह बग के साथ s[0]*(len(s)==2)नहीं है कि हम धन्यवाद से क्यों नहीं बदल सकते हैं(s[0]*len(s)==2) f([1]) -> 0<3

— एरवान

इस पेपर में इष्टतम समय के लिए एक अभिव्यक्ति है जो कई संभावनाओं का मंत्री है। क्या आप सुनिश्चित हैं कि आपका समाधान सभी मामलों में इष्टतम है?

— xnor

@xnor वाह ऐसा लगता है कि मेरे पास इष्टतम समाधान है जो मैं लेम्मा 3 में अभिव्यक्ति का उपयोग करता हूंA5:22

— एरवान

आप सुझाव से @movatica अद्यतन

— एर्वान

Answer 2

अजगर 2, 119 114 112 119 110 100 100 95 बाइट्स

मुझे अपने उत्तरों को अलग करने की सलाह दी गई है।

Theorem 1, A2:09 इस पेपर xnor के उपयोग से एक समाधान जुड़ा हुआ है । कागज उद्धृत करने के लिए (इसे शून्य-अनुक्रमण में बदलना):The difference between C_{k-1} and C_k is 2*t_1 - t_0 - t_{N-2k}.

lambda n,t:t.sort()or(n-3)*t[0]*(n>1)+sum(t)+sum(min(0,2*t[1]-t[0]-t[~k*2])for k in range(n/2))

Ungolfing:

def b(n, t): # using length as an argument
    t.sort()
    z = sum(t) + (n-3) * t[0] * (n>1) # just sum(t) == t[0] if len(t) == 1
    for k in range(n/2):
        z += min(0, 2*t[1] - t[0] - t[-(k+1)*2]) # ~k == -(k+1)
    return z

Comments

क्या आप सुनिश्चित हैं कि हम मान सकते हैं कि लंबाई एक तर्क हो सकती है?

— एरवान

@ इरावन उदाहरण के मामले इसकी अनुमति देते प्रतीत होते हैं। मैं पूछता हूँ

— शर्लक

Answer 3

रूबी, 94 133 97 96 101 96 99 बाइट्स

मुझे अपने उत्तरों को अलग करने की सलाह दी गई है।

यह एक समाधान एल्गोरिथ्म में वर्णित पर आधारित है A6:06-10के पुल और मशाल समस्या पर इस पत्र ।

संपादित करें: एक बग को ठीक करना जहां a=s[0]अभी तक परिभाषित नहीं है जब aअंत में कहा जाता है अगर s.size <= 3।

->s{r=0;(a,b,*c,d,e=s;r+=a+e+[b*2,a+d].min;*s,y,z=s)while s.sort![3];r+s.reduce(:+)-~s.size%2*s[0]}

Ungolfing:

def g(s)
  r = 0
  while s.sort![3]      # while s.size > 3
    a, b, *c, d, e = s  # lots of array unpacking here
    r += a + e + [b*2, a+d].min
    *s, y, z = s        # same as s=s[:-2] in Python, but using array unpacking
  end
  # returns the correct result if s.size is in [1,2,3]
  return r + s.reduce(:+) - (s.size+1)%2 * s[0]
end

Answer 4

स्काला, 113 135 (darnit)

def f(a:Seq[Int]):Int={val(s,b)=a.size->a.sorted;if(s<4)a.sum-(s+1)%2*b(0)else b(0)+Math.min(2*b(1),b(0)+b(s-2))+b(s-1)+f(b.take(s-2))}

कुछ हद तक अनगढ़

def f(a:Seq[Int]):Int = {
    val(s,b)=a.size->a.sorted      // Sort and size
    if (s<4) a.sum-(s+1)%2*b(0)    // Send the rest for cases 1-3
    else Math.min(b(0)+2*b(1)+b(s-1),2*b(0)+b(s-2)+b(s-1)) + // Yeah.
        f(b.take(s-2))             // Repeat w/o 2 worst
}

परीक्षक:

val tests = Seq(Seq(9)->9, Seq(1,2,5,8)->15, Seq(1,3,4,5)->14, Seq(3,1,6,8,12)->29, Seq(1,5,1,1)->9, Seq(1,2,3,4,5,6)->22, Seq(1,2,3)->6, Seq(1,2,3,4,5,6,7)->28)
println("Failures: " + tests.filterNot(t=>f(t._1)==t._2).map(t=>t._1.toString + " returns " + f(t._1) + " not " + t._2).mkString(", "))

सामान्य रूप से महान नहीं है, लेकिन शायद एक जोरदार टाइप की हुई भाषा के लिए बुरा नहीं है। और एक मामला सामने न आने के लिए xnor को धन्यवाद देना।

Comments

इस पेपर में इष्टतम समय के लिए एक अभिव्यक्ति है जो कई संभावनाओं का मंत्री है। क्या आप सुनिश्चित हैं कि आपका समाधान सभी मामलों में इष्टतम है?

— xnor

Answer 5

रूबी, 104 95 93 बाइट्स

मुझे अपने उत्तरों को अलग करने की सलाह दी गई है।

यह एक समाधान पर आधारित है मेरी अजगर 2 समाधान और Theorem 1, A2:09का पुल और मशाल समस्या पर इस पत्र ।

->n,t{z=t.sort!.reduce(:+)+t[0]*(n>1?n-3:0);(n/2).times{|k|z+=[0,2*t[1]-t[0]-t[~k*2]].min};z}

Ungolfing:

def b(n, t) # using length as an argument
  z = t.sort!.reduce(:+) + t[0] * (n>1 ? n-3 : 0)
  (n/2).times do each |k|
    a = t[1]*2 - t[0] - t[-(k+1)*2] # ~k == -(k+1)
    z += [0, a].min
  end
  return z
end