स्टिक को पेंट करने में कितना समय लगता है?

Question

( इस Math.SE समस्या के आधार पर , जो कुछ ग्राफिक्स भी प्रदान करता है)

मेरे पास एक छड़ी है जो इस तरह थोड़े दिखती है:

मैं इसे इस तरह थोड़े देखना चाहता हूं:

हालांकि, मैं एक विशेषज्ञ चित्रकार नहीं हूं, इसलिए इससे पहले कि मैं इस तरह की महत्वाकांक्षी DIY परियोजना शुरू करूं, मैं यह सुनिश्चित करना चाहता हूं कि मैं अपने सिर के ऊपर नहीं हूं।

आपके कार्यक्रम को यह बताना चाहिए कि इस छड़ी को बनाने में कितने कदम शामिल हैं। प्रत्येक चरण में एक ठोस रंग के साथ एक निरंतर क्षेत्र को चित्रित करना शामिल है, जो पेंट की पिछली परतों को कवर करता है। उपरोक्त उदाहरण के लिए, मैं बाएं आधे नीले, दाहिने आधे लाल, और फिर कुल 4 चरणों के लिए दो अलग-अलग हरे क्षेत्रों को चित्रित कर सकता था (हरा लगातार चित्रित नहीं है)।

यहाँ यह ASCII में है:

------
bbb---
bbbrrr
bgbrrr
bgbrgr

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

लक्ष्य

आपके कार्यक्रम को दिए गए रंग योजना के साथ छड़ी को चित्रित करने के लिए आवश्यक न्यूनतम चरणों का उत्पादन करना चाहिए। पेंट योजना पात्रों के एक स्ट्रिंग के रूप में होगी, जबकि आउटपुट एक संख्या होगी। यह कोड गोल्फ है। सबसे छोटा कार्यक्रम जीतता है।

इनपुट

आपके कार्यक्रम को पत्रों की एक स्ट्रिंग के रूप में एक छड़ी के लिए रंग योजना प्राप्त होगी। प्रत्येक अद्वितीय अक्षर (केस संवेदी) एक अद्वितीय रंग का प्रतिनिधित्व करता है।

YRYGR

grG

GyRyGyG

pbgbrgrp

hyghgy

उत्पादन

ये संख्या लाठी को चित्रित करने के लिए आवश्यक कदमों की सबसे कम संख्या है।

4

3

4

5

4

स्पष्टीकरण

यह है कि मैं उपरोक्त संख्याओं पर कैसे पहुंचा। आपके प्रोग्राम को इसे आउटपुट करने की आवश्यकता नहीं है:

 -----
 YYY--
 YRY--
 YRYG-
 YRYGR

 ---
 g--
 gr-
 grG

 -------
 GGGGGGG
 GyyyGGG
 GyRyGGG
 GyRyGyG

 --------
 pppppppp
 pbbbpppp
 pbbbrrrp
 pbgbrrrp
 pbgbrgrp

 ------
 -yyyyy
 -ygggy
 hygggy
 hyghgy

संपादित करें: यदि वे अधिक कठिन परीक्षण मामले साबित होते हैं तो मैं और अधिक परीक्षण मामले जोड़ूंगा।

Comments

यह मुझे stackoverflow.com/q/10364248/785745 की याद दिलाता है , जो समान है, लेकिन 2D में है।

— केंडल फ्रे

Answer 1

गोल्फस्क्रिप्ट, 82 72 67 अक्षर

.,n*{:c,,{[).2$1<*\c>+1$.,,{).2$<\3$<=},,.@>@@>]}%\;{~S)}%$0+0=}:S~

एक गोल्फस्क्रिप्ट कार्यक्रम के लिए यथोचित उपवास, उदाहरण:

> hyghgy
4

> pbgbrgrp
5

एल्गोरिथम का उपयोग रंगों के माध्यम से बाएं-से-दाएं पुनरावर्ती रूप से, निम्न कथनों के अनुसार किया जाता है:

• बाईं ओर से सभी भागों को अनदेखा करें जिनमें पहले से ही आवश्यक रंग है। उन्हें फिर से काबू में करने से बेहतर जवाब नहीं मिलेगा।
• यदि पूरी छड़ी में पहले से ही वांछित रंग है, तो परिणाम के रूप में 0 कदम लौटें।

