एक अच्छा समय मना करने के लिए

स्थापित करना

मान लीजिए आप दिया जाता है n फ़्यूज़, 1 के साथ ≤ n ≤ 5, जिनमें से प्रत्येक एक मीटर लंबा है, और जहां प्रत्येक फ्यूज के एक संबद्ध दर जला है एन प्रति मीटर की दूरी पर डी घंटे।

फ्यूज को एक या दोनों सिरों पर जलाया जा सकता है, बाद में एक या दोनों सिरों पर बुझा दिया जाता है, फिर से बुझाया जाता है, आदि, जब तक कि फ्यूज पूरी तरह से भस्म नहीं हो जाता है। आप फ़्यूज़ को तुरंत प्रकाश और बुझाने में सक्षम हैं, और आप देख सकते हैं कि सटीक फ़्यूज़ पूरी तरह से भस्म हो गया (जला हुआ)।

फ्यूज को न तो काटा जा सकता है और न ही इसके सिरों को छोड़कर कहीं भी जलाया जा सकता है।

इस तरह के एक सेटअप किसी भी दो फ्यूज प्रकाश / खपत की घटनाओं के बीच समय को मापने के द्वारा, एक सटीक रूप से सटीक समय प्रणाली के लिए अनुमति देता है। उदाहरण के लिए, 1 मीटर प्रति घंटे की दर से दो फ़्यूज़ दिए गए हैं, आप बिल्कुल 45 मिनट (3/4 घंटे) माप सकते हैं

एक साथ: दोनों सिरों पर पहले फ्यूज को रोशन करना, एक छोर पर दूसरे फ्यूज को रोशन करना, और अपने समय अंतराल की शुरुआत को चिह्नित करना
पहले फ्यूज के दूसरे फ्यूज के दूसरे सिरे को रोशन करना पहले फ्यूज की खपत होती है (30 मिनट बाद)
दूसरे फ़्यूज़ के तुरंत बाद अपने समय अंतराल के अंत को चिह्नित किया जाता है (15 मिनट बाद)

चुनौती

घंटे t के एक भिन्नात्मक संख्या को देखते हुए , और n फ़्यूज़ की सटीक बर्न दरों का प्रतिनिधित्व करने वाले n भिन्न का एक सेट , एक प्रोग्राम या फ़ंक्शन लिखता है जो एक सत्य मान देता है यदि t घंटे को फ़्यूज़ के व्यवस्थित जलने, या एक मानक के माध्यम से ठीक से मापा जा सकता है मिथ्या मूल्य अन्यथा।

कार्यक्रम का इनपुट निम्नलिखित में से कोई भी हो सकता है:

प्रपत्र के कमांड-लाइन तर्क TN/TD N1/D1 N2/D2 N3/D3 ...
प्रपत्र के एक स्ट्रिंग TN/TD N1/D1 N2/D2 N3/D3 ...से पढ़ने के stdinबराबर या
प्रपत्र का एक स्ट्रिंग TN/TD N1/D1 N2/D2 N3/D3 ...एक फ़ंक्शन तर्क के रूप में पारित हुआ
स्ट्रिंग का एक सरणी ["TN/TD", "N1/D1", "N2/D2", "N3/D3", ...]एक फ़ंक्शन तर्क के रूप में पारित हुआ

सभी मामलों में टी = TN/ TD, जहां TN, TDcases [1,10000]।

इसी तरह, सभी मामलों में: फ्यूज i = N _i / D _i = N<i>/ के लिए बर्न रेट D<i>, जहां N<i>, D<i>∈ [1,10] all i ।

आप मान सकते हैं कि हमेशा 1 और 5 फ़्यूज़ (सम्मिलित) के बीच होगा, और सभी इनपुट मान्य और इन-रेंज हैं। आप यह भी मान सकते हैं कि सभी इनपुट अंश सबसे कम शब्दों में दिए गए हैं।

आप इस चुनौती के लिए आंशिक घटकों के साथ फ्लोटिंग पॉइंट नंबरों का उपयोग नहीं कर सकते हैं। यही है, यदि आप अपने आवेदन में कहीं भी फ्लोटिंग पॉइंट नंबरों का उपयोग करते हैं, तो वे केवल शून्य भिन्नात्मक घटक के साथ अभिन्न मान ले सकते हैं।

