गणितीय प्रतीकों को समझें

यदि आपने कार्ल सगन द्वारा पुस्तक संपर्क पढ़ा है , तो यह चुनौती आपको परिचित हो सकती है।

एक संख्या, एक अज्ञात ऑपरेटर, एक अन्य संख्या, और एक परिणाम से मिलकर गणितीय समीकरणों के एक सेट के इनपुट को देखते हुए, घटाएं कि कौन से ऑपरेटर इसके अलावा, घटाव, गुणन या विभाजन का प्रतिनिधित्व करते हैं।

प्रत्येक इनपुट समीकरण हमेशा शामिल होगा

एक गैर-नकारात्मक पूर्णांक
पत्र में से एक A, B, C, याD
एक और गैर-नकारात्मक पूर्णांक
चरित्र =
एक अंतिम गैर-नकारात्मक पूर्णांक

एक साथ मिला हुआ। उदाहरण के लिए, एक संभावित इनपुट है 1A2=3, जिसमें से आप कटौती कर सकते हैं जो Aइसके अलावा का प्रतिनिधित्व करता है। पूर्णांकों में से प्रत्येक संतुष्ट करेगा 0 ≤ x ≤ 1,000।

हालाँकि, यह हमेशा की तरह सरल नहीं है। वहाँ के बीच अस्पष्टता संभव है:

5A0=5इसके अलावा / घटाव
1A1=1: गुणा / भाग
0A5=0: गुणा / भाग
2A2=4इसके अलावा / गुणन
4A2=2: घटाव / विभाजन
0A0=0इसके अलावा / घटाव / गुणा

और इसी तरह। चुनौती इस क्षमता का उपयोग करने के लिए है कि विकल्पों को कम करने के लिए, उन्मूलन की प्रक्रिया के साथ संयुक्त, यह पता लगाने के लिए कि प्रत्येक अक्षर किस ऑपरेटर का प्रतिनिधित्व करता है। (हमेशा कम से कम एक इनपुट समीकरण होगा, और यह हमेशा एकल ऑपरेटर के साथ इनपुट में उपयोग किए जाने वाले प्रत्येक अक्षर को स्पष्ट रूप से मेल खाने के लिए संभव होगा।)

उदाहरण के लिए, मान लें कि इनपुट निम्नलिखित समीकरण हैं:

0A0=0: यह नीचे, जोड़, घटाव या गुणा (नीचे 0 से भाग नहीं कर सकता) के लिए A को कम करता है।
10B0=10: B को जोड़ या घटाव होना चाहिए।
5C5=10: C स्पष्ट रूप से जोड़ है, जो B घटाव बनाता है, जो A गुणन करता है।

इसलिए, इन इनपुट समीकरणों के लिए उत्पादन से मेल खाना चाहिए Aसाथ *, B साथ -, और Cसाथ +।

इनपुट एक एकल व्हाट्सएप- / अल्पविराम-सीमांकित स्ट्रिंग या तार की एक सरणी के रूप में दिया जा सकता है, प्रत्येक एक समीकरण का प्रतिनिधित्व करता है। आउटपुट या तो एक स्ट्रिंग ( "A*B-C+"), एक सरणी ( ["A*", "B-", "C+"]), या एक शब्दकोश / तानाशाह की तरह 2 डी सरणी ( {"A": "*", ...}या [["A", "*"], ...]) हो सकता है।

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

चूंकि यह कोड-गोल्फ है , बाइट्स में सबसे छोटा कोड जीतता है।

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

In                       Out
-------------------------------
0A0=0 10B0=10 5C5=10     A*B-C+
100D100=10000            D*
4A2=2 4B2=2 0A0=0        A-B/
15A0=15 4B2=2 2C2=0      A+B/C-
1A1=1 0A0=0              A*
0A0=0 2A2=4 5B0=5 2B2=4  A*B+
2A2=4 0C0=0 5B0=5 5A0=5  A+B-C*
0A1000=0 4A2=2           A/

code-golf arithmetic

— Doorknob
स्रोत

क्या हम पूर्णांक विभाजन कर रहे हैं?

— मार्टिन एंडर

