एक निश्चित संख्या के लिए एक काउंटर को आगे बढ़ाने का सबसे छोटा तरीका खोजें

Question

मेरे पास एक काउंटर है। यह एक छोटा उपकरण है जो इस तरह दिखता है:

डिस्प्ले से जाता 0000है 9999। इसके शीर्ष पर थोड़ा पुश-बटन है जो गिनती को 1 से बढ़ाता है, और दाईं ओर थोड़ा घुंडी जिसका उद्देश्य काउंटर को 0 पर रीसेट करना है।

अब, छोटी घुंडी के बारे में बात यह है कि यदि आप इसे पीछे की ओर मोड़ते हैं, तो आप इसे किसी भी अंक को बढ़ा सकते हैं जिसे आप एक बार फिर से चालू करना चाहते हैं। इसलिए यदि मैं काउंटर बटन को 10 बार धक्का देता हूं ताकि काउंटर दिखाता है 0010, मैं तब तक नॉब को पीछे की ओर मोड़ सकता हूं जब तक कि मैं एक छोटा क्लिक नहीं सुनता हूं, फिर इसे फिर से चालू करें और इसे सीधे जाएं 0090।

लेकिन, घुंडी हमेशा एक ही अंक की सभी घटनाओं को 1 से बढ़ाएगी हर बार यह संख्या को आगे बढ़ाता है। इसलिए यदि काउंटर दिखाता है 6060, तो आप केवल इसे बढ़ा सकते हैं 7070, 6070या नहीं 7060। इसके अलावा, घुंडी शुरू करेगी 9रों से अधिक करने के लिए 0ले जाने के बिना, इसलिए 0990करने के लिए आगे बढ़ाएंगे 0000के बजाय 1000या 1100।

---

मैं एक निश्चित संख्या के लिए काउंटर सेट करने का सबसे कुशल तरीका जानना चाहता हूं। आपका कार्य एक प्रोग्राम या फ़ंक्शन लिखना है जो बटन पुश के सबसे कम अनुक्रम को निर्धारित करेगा और ऐसा करने के लिए आवश्यक घुंडी प्रगति करेगा।

आपका कार्यक्रम इनपुट के रूप में से एक 4 अंकों की संख्या ले जाएगा 0000करने के लिए 9999, और निम्न प्रारूप में चरणों की एक श्रृंखला वापसी:

> 0001
C
> 0093
C12345678C12345678CCC
> 1000
C12345678C12345678C12345678C12345678C12345678C12345678C12345678C
> 9999
012345678

जहाँ C"काउंटर बटन को पुश" करने के लिए और D0 से 9 तक के किसी भी अंक के लिए खड़ा है "के सभी घटनाओं को आगे बढ़ाने के लिए घुंडी का उपयोग करें।"D "1 के ।

आपके कार्यक्रम में सभी संभावित चार-अंकीय संयोजनों के लिए चरणों का एक मान्य अनुक्रम होना चाहिए, और सभी 10,000 मामलों के लिए आवश्यक चरणों की कुल संख्या से स्कोर किया जाएगा। एक टाई के मामले में (इष्टतम एल्गोरिथ्म पाए जाने पर सबसे अधिक संभावना है), कम कोड जीत जाएगा।

Comments

यदि आप घुंडी को आगे बढ़ाते हैं तो क्या होता है? यह हो जाएगा 0010में 0020उस मामले में? या आप केवल घुंडी को पीछे की ओर मोड़ सकते हैं? और यह भी, प्रत्येक "डी" की गिनती घुंडी की उन्नति के "डी" संख्या के रूप में होती है (उदाहरण के लिए, करता है1234567 मतलब है कि घुंडी को 1 बार, फिर 2 बार, फिर 3 बार, इतनी आगे की तरफ मोड़ें)? या क्या यह सिर्फ प्रत्येक अलग घुंडी बारी का संकेत देता है (उदाहरण के लिए, इसका 1234567मतलब सिर्फ घुंडी को 7 बार मोड़ना है)?

— आर। काप

ऊपर और नीचे जैसा दिखता है, असंबंधित हैं।

— लीक नून

घुंडी नीचे में भी अंकों का चयन कर सकती है।

— लीक नून

