माचिस की तीलियाँ

Question

इस चुनौती में आपका काम किसी दिए गए "माचिस के समीकरण" का विश्लेषण करना है ...

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

इनपुट

इनपुट एक स्ट्रिंग है जिसे STDIN से पढ़ा जा सकता है, एक फ़ंक्शन तर्क के रूप में लिया जाता है या किसी फ़ाइल में संग्रहीत किया जा सकता है। यह एक समीकरण है जो एक माचिस की व्यवस्था का प्रतिनिधित्व करता है और निम्नलिखित EBNF का उपयोग करके वर्णित किया जा सकता है:

input = term, "=", term ;
term = number | (term, ("+" | "-"), term) ;
number = "0" | (numeralExceptZero , {numeral}) ;
numeralExceptZero = "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" ;
numeral = "0" | numeralExceptZero ;

एक वैध इनपुट के लिए एक उदाहरण होगा 3+6-201=0+0+8।

कार्य

निम्नलिखित दृष्टांत पर विचार करें जहाँ प्रत्येक माचिस की संख्या में एक संख्या है:

अब हम प्रत्येक इनपुट प्रतीक का मिलान इस प्रकार की मिलान स्थिति के अनुसार करते हैं:

0 ↦ 1,2,3,4,5,6
1 ↦ 4,5
2 ↦ 2,3,5,6,8
3 ↦ 3,4,5,6,8
4 ↦ 1,4,5,8
5 ↦ 1,3,4,6,8
6 ↦ 1,2,3,4,6,8
7 ↦ 4,5,6
8 ↦ 1,2,3,4,5,6,8
9 ↦ 1,3,4,5,6,8
- ↦ 8
+ ↦ 8,10
= ↦ 7,9

प्रत्येक इनपुट फार्मूले को मैचस्टिक व्यवस्था में बदल दिया जा सकता है। उदाहरण के लिए, समीकरण "45 + 6 = 92" बन जाता है

जहां अप्रयुक्त माचिस की तीलियां निकलती हैं। आपका काम यह है कि समीकरण को वैध बनाने के लिए कम से कम मैचस्टिक्स का पता लगाना है।

उत्पादन

हम तीन संभावित मामलों में अंतर करते हैं:

• यदि इनपुट मान्य नहीं है (अर्थात यह उपरोक्त EBNF को संतुष्ट नहीं करता है), आउटपुट जो भी आप चाहते हैं।
• अन्यथा, यदि मैचस्टिक्स को फिर से व्यवस्थित करके समीकरण को वैध में बदलने के तरीके हैं, तो आपको न्यूनतम संख्या में पुनर्व्यवस्था और संबंधित समीकरण दोनों को आउटपुट करना होगा। इनपुट के रूप में, आउटपुट समीकरण को दिए गए EBNF को भी संतुष्ट करना होगा। उपरोक्त उदाहरण में, सही उत्पादन होगा और । यदि परिणामी समीकरण के लिए कई संभावनाएं हैं, तो उनमें से किसी को भी आउटपुट करें।146+6=52
• अन्यथा (इसलिए यदि इनपुट वैध है लेकिन समीकरण को सच करने का कोई तरीका नहीं है), तो आपको आउटपुट करना होगा -1।

विवरण

• आपको मैचों को हटाने या जोड़ने की अनुमति नहीं है। इसका मतलब है, यदि इनपुट nमाचिस की तीलियों से बना है, तो आउटपुट में बिल्कुल nमाचिस की तीलियां भी होनी चाहिए ।
• "खाली" माचिस-ब्लॉक केवल एक समीकरण के अंत और शुरुआत में अनुमत हैं, मध्य में नहीं। तो, उदाहरण के लिए, मोड़ 7-1=6में 7 =6-1बस को हटाने के द्वारा -1बाईं ओर से और सिर्फ 3 matchstick rearrangements के साथ सही पक्ष पर इसे जोड़ने की अनुमति नहीं है।

