एक शब्द समीकरण सॉल्वर [डुप्लिकेट] लिखें

Question

परिचय

निम्नलिखित उदाहरण पर विचार करें:

  CODE
+ GOLF
——————
 GREAT

यह एक समीकरण है जहां प्रत्येक अक्षर एक दशमलव अंक का प्रतिनिधित्व करता है और शब्द प्राकृतिक संख्याओं का प्रतिनिधित्व करते हैं (समान अक्षर समान अंकों का प्रतिनिधित्व करते हैं और विभिन्न अक्षर अलग-अलग अंकों का प्रतिनिधित्व करते हैं)। कार्य प्रत्येक अक्षर को उसके अंकों के मूल्य के साथ मिलान करना है ताकि समीकरण सही हो। उपरोक्त समीकरण का एक हल है:

  9265
+ 1278
——————
 10543

आपका कार्य

आपका कार्य एक कार्यक्रम या एक फ़ंक्शन लिखना है जो ऐसे समीकरणों को हल कर सकता है जैसा कि ऊपर देखा गया है।

इनपुट

इनपुट निम्नलिखित प्रारूप में एक स्ट्रिंग है:

[A-Z]+\+[A-Z]+=[A-Z]+

उदाहरण:

1. CODE+GOLF=GREAT
2. AA+BB=CC

रिक्त स्थान छोड़ दिए गए हैं और केवल राजधानी ए और जेड के बीच के अक्षरों का उपयोग किया जाएगा (कोई विशेष या छोटे अक्षर नहीं)।

यह स्ट्रिंग मानक इनपुट से, फ़ाइल से या फ़ंक्शन पैरामीटर के रूप में पढ़ा जा सकता है।

उत्पादन

आउटपुट प्रारूप के लिए आपके पास दो विकल्प हैं:

1. प्रतिस्थापित किए गए अंकों के साथ मूल समीकरण
2. पत्रों और उनके मूल्यों की सूची

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

उदाहरण:

1. 9265+1278=10543
2. A=1 B=2 C=3 (आप किसी भी सीमांकक का उपयोग कर सकते हैं)

नियम

1. चीजों को आसान बनाने के लिए, संख्याओं को 0 से शुरू करने के लिए स्वीकार किया जाता है, लेकिन आप 0 को अमान्य समाधान के रूप में अग्रणी के साथ संख्या को संभाल सकते हैं, यह आपके ऊपर है
2. समान अक्षर समान अंकों का प्रतिनिधित्व करते हैं और विभिन्न अक्षर अलग-अलग अंकों का प्रतिनिधित्व करते हैं
3. आप किसी भी भाषा और चुने हुए भाषा के मानक पुस्तकालय का उपयोग कर सकते हैं (कोई बाहरी परिवाद नहीं)
4. आप इंटरनेट पर किसी भी संसाधन से कनेक्ट नहीं कर सकते (आप वैसे भी क्यों करेंगे?)
5. यह एक कोड गोल्फ टास्क है, सबसे छोटा कोड जीतता है। लगातार व्हाट्सएप वर्णों को एक एकल वर्ण के रूप में गिना जाता है। (इसलिए व्हॉट्सएप में लिखा गया कोई भी प्रोग्राम अपने आप जीत जाता है)

मैं 179 वर्णों का उपयोग कर कुछ हद तक समाधान है। यदि कुछ स्पष्ट नहीं है, तो कृपया मुझे टिप्पणियों में पूछें।

Comments

मुझे लगता है कि इष्टतम उत्तर "सब कुछ 0 है"। आप विशेष रूप से उस पर प्रतिबंध लगाना चाह सकते हैं।

— अंडरग्राउंडोरेल

हर चीज से आपका क्या मतलब है 0 विभिन्न अक्षरों को अलग-अलग संख्याओं को निरूपित करना होता है।

— डेविड फ्रैंक

याद किया कि, कोई बात नहीं :)

— भूमिगत

If there are no solutions, the program should return an empty string or null.अनंत लूप अभी भी कुछ भी नहीं उत्पादन ... मैं कर सकता हूँ?

— टाइटस

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

— पपीरी

Answer 1

पायथन - 48 वर्ण

exec("".join(map(chr,map(len,'                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             '.split("    ")))))

व्हाट्सएप नियम का दुरुपयोग।