नॉब को आगे की ओर मोड़ना या तो 0010 से 0020 या 1111 पर आगे बढ़ेगा, स्थिति के आधार पर नॉब पहले से ही है। आप अपनी स्थिति निर्धारित करने के लिए नॉब को पीछे की ओर मोड़ते हैं, और फिर अंकों को आगे बढ़ाने के लिए आगे बढ़ते हैं।

— जो Z.

सच में, इस आदमी को सही मूल्य पर अपने काउंटर की आवश्यकता है !!!! अभी!!!

— कैलक्यूलेटरफलीन

Answer 1

लुआ, 327763 चरण (इष्टतम, 276 बाइट्स)

गोल्फ संस्करण:

a={[0]=""}t=tonumber for i=0,52 do A={}for k,v in pairs(a)do A[k]=v L=("%04d"):format(k)for i=1,4 do c=L:sub(i,i)d=L:gsub(c,(t(c)+1)%10)e=a[t(d)]A[d]=(not e or #e>#v)and v..c or e end b=k+1 if k<9999then e=a[b]A[b]=(not e or #e>#v)and v.."C"or e end end a=A endprint(a[(...)])

प्रश्न में उदाहरणों का बेहतर संस्करण (केवल 1000सुधार हुआ है):

0001:C
0093:CCCCCCCCCC12345678CCC
1000:0CCCCCCCCCCC2345678C23456789
     (0000>1111>1122>1199>1200>1000)
9999:012345678

Ungolfed संस्करण:

a = {[0]=""}
for i=0,52 do
    A = {}
    for k,v in pairs(a) do
        A[k] = v
        L=("%04d"):format(k)
        for i=1,4 do
           c=L:sub(i,i)
           d=L:gsub(c,(tonumber(c)+1)%10)
           e=a[tonumber(d)]
           A[d] = (not e or #e > #v) and v..c or e
        end
        b=k+1
        if k < 9999 then
            e=a[b]
            A[b] = (not e or #e > #v) and v.."C" or e
        end
    end
    a=A
end
print(a[93],a[1000],a[9999])

Answer 2

गणितज्ञ, स्कोर 512710

Unprotect[StringRepeat]
StringRepeat[x_String, 0]:=""
Protect[StringRepeat]
#<>StringRepeat["C",#3-#2*1111]&[Array[ToString@#&,#,0],##]&[If[#<10^3,0,Quotient[#,1111]],#]&

बग को ठीक StringRepeatकरता है (इसके लिए गलत व्यवहार करता है StringRepeat[x_String,0])

Comments

क्या इसमें जगह होने की जरूरत है StringRepeat[x_String, 0]:=""?

— बिल्ली

नहीं, लेकिन मैं इसे हटाने के लिए बहुत आलसी था। क्या यही समस्या है?

— कैलक्यूलेटरफ़लाइन

बिल्कुल नहीं: पी यह सिर्फ मेरे लिए उत्सुक है कि कोड के बाकी के लिए छोड़कर golfed है था एक खाली स्थान के।

— बिल्ली

... कि है golfed, है ना? या गणितज्ञ नई लाइन शोर है?

— बिल्ली

@cat यह कोड-गोल्फ नहीं है

— 0

Answer 3

पायथ, 327763 चरण (इष्टतम, 130 बाइट्स)

के बाद से ऑनलाइन संकलक इस तरह के भारी काम के साथ काम पर अयोग्य है, मैं इसे कम काम दे दिया है, इतना है कि यह केवल उत्पन्न करता है 0, 1और 1111। हालांकि, यह सैद्धांतिक रूप से समस्या को हल कर सकता है, क्योंकि यह शीर्ष पर Lua के समान एल्गोरिथ्म का उपयोग करता है।

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

=Y.d((0k;V53=ZYFGY XZG=k@YG=N%"%04d"GV4=b@NH=di:Nb%"%d"ehibTT XZd.x?>l@Ydlk+kb@Yd+kb)=bhGI<G9999 XZb.x?>l@Yblk+k\C@Yb+k\C))=YZ;@YQ

---

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

=Y.d((0k;V53=ZYFGY XZG=k@YG=N%"%04d"GV4=b@NH=di:Nb%"%d"ehibTT XZd.x?>l@Ydlk+kb@Yd+kb)=bhGI<G9999 XZb.x?>l@Yblk+k\C@Yb+k\C))=YZ)@YQ
                  assign_copy('Q',eval_input())