• अन्यथा, अब बाएं भाग का लक्ष्य रंग लें (यानी वांछित रंग में पहला नहीं)।

  • लक्ष्य रंग और पुनरावृत्ति के साथ 1 भाग पेंट करें।
  • इस रंग के साथ 2 भागों को पेंट करें और पुनरावृत्ति करें।

  ...

  • इस रंग के साथ पूरे शेष छड़ी को पेंट करें और फिर से डालें।

  उन सभी नंबरों का न्यूनतम ले लो और 1 (वर्तमान चरण के लिए) जोड़ें। चरणों की इष्टतम संख्या के रूप में इसे वापस करें।

यह एल्गोरिथ्म काम करता है, क्योंकि सबसे बाएं हिस्से को किसी भी समय चित्रित किया जाना है, इसलिए इसे तुरंत क्यों नहीं - किसी भी संभव फैशन में।

.,n*         # prepare the initial situation (target stick, unpainted stick)
             # used n instead of '-' for the unpainted parts, because it is shorter
{            # Define the operator S which does t c S -> n
             #   - t: the desired target colors
             #   - c: the stick as it is colored currently
             #   - n: minimum number of steps required to go from c to t
  :c         # Assign the current configuration to the variable c
  ,,{[       # Map the list [0 1 2 .. L-1]
             # We will build a list of all possible configurations if we paint
             # the stick with the 0th part's color (either 1 or 2 or 3 or ... parts)
    ).       # Increase the number, i.e. we paint 1, 2, 3, ... L parts, copy
    2$1<     # Take the first color of the target configuration
    *        # ...paint as many parts
    \c>+     # ...and keep the rest as with the current stick
    1$       # take the target configuration
             # Top of stack now e.g. reads
             #    h----- hyghgy (for i=0)
             #    hh---- hyghgy (for i=1)
             # Next, we strip the common leading characters from both strings:
    .,,      # Make list [0 1 2 ... L-1]
    {        # Filter {}, all the numbers for which the first j+1 parts are the same
      ).     # incr j
      2$<    # take leftmost j parts of stick A
      \3$<   # take leftmost j parts of stick B
      =      # are they equal?
    },,      # The length of the result is the number of common parts.
    .@>      # cut parts from A
    @@>      # cut parts from B
  ]}%
  \;         # Remove the target from the stack (not needed anymore)               
             # We now have a list of possible paintings where 1, 2, ..., L parts were
             # painted from the left with the same color.
             # All configurations were reduced by the common parts (they won't be
             # painted over anyways)
  {~S)}%     # Call the method S recursively on the previously prepared configurations
  $0+0=      # $0= -> sort and take first, i.e. take the minimum, 0+ is a workaround
             # if the list was empty (i.e. the operator was called with a stick of length 0).
}:S
~            # Execute S

Comments

"रंग सबसे गलत" एल्गोरिथ्म के लिए +1। हालांकि, यह n!कदम प्रतीत होता है ;) (लेकिन शायद यह वास्तविक जटिलता है, मुझे पता नहीं)।

— यो '

Answer 2

जावास्क्रिप्ट: 187 बाइट्स

मान लें कि हमें केवल फ़ंक्शन (कृपया) में इनपुट और आउटपुट की अनुमति है!

function p(w){var j,l,s=-1,i,m=i=w.length;if(m<2)return m;for(;i--;){l = 1;for(var k=-1;(j=k)!=m;){if((k=w.indexOf(w[i],++j))==-1)k=m;l+=p(w.substring(j,k));}if(s==-1||l<s)s=l;}return s;}

157 और बदसूरत अनुकूलन करके बाइट्स (जो बिंदु का हिस्सा है, और मुझे अविश्वसनीय रूप से मज़ा मिला):

function p(w){var j,l,s=-1,i,m=i=w.length;if(m<2)return m;for(;i--;s<0|l<s?s=l:1)for(l=1,j=0;~j;)l+=p(w.substring(j,(j=w.indexOf(w[i],j))<0?m:j++));return s}

135 बाइट्स मुझे एहसास हुआ कि इनपुट की लंबाई एक ऊपरी बाध्य है और मुझे अब अलग से तुच्छ मामलों को संभालने की आवश्यकता नहीं है।

function p(w){var j,l,s,i,m=s=i=w.length;for(;i--;l<s?s=l:1)for(l=1,j=0;~j;)l+=p(w.substring(j,~(j=w.indexOf(w[i],j))?j++:m));return s}

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

p("YRYGR")
4
p("grG")
3
p("GyRyGyG")
4
p("pbgbrgrp")
5
p("hyghgy")
4