पहले मैंने CASLifeJacket के हर चरित्र को उसके ASCII मूल्य में बदल दिया (मैं अपना लिख ​​सकता था लेकिन मैं आलसी हूं, और यह वैसे भी अंतिम स्कोर को प्रभावित नहीं करेगा)। मेरे समाधान में लंबी स्ट्रिंग उन ASCII मूल्यों में से प्रत्येक के लिए एक स्थान है, और उन्हें अलग करने वाले टैब हैं। टैब पर विभाजित करें, लंबाई खोजें, वर्णों में वापस बदलें और निष्पादित करें।

एसई प्रत्येक को 4 स्थानों में टैब में परिवर्तित करता है, इसलिए कोपिपस्टिंग काम नहीं करेगा। आपको बस मुझ पर विश्वास करना होगा :)

Comments

क्या आप विचारधारा, या अपने कोड के हेक्स डंप को लिंक प्रदान कर सकते हैं?

— n --h'a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

भी: निष्पादन एक कीवर्ड है, आप पहले और आखिरी ब्रैकेट को हटाकर 2

— चार्ट

Answer 2

रूबी 2.0, 122 वर्ण

जानवर बल फेरबदल + eval! यह अभी तक अशक्त / खाली स्ट्रिंग के मानदंडों को पूरा नहीं करता है जब कोई समाधान नहीं होता है; यह बस अनंत रूप से छोरों। यदि यह ~ 300 मिलियन पुनरावृत्तियों के बाद कोई परिणाम नहीं मिल सकता है, तो यह शून्य वापस आ जाएगा। पर्याप्त नजदीक?

f=->s{d=*0..9
d.shuffle!&&$.+=1until$.>9**9||z=eval((r=$_.tr(s.scan(/\w/).uniq*'',d*'')).gsub(/\b0/,'').sub ?=,'==')
z&&r}

यह इनपुट में सभी अद्वितीय अक्षरों को ढूंढता है, फिर बार-बार अंकों को 0-9 से फेरबदल करता है और उन्हें अक्षरों के साथ मिलान करने का प्रयास करता है जब तक कि यह एक कॉन्फ़िगरेशन नहीं पाता है जो काम करता है।

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

puts f["AA+BB=CC"]
 #=> 22+44=66
puts f["CODE+GOLF=GREAT"]
 #=> 8673+0642=09315

CODE+GOLF=GREATमेरी मशीन पर उदाहरण के लिए चलने का समय तात्कालिक से लगभग 6 सेकंड तक भिन्न होता है - यह इस बात पर निर्भर करता है कि आप कितने भाग्यशाली हैं!

मैं विशेष रूप gsub(/\b0/,'')से अग्रणी शून्य को हटाने के लिए बिट से नाखुश हूं, लेकिन यह केवल एक चीज थी जिसे मैं evalअष्टक ints के रूप में संख्याओं की व्याख्या करने से रोक सकता था ।

( बोनस : क्योंकि यह eval का उपयोग करता है, यह मनमाने ढंग से रूबी अभिव्यक्तियों के लिए काम करता है और सिर्फ जोड़ नहीं!)

Comments

जब मैं इसे पढ़ता था, तो मेरे पास एक ही विचार था, लेकिन मुझे कोड के ~ 170 चार्ट मिल गए, इसलिए अच्छी तरह से किया गया। 0..9 दस अंक हैं, तो क्या सीमा 10 ** 10 नहीं होनी चाहिए? आप सभी संभावित मैपिंग पर लूप के लिए Array # क्रमचय का उपयोग कर सकते हैं, लेकिन यह कोड को लंबा कर सकता है।

— ब्लुटोरेंज

@blutorange मैंने सिर्फ 9 ** 9 को चुना क्योंकि यह एक बड़ी संख्या थी जिसे आप कुछ पात्रों के साथ लिख सकते थे। मुझे लगता है कि यह किसी भी उचित परीक्षण मामलों के लिए पर्याप्त से अधिक होना चाहिए! मैंने एक संस्करण के आधार पर कोशिश नहीं की है permutation, लेकिन जैसा कि आप कहते हैं, मैं मुख्य रूप से कोड लंबाई से संबंधित था।

— पॉल प्रेस्टिज

Answer 3