@ MartinBüttner आप मान सकते हैं कि एक संख्या से विभाजन कभी नहीं होगा जो पूर्णांक में परिणाम नहीं करता है। (प्रश्न में संपादित।)

— दरवाज़े

क्या हम एक शब्दकोश के रूप में आउटपुट कर सकते हैं?

— lirtosiast

@ThomasKwa ज़रूर, एक शब्दकोश भी स्वीकार्य उत्पादन है।

— दरवाज़े

अधिकांश उदाहरण असंगत हैं " यह हमेशा स्पष्ट रूप से संभव होगा, विशिष्ट रूप से पहचानें कि कौन सा अक्षर किस ऑपरेटर के लिए खड़ा है ", हालांकि वे " इसके साथ संगत हैं" यह हमेशा यह पहचानना संभव होगा कि कौन सा ऑपरेटर प्रत्येक पत्र में उपयोग किए गए प्रत्येक अक्षर का प्रतिनिधित्व करता है। इनपुट "।

— पीटर टेलर

जवाबों:

MATL , 53 बाइट्स

j61tthYX'+-*/'X{Y@!"t'ABCD'!XKX{@YXU?K@Y}hwxKGm1L3$).

वर्तमान संस्करण का उपयोग करता है (10.1.0)

EDIT (12 जून, 2016): भाषा में परिवर्तन के अनुकूल होने के लिए, इसके Y}द्वारा gऔर इसके 1L3$)द्वारा प्रतिस्थापित करें Y)। नीचे दिए गए लिंक में उन संशोधनों को शामिल किया गया है

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

व्याख्या

यह चार ऑपरेटरों के सभी संभावित क्रमपरिवर्तन को एक लूप में परीक्षण करता है जब तक कि एक क्रमपरिवर्तन सभी समीकरणों को सत्य बनाता है।

यदि समीकरण सही हैं, तो परीक्षण करने के लिए, ऑपरेटरों द्वारा चार अक्षरों को बदलने के लिए एक रेगेक्स लागू किया जाता है (वर्तमान क्रमपरिवर्तन द्वारा निर्धारित क्रम में), और स्ट्रिंग को संख्याओं में बदल दिया जाता है (मूल्यांकन)। यह समीकरणों के रूप में कई संख्याओं के साथ एक सरणी देता है, जिसमें समीकरण जो सच होते हैं 1और समीकरण जो झूठे बन जाते हैं 0। यदि इस वेक्टर में केवल 1मान हैं, तो हम कर रहे हैं।

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

j            % input data string
61           % '=' (ASCII)
tth          % duplicate twice and concat: '==' (ASCII)
YX           % regexprep to change '=' into '==' in input string
'+-*/'       % push string
X{           % transform into cell array {'+','-','*','/'}
Y@!          % all permutations, each in a column
"            % "for" loop. Iterate columns (that is, permutations)
  t          %   duplicate data string containing '=='
  'ABCD'!XK  %   create column array ['A';'B';'C';'D'] and copy to clipboard K
  X{         %   transform into column cell array {'A';'B';'C';'D'} 
  @          %   push column cell array with current permutation of operator symbols
  YX         %   regexprep. Replaces 'A',...,'D' with current permutation of operators
  U          %   convert to numbers, i.e. evaluate string
  ?          %   if all numbers are 1 (truthy result): found it! But before breaking...
    K        %     push column array ['A';'B';'C';'D']
    @Y}      %     push column array with current permutation of operator symbols
    h        %     concatenate horizontally into 4x2 char array
    wx       %     delete original input so it won't be displayed
    K        %     push ['A';'B';'C';'D']
    G        %     push input string
    m        %     logical index that tells which of 'A',...,'D' were in input string
    1L3$)    %     apply that index to select rows of the 4x2 char array
    .        %     we can now break "for" loop
             %   implicitly end "if"
             % implicitly end "for"
             % implicitly display stack contents

— लुइस मेंडो
स्रोत

पायथन, 278 वर्ण

कोड गोल्फ पर मेरा पहला जवाब ...

यह केवल एक फ़ंक्शन है जो एक ब्रूट फ़ोर्स एल्गोरिदम को लागू करता है, आप इसे तर्क के स्ट्रिंग के रूप में पासिंग कहते हैं।