विस्तारित संस्करण:

function paint(word) {
    var smallest = -1;
    if(word.length < 2) return word.length;
    for(var i = word.length; i-->0;) {
        var length = 1;
        for(var left, right = -1;(left = right) != m;) {
            if((right = word.indexOf(word[i],++left)) == -1) right = word.length;
            if(left != right) length += paint(word.substring(left , right));
        }
        if(smallest == -1 || length < smallest) smallest = l;
    }
    return smallest;
}

इनपुट के प्रत्येक वर्ण के लिए, पैटर्न की लंबाई की गणना करें यदि हम पहले उस रंग को चित्रित करते हैं। यह दिखावा करके किया जाता है कि हम उस रंग को पेंट करते हैं और फिर उप खंडों को उस रंग से नहीं बनाते हैं, और उन पर पेंट विधि को फिर से कॉल करते हैं। सबसे छोटा रास्ता वापस आ गया है।

उदाहरण ( YRYGR):

प्रारंभ में, प्रयास करें R। यह हमें उप समूह Yऔर देता है YG। Yतुच्छ रूप से एक बार में चित्रित किया गया है।

के लिए YG: कोशिश G, Yतुच्छ है, लंबाई 2। कोशिश करो Y, Gतुच्छ है, लंबाई 2. YGइसलिए लंबाई है 2।

पेंटिंग Rपहले इसलिए हमें देता है1 + 1 + 2 = 4

फिर प्रयास करें G। यह हमें उप समूह YRYऔर देता है R। Rतुच्छ है।

के लिए YRY:

कोशिश Y: Rतुच्छ है, लंबाई 2। कोशिश करो R: Yऔर Yदो समूह हैं, लंबाई 3।

YRYलंबाई है 2।

पेंटिंग Gपहले देती है1 + 1 + 2 = 4

फिर प्रयास करें Y। यह उप समूहों Rऔर देता है GR। Rतुच्छ, GRलंबाई है 2। Yलंबाई है4

यह कार्यान्वयन कोड लंबाई को कम करने के लिए फिर से R और Y की जाँच करेगा। YRYGRइसलिए इसका परिणाम है 4।

Comments

मुझे लगता है कि आपके विस्तारित संस्करण ने संस्करण को mकहीं खो दिया है।

— ११:५ast पर हस्त्कर्ण

दुर्भाग्य से, आपके संस्करण भी इनपुट के लिए सही परिणाम नहीं देते हैं "abcacba"।

— हावर्ड

@ हस्तूरकुन के mलिए सिर्फ शॉर्टहैंड था word.length:) @ आप सही हैं, मुझे इस पर फिर से विचार करना होगा।

— मेयोनेज़ोम

Answer 3

पायथन, 149 चार्ट

D=lambda s:0 if s=='?'*len(s)else min(1+D(s[:i]+'?'*(j-i)+s[j:])for i in range(len(s))for j in range(i+1,len(s)+1)if set(s[i:j])-set('?')==set(s[i]))

मैं ?एक ऐसे क्षेत्र को चिह्नित करने के लिए उपयोग करता हूं जो किसी भी रंग का हो सकता है। Dछड़ी के एक सन्निहित क्षेत्र को चुनता है जिसमें केवल एक ही रंग होता है (साथ ही शायद कुछ ?एस), रंग जो उस क्षेत्र में अंतिम होते हैं, उस क्षेत्र को ?एस के साथ बदल देते हैं , और पिछले सभी चरणों को खोजने के लिए पुनरावर्ती करते हैं।

घातीय समय चल रहा है। उचित समय (कुछ मिनटों) में उदाहरणों को करने के लिए बस मुश्किल से पर्याप्त उपवास। मैंने संस्मरण के साथ शर्त लगाई कि यह बहुत तेज़ हो सकता है।

Answer 4

पायथन 3 - 122

def r(s,a):c=s[0];z=c in a;return s[1:]and min([1+r(s[1:],a+c)]+[r(s[1:],a[:a.rfind(c)+1])]*z)or(1-z)
print(r(input(),''))

यह काम करने लगता है, लेकिन मुझे अभी भी 100% यकीन नहीं है कि यह विधि हमेशा न्यूनतम संख्या में कदम उठाएगी।

Answer 5

कॉफीस्क्रिप्ट - 183 247 224 215 207