स्कोरिंग

यह एक कोड-गोल्फ चुनौती है, इसलिए बाइट्स में सबसे कम अनुपालन प्रस्तुत करने वाले को जीत से सम्मानित किया जाएगा।

उदाहरण इनपुट / आउटपुट

input:  29/6 3/2 2/3 3/5 3/7 7/5
output: true

One solution:
  - light both ends of fuse 1, mark start of interval
  - on fuse 1 consumption: light both ends of fuse 2, light one end of fuse 5
  - on fuse 5 consumption: extinguish one end of fuse 2, light both ends of fuse 3,
    light both ends of fuse 4
  - on fuse 2 consumption: extinguish one end of fuse 3, extinguish both ends of
    fuse 4
  - on fuse 3 consumption: relight one end of fuse 4
  - on consumption of fuse 4: mark end of interval (29/6 hours)

input:  2/1 3/1 5/1 7/1
output: false

input:  5/1 6/1 1/6 9/1 1/9
output: true

One solution:
  - light fuse 1 at one end, light fuse 2 at both ends, light fuse 4 at both ends
  - on fuse 1 consumption: extinguish one end of fuse 2, mark start of interval
  - on fuse 4 consumption: relight one end of fuse 2
  - on fuse 2 consumption: mark end of interval (5 hours)

हैप्पी फ्यूज़िंग! :)

code-golf puzzle-solver rational-numbers

— COTO
स्रोत

@ MartinBüttner मुझे लगता है कि यह फ्लोटिंग पॉइंट नंबर प्रतिबंध होगा।

— hmatt1

@ मार्टिनबटनर मैं मानता हूं कि यह स्रोत कोड पर प्रतिबंध नहीं है। मुझे नहीं लगता कि [प्रतिबंधित-स्रोत] इस सवाल पर फिट बैठता है क्योंकि यह वर्तमान में खड़ा है।

— hmatt1

@chilemagic: मैं इस तथ्य पर ध्यान आकर्षित करना चाहता था कि फ्लोटिंग पॉइंट लॉजिक का उपयोग नहीं किया जा सकता है, लेकिन यदि सर्वसम्मति यह है कि यह टैग का उचित उपयोग नहीं है, तो मैं इसे पट्टी करूँगा।

— सीओटीओ

परीक्षण के मामले बहुत बड़े हैं :)

— feersum

लोल, मैं गोल्फ उद्देश्यों के लिए एक O ((n!) ^ 3) एल्गोरिदम का उपयोग कर रहा हूं।

— feersum

जवाबों:

अजगर 2, 305

यह गोल्फ वाला संस्करण है। यह n> 3 के लिए व्यावहारिक रूप से अनुपयोगी है , क्योंकि समय (और स्थान) जटिलता 3 ^{n ^{2 की}} तरह है ... वास्तव में यह समय के लिए बहुत कम हो सकता है। वैसे भी, फ़ंक्शन स्ट्रिंग्स की एक सूची को स्वीकार करता है।

def f(i):
 Z=range;r=map(__import__('fractions').Fraction,i);R=r[1:];n=len(R);L=[[[1]*n,[0]]];g=0
 for m,p in L: 
  for d in([v/3**i%3for i in Z(n)]for v in Z(3**n)):
    try:x=min(m[i]/R[i]/d[i]for i in Z(n)if m[i]*d[i]>0);L+=[[[m[i]-x*R[i]*d[i]for i in Z(n)],[p[0]+x]+p]]
    except:g|=p[0]-r[0]in p
 return g

एक थोड़ा अनुकूलित संस्करण कुछ ही मिनटों में परीक्षण के मामलों को समाप्त कर सकता है। यह अभी भी एक असंभव n = 5 मामले के लिए धीमा हो सकता है ।

def fLessslow(i):
 Z=range
 r=map(__import__('fractions').Fraction,i)
 R=r[1:]
 n=len(R)
 L=[((1,)*n,(0,))]
 ls = set(L)
 for m,p in L: 
  if p[0]-r[0]in p: return 1
  for d in([v/3**i%3 for i in Z(n)]for v in Z(3**n)):
   if any(d[i] and m[i]<=0 for i in Z(n)):continue
   try:
    x=min(m[i]/R[i]/d[i]for i in Z(n)if m[i]*d[i]>0)
    thing = (tuple(m[i]-x*R[i]*d[i]for i in Z(n)),(p[0]+x,)+p)
    if thing not in ls:L+=[thing];ls.add(thing)
   except:5
 return 0

