Wenn Sie das Buch Contact von Carl Sagan gelesen haben , kommt Ihnen diese Herausforderung vielleicht bekannt vor.

Wenn Sie einen Satz mathematischer Gleichungen eingeben, der aus einer Zahl, einem unbekannten Operator, einer anderen Zahl und einem Ergebnis besteht, können Sie ableiten, welche Operatoren Addition, Subtraktion, Multiplikation oder Division darstellen.

Jede Eingabegleichung besteht immer aus

• eine nicht negative ganze Zahl
• einen der Buchstaben A, B, C, oderD
• eine andere nicht negative ganze Zahl
• der Charakter =
• eine letzte nicht negative ganze Zahl

zusammen verkettet. Eine mögliche Eingabe ist beispielsweise 1A2=3, aus der Sie ableiten können, dass dies Aeine Addition darstellt. Jede der ganzen Zahlen wird befriedigen 0 ≤ x ≤ 1,000.

Es ist jedoch nicht immer so einfach. Es kann zu Unklarheiten kommen zwischen:

• 5A0=5: Addition Subtraktion
• 1A1=1: Multiplikation / Division
• 0A5=0: Multiplikation / Division
• 2A2=4: Addition / Multiplikation
• 4A2=2: Subtraktion / Division
• 0A0=0: Addition / Subtraktion / Multiplikation

und so weiter. Die Herausforderung besteht darin, diese Fähigkeit zu nutzen, um in Kombination mit dem Eliminierungsprozess die Auswahl einzugrenzen und herauszufinden, welchen Operator jeder Buchstabe darstellt. (Es wird immer mindestens eine Eingabegleichung geben, und es wird immer möglich sein, jeden in der Eingabe verwendeten Buchstaben eindeutig einem einzelnen Operator zuzuordnen.)

Angenommen, die Eingabe besteht aus den folgenden Gleichungen:

• 0A0=0: Hiermit wird A auf Addition, Subtraktion oder Multiplikation eingegrenzt (kann nicht durch 0 dividiert werden).
• 10B0=10: B muss entweder Addition oder Subtraktion sein.
• 5C5=10: C ist offensichtlich Addition, die B-Subtraktion macht, die A-Multiplikation macht.

Daher sollte die Ausgabe für diese Eingangsgleichungen Amit *, B mit -und Cmit übereinstimmen +.

Die Eingabe kann entweder als einzelne, durch Leerzeichen / Kommas getrennte Zeichenfolge oder als Array von Zeichenfolgen erfolgen, die jeweils eine Gleichung darstellen. Die Ausgabe kann entweder eine einzelne Zeichenfolge ( "A*B-C+"), ein Array ( ["A*", "B-", "C+"]) oder ein wörterbuch- / diktähnliches 2D-Array ( {"A": "*", ...}oder [["A", "*"], ...]) sein.

Sie können davon ausgehen, dass eine Zahl niemals durch eine andere Zahl geteilt wird, durch die sie nicht teilbar ist.

Da es sich um Code-Golf , der kürzeste Code in Bytes gewinnt.

Testfälle:

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/

MATL , 53 Bytes

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

Verwendet die aktuelle Version (10.1.0)

EDIT (12. Juni 2016): Anpassung an Sprachänderungen, Y}nach gund 1L3$)nach ersetzen Y). Der unten stehende Link enthält diese Änderungen

Probieren Sie es online!

Erläuterung

Dies testet alle möglichen Permutationen der vier Operatoren in einer Schleife, bis eine Permutation alle Gleichungen wahr macht.

Um zu testen, ob Gleichungen wahr sind, wird ein regulärer Ausdruck angewendet, um die vier Buchstaben durch die Operatoren zu ersetzen (in der Reihenfolge, die von der aktuellen Permutation vorgegeben wird), und die Zeichenfolge wird in Zahlen umgewandelt (ausgewertet). Dies ergibt ein Array mit so vielen Zahlen wie Gleichungen, in denen Gleichungen, die wahr sind, 1und Gleichungen, die falsch sind, werden 0. Wenn dieser Vektor nur 1Werte enthält , sind wir fertig.

Die gefundene Lösung weist den vier Buchstaben Operatoren zu, aber nicht alle müssen in der Eingabe enthalten sein. Daher wird ein letzter Test durchgeführt, um nicht verwendete Buchstaben (und deren übereinstimmende Operatoren) zu verwerfen.

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

Python, 278 Zeichen

Meine erste Antwort auf Code Golf ...

Es ist nur eine Funktion, die einen Brute-Force-Algorithmus implementiert. Sie bezeichnen ihn als Übergabe der Gleichungszeichenfolge.

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

JavaScript (ES6), 213 208 Byte

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]:"")

Erläuterung

Eingabe und Ausgabe sind Zeichenfolgen.

Definiert eine Funktion f die gleichzeitig als rekursive Funktion zum Generieren aller Permutationen der Operatoren und zum Testen vollständiger Permutationen mit den Eingabegleichungen verwendet wird 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]:"")

Prüfung

Test verwendet keine Standardargumente für die Browserkompatibilität.

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>