• चूँकि मैं वास्तव में इस चुनौती के एक दिलचस्प हिस्से के रूप में संख्याओं से मेलस्टिक पदों के लिए मैपिंग को नहीं देखता, 20 बाइट्स के प्लस के लिए , आप या तो हो सकते हैं

  • एक फ़ाइल का उपयोग करें जिसमें मैपिंग (number/operation ↦ matchstick positions)किसी भी उचित तरीके से संग्रहीत की जाती है, या
  • यदि आपकी प्रोग्रामिंग भाषा Mapडेटाटाइप का समर्थन करती है , तो मान लें कि आपके पास (number/operation ↦ matchstick positions)मैपिंग तक पहुंच है, जो मानचित्रण के साथ पूर्व- निर्मित है। उदाहरण के लिए यह नक्शा इस तरह दिख सकता है:{(0,{1,2,3,4,5,6}),(1,{4,5}),(2,{2,3,5,6,8}),(3,{3,4,5,6,8}), ..., (-,{8}),(+,{8,10}),(=,{7,9})}

उदाहरण

इनपुट: 1+1=3 ↦ आउटपुट: 1 और1+1=2

इनपुट: 15+6=21 ↦ आउटपुट: 0 और15+6=21

इनपुट: 1=7 ↦ आउटपुट: -1

इनपुट: 950-250=750 ↦ आउटपुट: 2 और990-240=750

इनपुट: 1-2=9 ↦ आउटपुट: 1 और1+2=3

इनपुट: 20 + 3=04 ↦ आउटपुट: कुछ भी

विजेता

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

Comments

0: 1, 2, 3, 4, 5, 6निरंतरता के लिए कृपया जोड़ें

— नहीं कि

ओह धन्यवाद, पूरी तरह से उस के बारे में भूल गया!

— vauge

@v Hey को '2 = 1-1' -> '2-1 = 1' रिटर्न 3 या 14 चालें चाहिए क्योंकि 2 को तकनीकी रूप से छोड़ना पड़ता है?

— 13

@ सामान्य इसे 3 वापस करना चाहिए, सिर्फ इसलिए कि आप =(2 माचिस) की स्थिति को बदल सकते हैं और -(1 माचिस की तीली) और उन सभी नंबरों को छोड़ दें जहां वे हैं। यदि, हालांकि, 2 को बाएं चलना पड़ा, तो आपको आवश्यक चाल भी गिननी होगी।

— 14

क्या ऑपरेशन की संख्या पर कोई सीमा है? इनपुट की तरह हो सकता है 1+1+2=3-6+10? और आउटपुट के बारे में भी यही सवाल है।

— क्वर्टी

Answer 1

जावास्क्रिप्ट, 1069 बाइट्स

मैंने इसे काफी कुछ परीक्षण समीकरणों के साथ परीक्षण किया है और ऐसा लगता है कि अब यह सभी काम कर रहा है ...

function w(t){function B(c,f){d=(c.length>f.length?f:c).split("");e=(c.length>f.length?c:f).split("");longer=Math.max(d.length,e.length);if(0!==d.length&&0!==e.length){c=[];for(x in d)for(y in c[x]=[],e)c[x][y]=1<y-x?-1:function(c,n){r=0;for(j in n)-1<c.indexOf(n[j])&&r++;return c.length+n.length-2*r}(a[d[x]],a[e[y]]);return v=function(f,n){for(var h=f.length-2;0<=h;h--)c[n.length-1][h]+=c[n.length-1][h+1];for(h=f.length-2;0<=h;h--)for(var q=0;q<n.length-1;q++)1>=h-q&&(c[q][h]+=-1==c[q][h+1]?c[q+1][h+1]:Math.min(c[q+1][h+1],c[q][h+1]));return c[0][0]/2}(e,d)}return-1}a=[[1,2,3,4,5,6],[4,5],[2,3,5,6,8],[3,4,5,6,8],[1,4,5,8],[1,3,4,6,8],[1,2,3,4,6,8],[4,5,6],[1,2,3,4,5,6,8],[1,3,4,5,6,8]];a["+"]=[8,0];a["-"]=[8];a["="]=[7,9];a[" "]=[];l=0;p=[];u=[];r=/^([1-9]\d*|0)([+-]([1-9]\d*|0))*=([1-9]\d*|0)([+-]([1-9]\d*|0))*$/;b=/(=.*=|[+=-]{2,}|^[+=-])/;if(!t.match(r))return-1;g=function(c,f,t){if(0===t&&f.match(r)&&eval(f.replace("=","==")))c.push(f);else for(var n in a)t>=a[n].length&&" "!=n&&!(f+n).match(b)&&g(c,f+n,t-a[n].length)};g(p,"",function(c){m=0;for(var f in c)m+=a[c[f]].length;return m}(t.split("")));for(var z in p)k=B(t,p[z]),u[k]||(u[k]=[]),u[k].push(p[z]);for(var A in u)return[A,u[A]];return-1}

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