print fLessslow('5/1 6/1 1/6 9/1 1/9'.split())
print fLessslow('29/6 3/2 2/3 3/5 3/7 7/5'.split())

— feersum
स्रोत

एक छोटी गाड़ी कोड के लिए 8 अपवोट्स: विवरण में उदाहरण के साथ फ़ंक्शन को कॉल करना: प्रिंट एफ ('3/4 1/1 1 / 1'.split ()) 0 देता है, हालांकि जैसा कि विवरण कहता है, यह हल करने योग्य है ।

— जकूबे

@ जाकुब परीक्षण के लिए धन्यवाद ... यह इस साइट पर बहुत कम है! यह अब तय हो गया है; मैं 1 या 2 के कारक से विभाजित करने के लिए एक जगह में भूल गया कि रस्सी के कितने छोर जलाए जाते हैं।

— feersum

अजगर 2, 331

यह feersum के संस्करण की तुलना में थोड़ा लंबा है, लेकिन यह बहुत तेज़ है। सभी टेस्टकेस एक साथ मेरे लैपटॉप पर लगभग 3 सेकंड लगते हैं। N = 5 के लिए एक पूर्ण खोज हालांकि 10 मिनट से अधिक समय लेती है। कोड में से कुछ feersum के संस्करण के समान है, लेकिन मैंने जानबूझकर किसी भी कोड को कॉपी नहीं किया है।

from fractions import*
f=Fraction
r=range
g=lambda x:h(f(x[0]),[1/f(i)for i in x[1:]],[])
def h(t,x,y):
 for i in r(1,3**len(x)):
  c=[[],[],[]]
  for j in r(len(x)):c[i/3**j%3]+=[x[j]]
  n,b,w=c
  m=min(b+[i/2 for i in w])
  if h(t,[i for i in n+[j-m for j in b]+[j-2*m for j in w]if i],[i+m for i in y]+[m]):return True
 return t in y

उपयोग:

print g('3/4 1/1 1/1'.split())
print g('29/6 3/2 2/3 3/5 3/7 7/5'.split())
print g('2/1 3/1 5/1 7/1'.split())
print g('5/1 6/1 1/6 9/1 1/9'.split())

स्पष्टीकरण:

लैम्ब्डा एक्सप्रेशन जी इनपुट के कुछ प्रीप्रोसेसिंग करता है, जैसे स्ट्रिंग्स को अंशों में बदलना, बर्न रेट्स से लक्ष्य समय को अलग करना और बर्न टाइम (= 1 / बर्न रेट) की गणना करना।

फ़ंक्शन h सभी बर्न बार x को 3 सेट n, b और w (non_burning के लिए n स्टैंड, b____bing के लिए, और w_end_burning के लिए) में विभाजित करता है। यह उन सभी व्यवस्थाओं पर निर्भर करता है (व्यवस्था n = x, b = [], w = [] को छोड़कर), फ्यूज को सबसे कम बर्न रेट (m में समय बचाना) के साथ निर्धारित करता है, और पुन: अद्यतन बर्न समय के साथ h कॉल करता है। Y में मैं हर संभव समय को बचाता हूं जो कोई फ़्यूज़ का उपयोग करके माप सकता है। पुनरावर्ती कॉल में ये मान भी अपडेट हो जाते हैं।

जैसे ही मुझे मूल्य मिलता है, यह ट्रू के साथ कॉल को समाप्त कर देता है।

— Jakube
स्रोत

आप युवा पायथन प्रोग्रामर आपके सभी अंतर्निहित भिन्नों और बड़े पूर्णांक के साथ खराब हो जाते हैं। वापस जब मैं एक young'un था, सब हम था 1की और 0की है, जो हम एक मॉनिटर के बिना एक कंसोल पर एक पर एक समय में टाइप करने के लिए किया था। कभी-कभी हमारे पास नहीं थे 1।

— COTO