=Y.d((0k;         assign_copy('Y',dict(0=k))
V53               for N in range(0,53):
=ZY                   assign_copy('Z',Y)
FGY                   for G in num_to_range(Y):
 XZG=k@YG                 no_print(Z[G] = assign_copy('k',lookup(Y,G)))
=N%"%04d"G                assign_copy('N',format("%04d",G))
V4                        for H in range(0,4):
=b@NH                         assign_copy('b',lookup(N,H))
=di:Nb%"%d"ehibTT             assign_copy('d',base(replace(N,b,format("%d",mod10(increment(base(b,10))))),10))
 XZd.x?>l@Ydlk+kb@Yd+kb       no_print(Z[d]=try_and_catch(greater_than(Plen(lookup(Y,d)),Plen(k)) ? concat(k,b) : lookup(Y,d)), lambda:plus(k,b))
)                         <anti-indent>
=bhG                      assign_copy('b',head(G))
I<G9999                   if less_than(G,9999):
 XZb.x?>l@Yblk+k\C@Yb+k\C     no_print(Z[b]=try_and_catch(greater_than(Plen(lookup(Y,b)),Plen(k)) ? concat(k,"C") : lookup(Y,b)), lambda:plus(k,"C"))
)                         <anti-indent>
)                     <anti-indent>
=YZ                   assign('Y',Z)
)                 <anti-indent>
@YQ               print(lookup(Y,Q))

Comments

बस ध्यान दे: लुआ एक नीचे है। : पी लेकिन यह अद्भुत, अच्छा काम है।

— R

अभी भी मेरे लिए ऊपर है: ओ

— लीके नून

मैं सक्रिय रूप से हल करता हूं, शायद आपके पास वोट हैं। लेकिन यह वास्तव में कोई फर्क नहीं पड़ता।

— R

ओह, यह मेरे लिए अब नीचे है

— लीके नून

Answer 4

जावास्क्रिप्ट (ईएस 6), 327763 चरण (इष्टतम, 184 बाइट्स)

एक चौड़ाई पहली खोज, इतनी स्मार्ट नहीं और इतनी जल्दी नहीं।

t=>eval("for(k=[],s=[['0000',i='']];[u,p]=s[i++],u-t;k[v=(1+u-~0+'').slice(-4)]=k[v]||s.push([v,p+'C']))[...u].map(x=>k[v=[...u].map(y=>x-y?y:-~x%10).join``]=k[v]||s.push([v,p+x]));p")

कम गोल्फ वाला

t=>{
  k=[]; // mark values already found to reduce search
  for( i=0, s=[['0000','']]; 
       [u,p]=s[i++], // u: current code, p:current steps
       u != t; // exit if target found
     )
  {
     // try all digits present in current code
     [...u].map(x=> {
       v=[...u].map(y=>x-y?y:-~x%10).join`` // apply digit x to u
       if (!k[v]) // check if value v not found already
          k[v] = s.push([v,p+x]));
     })
     v=(1+u-~0+'').slice(-4); // try operator C
     if (!k[v]) // check if value v not found already
       k[v] = s.push([v,p+'C']))
  }
  return p
}

परीक्षा

f=t=>eval("for(k=[],s=[['0000',i='']];[u,p]=s[i++],u-t;k[v=(1+u-~0+'').slice(-4)]=k[v]||s.push([v,p+'C']))[...u].map(x=>k[v=[...u].map(y=>x-y?y:-~x%10).join``]=k[v]||s.push([v,p+x]));p")

function SingleTest()
{
  var i=S.value
  if (/^\d{4}$/.test(i)) X.value=f(i)
  else X.value='invalid input'
}  

SingleTest()

function LongTest()
{
  var i=0,v,r,t=0
  
  var step=_=>{ 
    v = ('000'+i).slice(-4);
    r = f(v);
    t+= r.length    
    V.value = v;
    R.value = r;
    T.value = t;
    ++i;
    if(i<10000) setTimeout(step, 0)
  }  
  
  step()
}

#V,#T,#S { width:5em }
#R,#X { width: 25em }

Single Test <input id=S value='0093'><button onclick="SingleTest()">-></button><input readonly id=X><hr>
Long test (0000 ... 9999) <button onclick="LongTest()">Go</button>(i mean <i>long</i>, runtime 1 hour)<br>
<input readonly id=V>
<input readonly id=R> 
Total steps:<input readonly id=T>