यदि इनपुट "1-2 = 9" है तो आउटपुट [1, ["1 + 2 = 3", "7-2 = 5"] है।]

और यहाँ असम्पीडित कोड है:

function ms(s) {
a=[[1,2,3,4,5,6],[4,5],[2,3,5,6,8],[3,4,5,6,8],[1,4,5,8],[1,3,4,6,8],[1,2,3,4,6,8],[4,5,6],[1,2,3,4,5,6,8],[1,3,4,5,6,8]];
a["+"] = [8, 0];
a["-"] = [8];
a["="] = [7, 9];
a[" "] = [];
l = 0;
p = [];
u = [];
r = /^([1-9]\d*|0)([+-]([1-9]\d*|0))*=([1-9]\d*|0)([+-]([1-9]\d*|0))*$/;
b = /(=.*=|[+=-]{2,}|^[+=-])/;
if (!s.match(r)) return -1;
function f(g,h)
{
    d=(g.length>h.length?h:g).split('');
    e=(g.length>h.length?g:h).split('');
    longer=Math.max(d.length, e.length);
    if(0!==d.length&&0!==e.length)
    {
        g=[];
        for(x in d)
        {
            g[x]=[];
            for(y in e)
            {
                g[x][y]=(y-x>1)?-1:function(g, h){r=0;for(j in h)if(g.indexOf(h[j])>-1)r++;return g.length+h.length-2*r;}(a[d[x]],a[e[y]]);
            }
        }
        v=function(d,e)
        {
        for(var y=d.length-2;y>=0;y--) g[e.length-1][y]+=g[e.length-1][y+1];
        for(var y=d.length-2;y>=0;y--)
            for(var x=0;x<e.length-1;x++)
                if(y-x<=1)
                    g[x][y]+=g[x][y+1]==-1?g[x+1][y+1]:Math.min(g[x+1][y+1], g[x][y+1]);
        return g[0][0]/2}(e,d)
        return v
    }
    return -1;
}
g=function(n, s, i){if (i===0 && s.match(r) && eval(s.replace('=','=='))){n.push(s);return;}for (var c in a) if(i>=a[c].length && c!=" " && !(s+c).match(b)) g(n, s+c, i-a[c].length);};
g(p, "", function(q){m=0;for(var t in q)m+=a[q[t]].length;return m}(s.split('')));
for (var i in p)
{
    k=f(s, p[i]);
    if (!u[k]) u[k] = [];
    u[k].push(p[i]);
}
for (var q in u) return [q, u[q]];
return -1;
}

चेतावनी: 950-250 = 750 जैसे समीकरण न करें, यह ~ 45 माचिस की तीलियों का उपयोग करता है और क्योंकि यह कोड पाश्र्व बल का उपयोग करता है जिससे जावास्क्रिप्ट लटकने लगेगा।

Comments

मेरा मानना ​​है कि आप अपने द्वारा उपयोग किए जाने वाले चर var kको फंक्शन के लिए अप्रयुक्त पैरामीटर के रूप में घोषित कर सकते हैं, इस घोषणा के लिए 3 बाइट्स की बचत करते हैं।

— rorlork

मुझे लगता है कि मैं कुछ और प्रोग्रामिंग लैंग्वेज सीखने जा रहा हूं और यह जानने की कोशिश नहीं कर रहा हूं कि वास्तव में बाइट की गिनती करने के लिए एक बहुत ही ब्रूट फोर्स तरीका है।

— सेरिक