लाइवस्क्रिप्ट (179 वर्ण)

इसमें नियतात्मक और अपेक्षाकृत जल्दी चलने वाला समय है और अन्य ऑपरेटरों (+, -, *) के साथ भी काम करता है।

f=(s)->                     # define function that takes parameter s
  c=s.replace /[^A-Z]/g ''  # remove all the non-letters
  if c                      # if any letters remain
    for i from 0 to 9       # loop from 0 to 9
       if s.indexOf(i)<0&&a=f s.split(c.0).join i  # if i is not present in the number, replace the first letter with i and call the function recursively
         return a           # if there is a solution, return it
  else                      # if there are no letters left
    if eval s.replace(/(^|\D)0+(\d)/g,'$1$2').replace \= \==  # if the expression is correct (we need to remove leading 0, because javascript interprets numbers with leading 0 as octal)
       return s  # return solution



f("CODE+GOLF=GREAT")

Answer 4

अजगर, 256 213 चार्ट

भयानक समय चल रहा है, आगे सुधार करने की कोशिश करेंगे:

q='='
e=input()
v=set(e)-set([q,'+'])
for x in __import__('itertools').permutations(range(10),len(v)):
    t=e
    for l,n in zip(v,x):t=t.replace(l,str(n))
    try: 
        if eval(t.replace(q,q*2)):print(t);break
    except:pass

Answer 5

जावास्क्रिप्ट 138

for(s=prompt(p='1');eval(p.replace('=','!='));)for(p=s,i=64;i++<90;)p=p.replace(new RegExp(String.fromCharCode(i),'g'),10*Math.random()|0)

यादृच्छिक जानवर।
थोड़ी देर ले सकते हैं (मेरा सबसे अच्छा शॉट CODE+GOLF=GREAT3 सेकंड है, मेरा सबसे खराब 3 मिनट)।
इसे सरल अभिव्यक्ति की तरह आज़माएँA+B=C

Answer 6

हास्केल, 222

import Data.List
z=(\(b,(_:c))->b:z c).span Data.Char.isUpper
j(Just g)=g
main=interact$(\d@[a,b,c]->show$take 1[e|e<-map(zip$nub$d>>=id)$permutations['0'..'9'],(\f->f a+f b==(f c::Int))(read.map(j.(`lookup`e)))]).take 3.z

पाशविक बल। हर संभव मिलान की कोशिश करता है जब तक कि यह एक नहीं मिलता है, या इसके बाद उन सभी की कोशिश कर रहा है। मैंने आउटपुट नियमों को बढ़ाया: [[('C','3'),('O','8'),('D','6'),('E','7'),('G','0'),('L','5'),('F','2'),('R','4'),('A','1'),('T','9')]]समाधान के लिए कुछ प्रिंट करता है, और यदि कोई मौजूद नहीं है, तो प्रिंट करता है []। अगर मुझे इसे बदलने की जरूरत है तो मुझे बताएं।

Comments

मुझे लगता है, यह आउटपुट स्वीकार्य है।

— डेविड फ्रैंक

Answer 7

CJam - 17

"





























































































































































































































































































































    ""  
"f#3b127b:c~

कुल 975 वर्ण, लेकिन उनमें से 960 2 अनुक्रमों में व्हाट्सएप हैं, इसलिए उन वर्णों की गिनती 2 वर्णों के साथ है, और अन्य 15 के साथ, हमें 17 मिलते हैं।
975 बहुत अधिक लग सकते हैं, लेकिन ध्यान दें कि अंडरग्राउंडोरेल के पाइथ सॉल्यूशन में 18862 वर्ण हैं, वे 'सिर्फ एक लाइन पर फिर से :)

आप इसे संक्षिप्त शब्दों के लिए http://cjam.aditsu.net/ पर चला सकते हैं , लेकिन आपको संभवतः अधिक समय तक जावा दुभाषिया का उपयोग करना चाहिए। मेरे लैपटॉप पर जावा के साथ, SEND+MORE=MONEY30-40 सेकंड में और CODE+GOLF=GREATलगभग 3 मिनट में चलता है । यह 0 से शुरू होने वाली संख्याओं को स्वीकार नहीं करता है (क्योंकि यह शांत नहीं है)।