from itertools import *
def f(s):
    l=list("ABCD")
    for p in permutations("+-*/"):
        t=s
        for v,w in zip(l+["="," "],list(p)+["=="," and "]):
            t=t.replace(v, w)
        try:
            o=""
            if eval(t):
                for c,r in zip(l,p):
                    if c in s:
                        o+=c+r
                return o
        except:
            pass

— बॉब
स्रोत

मुझे यकीन है कि अगर यह काम करता है नहीं कर रहा हूँ, लेकिन आप बदल सकते हैं ["A","B","C","D"]के साथ list("ABCD")?

— अदनान

@ अदनान ने जो सुझाव दिया वह वास्तव में काम करता है। =की परिभाषा में आप रिक्त स्थान भी निकाल सकते हैं l।

— एलेक्स ए।

@ अदनान और एलेक्स ए धन्यवाद, मैंने कोड को संपादित किया।

— बॉब

यहां एक ही दृष्टिकोण के लिए 257 बाइट्स हैं , साथ ही एक ऑनलाइन परीक्षण वातावरण भी है।

— एलेक्स ए।

कुछ बदलाव किए - repl.it/BfuU । आप एक अलग आउटपुट स्वरूप चुनकर बहुत सारे बाइट्स काट सकते हैं। यह समाधान केवल अजगर 3 बीडब्ल्यूटी ( 4A2=2 4B3=1) पर काम करता है ।

— नबं

जावास्क्रिप्ट (ईएस 6), 213 208 बाइट्स

f=(l,s="+-*/",p="",r)=>s?[...s].map(o=>r=f(l,s[g="replace"](o,""),p+o)||r)&&r:l.split` `.every(x=>(q=x.split`=`)[1]==eval(q[0][g](/[A-D]/g,m=>p[(a="ABCD").search(m)])))&&a[g](/./g,(c,i)=>l.match(c)?c+p[i]:"")

व्याख्या

इनपुट और आउटपुट स्ट्रिंग्स हैं।

एक फ़ंक्शन को परिभाषित करता है fजो ऑपरेटरों के सभी क्रमपरिवर्तन उत्पन्न करने के लिए एक पुनरावर्ती कार्य के रूप में दोगुना हो जाता है और इनपुट समीकरणों के साथ पूर्ण क्रमपरिवर्तन का परीक्षण करता है eval।

f=(
  l,                          // l = input expression string
  s="+-*/",                   // s = remaining operators
  p="",                       // p = current permutation of operators
  r                           // r is here so it is defined locally
)=>
  s?                          // if there are remaining operators
    [...s].map(o=>            // add each operator o
      r=f(
        l,
        s[g="replace"](o,""), // remove it from the list of remaining operators
        p+o                   // add it to the permutation
      )
        ||r                   // r = the output of any permutation (if it has output)
    )
    &&r                       // return r
  :                           // else if there are no remaining operators
    l.split` `.every(x=>      // for each expression
      (q=x.split`=`)          // q = [ equation, result ]
      [1]==eval(              // if the results is equal to the eval result

        // Replace each letter with the current permutation
        q[0][g](/[A-D]/g,m=>p[(a="ABCD").search(m)])
      )
    )

    // If all results matched, add permutation symbols to present characters and return
    &&a[g](/./g,(c,i)=>l.match(c)?c+p[i]:"")

परीक्षा

ब्राउज़र संगतता के लिए परीक्षण डिफ़ॉल्ट तर्कों का उपयोग नहीं करता है।

कोड स्निपेट दिखाएं

var solution = f=(l,s,p,r)=>s==null&&(s="+-*/",p="",0)?0:s?[...s].map(o=>r=f(l,s[g="replace"](o,""),p+o)||r)&&r:l.split` `.every(x=>(q=x.split`=`)[1]==eval(q[0][g](/[A-D]/g,m=>p[(a="ABCD").search(m)])))&&a[g](/./g,(c,i)=>l.match(c)?c+p[i]:"")

<input type="text" id="input" value="2A2=4 0C0=0 5B0=5 5A0=5" />
<button onclick="result.textContent=solution(input.value)">Go</button>
<pre id="result"></pre>

स्निपेट का विस्तार करें

— user81655
स्रोत