मुझे लगता है कि आपका समाधान सही नहीं है, जब आप दूरी की गणना कर रहे हैं तो आप हमेशा बराबर वर्णों को संरेखित करते हैं। कुछ मामलों में यह इष्टतम तरीका नहीं है। उदाहरण के लिए '2 = 1-1' को 3 चालों में '2-1 = 1' में बदला जा सकता है, जबकि '=' संकेतों को संरेखित करने से 14 चालें चलती हैं। इसके अलावा, मैं यह नहीं देखता कि आप अग्रणी शून्य से कैसे बचते हैं। उदाहरण के 08=8लिए 80=8गलत है।

— नटकी

@ कुटकी हाँ, मुझे लगता है कि मैं इसे बदल सकता हूँ। मैं सोच रहा था कि गलत होगा हालांकि आप के कारण तकनीकी रूप से 2 को स्थानांतरित करने के लिए -1 के लिए जगह बनाने के लिए होगा

— Cieric

@ कुटकी ठीक है, हाँ। क्षमा करें, मैं देख रहा हूं कि अब आपका क्या मतलब है। वैसे मैं regex को ठीक करने जा रहा हूं और देख सकता हूं कि क्या मैं एडिट दूरी के लिए कोड बदल सकता हूं।

— Cieric

Answer 2

पर्ल, 334

जब तक समाधान 1 या 2 चाल में उपलब्ध है, तब तक काफी तेजी से। जब कोई हल नहीं होता है तो आप सबसे छोटे मामले में भी लंबे इंतजार के लिए तैयार रहते हैं 1=7।

#!perl -p
@y=map{sprintf"%010b",$_}63,24,118,124,89,109,111,56,127,125,64,192,768;
$y{$z{$y[$c++]}=$_}=$y[$c]for 0..9,qw(- + =);
$"="|";$l=s/./$y{$&}/g;$x{$_}=1;for$m(0..y/1//){
last if$_=(map"$m $_",grep{s/@y/$z{$&}/g==$l&&/^\d.*\d$/&!/\D\D/&!/\b0\d/&y/=//==1&&eval s/=/==/r}keys%x)[0];
$_=-1;s/0/"$`1$'"=~s!1!$x{"$`0$'"}=1!ger/eg for keys%x}

उदाहरण:

$ time perl ~/matchstick.pl <<<950-250=750
2 990-250=740

real    0m39.835s
user    0m39.414s
sys 0m0.380s

यह उन समाधानों को नहीं खोजेगा जो समीकरण की लंबाई को बदलते हैं जैसे 11=4-> 2 11=11, लेकिन मुझे यकीन नहीं है कि इसे इसकी अनुमति होगी।

Comments

जब तक वे प्रश्न में उल्लिखित EBNF का अनुसरण करते हैं, तब तक समीकरण की लंबाई बदलने वाले समाधानों की अनुमति दी जाती है। इसलिए, उन्हें आपके फ़ंक्शन द्वारा भी पाया जाना चाहिए।

— जुन्न

@ गेज, हाँ, मैं देख सकता हूँ कि यह विवरण में "खाली मशीन स्टॉक्स" खंड से अनुमान लगाया जा सकता है। मैं इसे इस समाधान में नहीं जोड़ूंगा, हालांकि जब यह काम कर सकता है, तो यह इसे और भी धीमा कर देगा।

— नटकी

@ मैं असभ्य ध्वनि नहीं करना चाहता, लेकिन अगर कोड तय नहीं है तो क्या यह अभी भी गिना जाएगा?

— सेरिक

@ सीरिक यदि कोई अन्य समाधान नहीं है जो उन सभी मामलों को संभालता है तो हां, यह गिना जाएगा। हालांकि, अगर इस चुनौती के अंत तक कोई पूरी तरह से काम करने वाले उत्तर हैं, तो मैं उनमें से सबसे कम को स्वीकार करूंगा।

— जुं

@ ठीक ठीक जाँचने के लिए मुझे केवल यह सुनिश्चित करना है कि चाल की संख्या सही है, अब तक यह हमेशा सही आउटपुट समीकरण प्रदर्शित करता है।

— Cieric