x=(s,c='')->return 0if !s[0]?;return x s[1..],c if s[0]is c;l=s.length;return x s[1...l],c if s[l-1]is c;i=s.lastIndexOf s[0];1+(x s[1...i],s[0])+x s[i+1..],c
y=(z)->z=z.split "";Math.min (x z),x z.reverse()

JSFiddle.net पर डेमो

डिबग कोड और टिप्पणियों सहित अनप्लग्ड संस्करण:

paintSubstring = (substring, color = '####') ->
  console.log 'Substring and color', substring, color, substring[0]
  # no need to color here
  if !substring[0]?
    return 0
  # no need to recolor the first part
  if substring[0] is color
    return paintSubstring (substring[1..]), color
  l = substring.length
  # no need to recolor the last part
  if substring[l-1] is color
    return paintSubstring substring[0...l], color
  # cover as much as possible
  index = substring.lastIndexOf substring[0]
  part1 = substring[1...index]
  part2 = substring[index+1..]
  console.log 'Part 1:', part1
  console.log 'Part 2:', part2
  # color the rest of the first half
  p1 = paintSubstring part1, substring[0]
  # color the rest of the second half, note that the color did not change!
  p2 = paintSubstring part2, color
  # sum up the cost of the substick + this color action
  return p1+p2+1
paintSubstringX=(x)->Math.min (paintSubstring x.split("")), paintSubstring x.split("").reverse()
console.clear()
input = """YRYGR
grG
GyRyGyG
pbgbrgrp
aaaaaaaa
hyghgy""".split /\n/
for stick in input
  console.log paintSubstringX stick

Comments

के लिए एक गलत परिणाम वापस करने के लिए प्रकट होता है hyghgy। यह 5 कहता है, लेकिन यह 4 होना चाहिए (हालांकि, यह 4 के लिए सही परिणाम लौटाता है hyghgyh)।

— PhiNotPi

@PhiNotPi भगवान, इसने मुझे 60 से अधिक पात्रों को पीछे धकेल दिया :( झपकी लेने के बाद, इसे दूसरी भाषा में फिर से लागू करने की कोशिश कर रहा है।

— तिमुल्लल्ला

Answer 6

हास्केल, 143 वर्ण

f s=g(r n ' ')0where{r=replicate;n=length s;g p l=minimum$n:[0|p==s]++[1+g(take i p++r(j-i)(s!!i)++drop j p)(l+1)|l<n,i<-[0..n-1],j<-[i+1..n]]}

यह स्ट्रिंग की लंबाई तक सभी संभव पुनर्लेखन की कोशिश करता है, और तब तक चला जाता है जब तक कि यह एक ऐसा न मिल जाए जो इनपुट पैटर्न का निर्माण करता है। कहने की आवश्यकता नहीं है, घातीय समय (और फिर कुछ)।

Answer 7

एक सरल चौड़ाई पहले खोज। यह कतार पर कुछ भी नहीं डालता है जो पहले से ही देखा गया है। यह सभी उदाहरणों के लिए एक सेकंड के तहत काम करता है लेकिन 'pbgbrgrp' जो वास्तव में पूरा मिनट लेता है :(

अब जब मेरे पास कुछ है जो काम करता है तो मैं तेजी से और कम कुछ खोजने पर काम करूंगा।

अजगर - 300 296

def f(c):
 k=len(c);q=['0'*99];m={};m[q[0]]=1
 while q:
  u=q.pop(0)
  for x in ['0'*j+h*i+'0'*(k-j-i) for h in set(c) for j in range(1+k) for i in range(1,1+k-j)]:
   n=''.join([r if r!='0' else l for l,r in zip(u,x)])
   if n == c:
     return m[u]
   if not n in m:
    m[n]=m[u]+1;q.append(n)

Comments

क्या आप कृपया इंडेंटेशन की जांच कर सकते हैं? लगता है टूट गया होगा।

— हावर्ड

@ हावर्ड तय मुझे नहीं पता कि कल रात मैं क्या सोच रहा था।

— ट्रेवरएम

Answer 8

हास्केल, 118 86 वर्ण

p""=0
p(a:s)=1+minimum(map(sum.map p.words)$sequence$map(a%)s)
a%b|a==b=b:" "|1<3=[b]

टेस्ट रन:

λ: p "YRYGR"
4

λ: p "grG"
3

λ: p "GyRyGyG"
4

λ: p "pbgbrgrp"
5

λ: p "hyghgy"
4

λ: p "abcacba"
4

यह विधि भी वह सब अक्षम नहीं है!