यहाँ एक प्रोग्राम है जो ऊपर प्रोग्राम बनाता है (यह भी मदद करता है कि अगर StackExchange व्हाट्सएप को सही ढंग से नहीं दिखाता है):

"{L__&=}:U;
{L!!{L))_9>{;:L;I}{+:L;}?}*}:I;
{{U!_{I}*}g}:M;
{L,N<L,g&}:K;
{I{K{L0+:L;}*MK}g}:G;
{{C#L=}%si}:R;
{XRYR+ZR=PRAb0#0<&}:F;
l'+/~'=/~:Z;:Y;:X;
[X0=Y0=Z0=]:P;
XYZ++_&:C,:NB<{0a:L;{F0{GL}?}g}*
L{XR'+YR'=ZR}{L}?"
127b3b[32 9 A]:cf='"\'"_32c9cAc"\"f#3b127b:c~"

पहली 11 लाइनों में मूल प्रोग्राम (वास्तव में गोल्फ नहीं है) एक स्ट्रिंग में होता है, और अंतिम पंक्ति रूपांतरण करती है और डिकोडिंग भाग को जोड़ती है।

Answer 8

पॉवरशेल, 137 बाइट्स

लाइवस्क्रिप्ट का पोर्ट

$f={param($s)if($c=$s-replace'[^A-Z]'){0..9|?{$s-notmatch$_}|%{&$f ($s-replace$c[0],$_)}|Select -f 1}elseif($s-replace'=','-eq'|iex){$s}}

अनगुल्ड परीक्षण स्क्रिप्ट:

$f={

param($s)                           # parameter string
$c=$s-replace'[^A-Z]'               # remove all the non-letters
if($c){                             # if any letters remain
    0..9|?{                         # loop from 0 to 9
        $s-notmatch$_               # if $s is not contains current number
    }|%{
        &$f ($s-replace$c[0],$_)    # replace the first letter with current number and call the function recursively
    }|Select -f 1                   # seelct first non-null value (break if found)
}
elseif($s-replace'=','-eq'|iex){    # else if evaluated value if the expression is $true
    $s                              # return $s as solution
}

}

&$f "AA+BB=CC"
&$f "A+AB=A"            # empty because it has no solution
&$f "CODE+GOLF=GREAT"

आउटपुट:

11+22=33
2846+0851=03697

Answer 9

PHP, 118 113 बाइट्स

for(;;)eval(strtr($argn,"=".$w=substr(count_chars($argn,3),2),"-".$n=str_shuffle(1234567890))."||die('$w
$n');");

अक्षरों के नीचे अंक और कार्यक्रम से बाहर निकलता है; अगर अंतहीन है तो लूप्स लाजिमी है। साथ पाइप के रूप में चलाएँ -nr।

टूट - फूट

for(;;)
    eval(                               # 6. evaluate
        strtr($argn,                    # 4. translate letters to digits, "=" to "-"
            "=".$w=substr(              # 2. remove non-letters
                count_chars($argn,3)    # 1. get characters used in the argument
                ,2),
            "-".$n=str_shuffle(1234567890)  # 3. shuffle digits
        )."||die('$w\n$n');"            # 5. if falsy (`A+B-C==0`), print translation and exit
    )
;

Answer 10

PHP, 145 बाइट्स

function f($s){for(;$i<10*preg_match("/[A-Z]/",$s,$m);)strpos(_.$s,++$i+47)||f(strtr($s,$m[0],$i-1));$i||eval(strtr($s,"=","-")."||die('$s');");}

पुनरावर्ती समारोह, प्रिंट हल समीकरण और कार्यक्रम से बाहर निकलता है; NULLजब वापसी नहीं होती है।

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

टूट - फूट

function f($s)
{
    for(;
        $i<10                   # loop $i from 0 to 9
        *preg_match("/[A-Z]/",$s,$m)    # find a letter; if not found: $i<10*0 == falsy
        ;
    )
        strpos(_.$s,++$i+47)            # find $i in string
        ||f(strtr($s,$m[0],$i-1));      # if not found, replace letter with $i, recurse
    $i||                        # no letter found ($i is unset):
        eval(                   # evaluate:
            strtr($s,"=","-")       # replace "=" with "-"
            ."||die('$s');"         # if falsy (A+B-C==0), print equation, exit program
        );
    # else implicitly return NULL
}