Präambel

Ganzzahlen sind immer entweder gerade oder ungerade . Gerade ganze Zahlen sind durch zwei teilbar, ungerade ganze Zahlen nicht.

Wenn Sie zwei Ganzzahlen hinzufügen, können Sie ableiten, ob das Ergebnis gerade oder ungerade ist, je nachdem, ob die Summanden gerade oder ungerade waren:

• Gerade + Gerade = Gerade
• Gerade + Ungerade = Ungerade
• Ungerade + Gerade = Ungerade
• Ungerade + Ungerade = Gerade

Wenn Sie zwei Ganzzahlen multiplizieren, können Sie auch ableiten, ob das Ergebnis gerade oder ungerade ist, je nachdem, ob die Faktoren gerade oder ungerade waren:

• Gerade * Gerade = Gerade
• Gerade * Ungerade = Gerade
• Ungerade * Gerade = Gerade
• Ungerade * Ungerade = Ungerade

Wenn Sie also die Gleichmäßigkeit oder Ungleichmäßigkeit aller Variablen in einem mathematischen Ausdruck kennen, bei dem es nur um Addition und Multiplikation geht, können Sie ableiten, ob das Ergebnis gerade oder ungerade ist.

Zum Beispiel können wir zuversichtlich sagen, dass dies (68 + 99) * 37eine Ungerade ergibt, weil ein gerades Plus eine ungerade ( 68 + 99) eine ungerade ist, und dass ungerade mal eine andere ungerade ( odd * 37) eine ungerade ergibt.

Herausforderung

Schreiben Sie ein Programm oder eine Funktion, die nur eine Zeichenfolge mit den vier Zeichen enthält eo+*. Diese Zeichenfolge stellt einen mathematischen Ausdruck dar, der in Präfixnotation angegeben wird und nur Addition ( +) und Multiplikation ( *) umfasst. Jedes erepräsentiert eine beliebige gerade Zahl und jedes orepräsentiert eine beliebige ungerade Zahl.

Ihre Aufgabe ist es, den Ausdruck, Druck oder Rückgabe eines einzigen zu vereinfachen eoder obasierend darauf , ob das Ergebnis des Ausdrucks gerade oder ungerade ist .

Sie können davon ausgehen, dass die Eingabe immer in gültiger Präfixnotation erfolgt. Insbesondere werden hinter jedem +und *immer zwei entsprechende Operanden vorkommen. Diese Operanden können ein einzelnes eoder ooder ein anderes +oder ein *Ausdruck sein, der wiederum Operanden enthält.

Beispielsweise *+eookönnte die Eingabe als mul(add(e, o), o)oder (e + o) * oin normaler Infixnotation gelesen werden . Das eund das erste osind die Operanden, die dem entsprechen +, +eound das letzte osind die Operanden, die dem entsprechen *.

Zur Verdeutlichung hier einige ungültige Eingaben mit falscher Präfixnotation:

eo
ooe
o+e
ee*
+*oe
+e*o

Eine einzelne nachgestellte Zeile in der Ausgabe ist in Ordnung, ansonsten sollte nur eine egerade oder oungerade Zeile ausgegeben werden.

Der kürzeste Code in Bytes gewinnt.

Testfälle

^{(Leerzeilen dienen nur zur optischen Trennung ähnlicher Fälle.)}

e -> e
o -> o

+ee -> e
+eo -> o
+oe -> o
+oo -> e
*ee -> e
*eo -> e
*oe -> e
*oo -> o

+e+ee -> e
+e+eo -> o
+e+oe -> o
+e+oo -> e
+e*ee -> e
+e*eo -> e
+e*oe -> e
+e*oo -> o

+o+ee -> o
+o+eo -> e
+o+oe -> e
+o+oo -> o
+o*ee -> o
+o*eo -> o
+o*oe -> o
+o*oo -> e

*e+ee -> e
*e+eo -> e
*e+oe -> e
*e+oo -> e
*e*ee -> e
*e*eo -> e
*e*oe -> e
*e*oo -> e

*o+ee -> e
*o+eo -> o
*o+oe -> o
*o+oo -> e
*o*ee -> e
*o*eo -> e
*o*oe -> e
*o*oo -> o

++eee -> e
++eeo -> o
++eoe -> o
++eoo -> e
++oee -> o
++oeo -> e
++ooe -> e
++ooo -> o

+*eee -> e
+*eeo -> o
+*eoe -> e
+*eoo -> o
+*oee -> e
+*oeo -> o
+*ooe -> o
+*ooo -> e

*+eee -> e
*+eeo -> e
*+eoe -> e
*+eoo -> o
*+oee -> e
*+oeo -> o
*+ooe -> e
*+ooo -> e

**eee -> e
**eeo -> e
**eoe -> e
**eoo -> e
**oee -> e
**oeo -> e
**ooe -> e
**ooo -> o

+e+e+e+ee -> e
+o+o+o+oo -> o
*e*e*e*ee -> e
*o*o*o*oo -> o
+e+o+e+oe -> e
+o+e+o+eo -> o
*e*o*e*oe -> e
*o*e*o*eo -> e
+e*e+e*ee -> e
+o*o+o*oo -> o
*e+e*e+ee -> e
*o+o*o+oo -> o

+**++*+*eeoeeooee -> e
+**++*+***eooeoeooeoe -> e
+**+***+**++**+eooeoeeoeeoeooeo -> o

+e*o*e**eoe -> e
+*e+e+o+e**eeoe -> e
**o++*ee*++eoe*eo+eoo -> o

CJam, 18 17 13 Bytes

Danke an aditsu für das Speichern von 4 Bytes.

qW:O%eu~"eo"=

Probieren Sie die Testsuite hier aus. (Die Testsuite ist zu lang für den Permalink. Kopieren Sie sie einfach aus der Herausforderungsspezifikation.)

Erläuterung

q     e# Read the input.
W:O   e# Push a -1 and store it in variable O.
%     e# Use the -1 to reverse the string, because CJam's stack-based nature and the
      e# commutativity of the operators means we can evaluate the code in postfix notation.
eu    e# Convert the string to upper case, turning 'e' into 'E' (a variable with even value
      e# 14) and 'o' into 'O' (which we've stored the odd value -1 in).
~     e# Evaluate the string as CJam code, leaving the result on the stack.
"eo"= e# Use the result as an index into the string "eo". CJam's indexing is cyclic so it
      e# automatically takes inputs modulo 2. Negative indices also work as expected.

Pyth, 16 bis 14 Bytes

@"eo".vjdXzGU9

Pyth kann selbst einen String in Pyth-Syntax auswerten. Deshalb ersetze ich eund omit 4und 5. Die Auswertung gibt mir dann eine gerade oder ungerade Zahl und ich kann das Ergebnis leicht ausdrucken.

Probieren Sie es online aus: Demo oder Test Suite

Erläuterung:

@"eo".vjdXzGU9   implicit: z = input string
         XzGU9   replace "e" in z with 4 and "o" with 5
       jd        put a space between each char
     .v          evaluate it (Pyth style)
@"eo"            and print "e" or "o"

Zusätzliche Erklärung zum Ersetzen. Gist eine mit dem Alphabet initialisierte Variable abc...xyz. U9ist die Liste [0, 1, ..., 8]. XzGU9Ersetzt die Buchstaben des Alphabets durch die Werte der Liste. Also awird ersetzt durch 0, bmit 1, ..., emit 4, ..., imit 8, jmit 0, ... und omit 5. Deshalb werde ich edurch eine gerade und oeine ungerade Zahl ersetzt. Alle anderen Ersetzungen haben überhaupt keine Wirkung.

Perl, 50 45 40 Zeichen

(39 Zeichen Code + 1 Zeichen Befehlszeilenoption.)

1while s/\+oe|\+eo|\*oo/o/||s/\W\w\w/e/

Probelauf:

bash-4.3$ echo -n '**o++*ee*++eoe*eo+eoo' | perl -pe '1while s/\+oe|\+eo|\*oo/o/||s/\W\w\w/e/'
o

Retina , 29 Bytes

(+`\*oo|\+(eo|oe)
o
\W\w\w
e

Für die praktische Version mit einer Datei wird das -sFlag verwendet.

Wir tauschen ungerade Ausdrücke ( *oo, +oe, +eo) zu , obis wir können, dann tauschen Sie die restlichen Symbol-Buchstaben-Buchstaben - Ausdrücken e. Wir wiederholen dies, bis wir können und der letzte Buchstabe unsere Ausgabe ist.

(Diese Lösung ähnelt der Perl-Antwort von manatwork .)

Probieren Sie es online! (von Dennis)

Python 2, 90

def f(s):i=iter(s);a=next(i);return(a>'a')*a or'oe'[f(i)==f(i)if'*'<a else'e'in f(i)+f(i)]

Die iterFunktion ist eine gute Möglichkeit, die Eingabezeichenfolge in eine FIFO-Warteschlange zu verwandeln, die sich daran erinnert, wie viel der Zeichenfolge über Aufrufe von analysiert wurde f. Es ist idempotent, daher ist es harmlos, es erneut aufzurufen, wenn die Eingabe bereits ein Iterator und keine Zeichenfolge ist. Die hintere Hälfte der Antwort, die mit or'oe'... beginnt, scheint golfen zu können, aber ich konnte nichts finden.

-1 dank Sp3000.

Mathematica, 91 84 Bytes

#//.s_:>s~StringReplace~{"+ee"|"+oo"|"*ee"|"*eo"|"*oe"->"e","+eo"|"+oe"|"*oo"->"o"}&

Auf der Suche nach einer Möglichkeit, dies zu komprimieren ...

Python 2, 80 Bytes

def f(s,e=0,o=1):i=iter(s);a=next(i);return(a>'a')*a or'eo'[eval(f(i)+a+f(i))%2]

Dies wird auf feersum eingebaute sehr kluge Antwort , die eine verwendeten iterpolnisch-Notation Operationen zu implementieren. Die neue Idee besteht darin eval, die Ausdrücke auszuwerten +und *mit eval(f(i)+a+f(i)), wo der Operator azwischen den rekursiven Ergebnissen eingefügt wird. Das eval verwendet die Bindungen e=0,o=1in den optionalen Funktionsargumenten. Die Ausgabe erfolgt dann mod 2.

C 79 Bytes

Einfache Rekursion. Beruht auf einigen (zufälligen?) Bitweisen Eigenschaften der vier zulässigen Eingabezeichen.

f(){int c=getchar();return c&4?c:c&1?f()^f()^'e':f()&f();}main(){putchar(f());}

Shell + GNU-Dienstprogramme, 33

dc -eFo`rev|tr oe OK`2%p|tr 10 oe

Die Eingabe erfolgt über STDIN.

Dies macht den gleichen Trick wie das Umkehren der Eingabe und das Auswerten mit einem stapelbasierten Rechner - in diesem Fall dc. Wir könnten eund odurch 0und ersetzen 1, aber dann müssten Leerzeichen eingefügt werden, um ein gieriges Parsen der Ziffern in die falschen Zahlen zu verhindern.

Stattdessen ewird ersetzt durch Kden dcBefehl zum Übertragen der aktuellen Genauigkeit zum Stapel, der standardmäßig 0 ist. Und owird ersetzt durch Oden dcBefehl zum Übertragen der aktuellen Ausgabebasis zum Stapel. Dies muss ungerade sein, also setzen wir es mit auf 15, Fobevor wir etwas anderes in dc machen.

Dann geht es einfach darum, Mod 2 zu nehmen und zu drucken 2%p. Die einzig möglichen Werte sind now 0und 1, es spielt also keine Rolle, dass die Ausgabebasis 15 ist. Dann wird trzurück in ooder übersetzt e.

Ich mag es, wenn du deine Augen zusammenknickst, diese Quelle sieht fast so aus dc Forever OK.

Im Ernst , 24 Bytes

,R'2'e(Æ'1'o(Æ£ƒ'e'o2(%I

Effizientere Stack-Manipulationen könnten das wahrscheinlich kürzer machen, aber ich bin zufrieden damit.

Nimmt Eingaben als Zeichenfolge wie "+*oee"

Online ausprobieren (Eingabe muss manuell erfolgen)

Erläuterung:

,R        get input and reverse it
'2'e(Æ    replace all "e"s with "2"s
'1'o(Æ    replace all "o"s with "1"s
£ƒ        cast as function and call
'e'o2(%I  push "e" if result is even, else "o"

Ruby, 61 Bytes

Verwenden von Parsing rekursiver Abstammung und Boolescher Algebra.

def f
gets(1)==?+?f^f : ~/\*/?f&f : $_==?o
end
puts f ? ?o:?e

Die Funktion liest jeweils ein Zeichen von stdin. Wenn es a +oder a liest *, ruft es sich zweimal auf, um ungerade oder gerade zu bestimmen. Die Funktion gibt truefür ungerade und falsefür zurück even. Die ^ XOR- und & AND- Operatoren werden verwendet, um die "Seltsamkeit" von Additions- bzw. Multiplikationsausdrücken zu bestimmen.

Hier ist eine ungolfed Version:

def f
  x = gets(1)
  case x
  when '+'
    f ^ f
  when '*'
    f & f
  else
    x == 'o'
  end
end

puts f ? 'o' : 'e'

_{Vielen Dank an @Shel für den Hinweis auf einen Fehler in der ursprünglichen Version.}

Minkolang 0,14 , 40 Bytes

Ich habe versucht, eine clevere Bewertungsmethode anzuwenden, aber es hat sich herausgestellt, dass der Programmzähler keine Werte erreicht, die der Codebox außerhalb des ursprünglichen Bereichs hinzugefügt wurden. Also habe ich eine weniger clevere Bewertungsmethode angewendet. : P

$o"eo+*"r0I4-[4g1Z2*1F]l*"e"+O.
0f1f+f*f

Probieren Sie es hier aus.

Erläuterung

$o                                Read in whole input as characters
  "eo+*"                          Push these characters onto the stack (in reverse order)
        r                         Reverse the stack
         I4-                      Push the length of the stack - 4
            [                     For loop; pop n and repeat that many times
             4g                   Get the item at the fourth index and put it on top
               1Z                 Pops n and pushes first index of n in stack
                 2*               Multiply by 2
                   1F             Gosub; goes to codebox(2n,1) to be returned to
                     ]            Close for loop
                      l*          Multiply by 10
                        "e"+      Add 101 ("o" is 111)
                            O.    Output as character and stop.
0f1f+f*f                          Does the appropriate operation then returns to F

JavaScript, 110 106 94 Bytes

while(i.length>2)i=i.replace(/([+*][eo]{2})/,(o,e)=>{return"+oe+eo*oo".indexOf(o)<0?"e":"o"});

Mit Sicherheit nicht die kleinste Lösung, aber wahrscheinlich die kleinste Lösung, die in einer ausführlichen Sprache wie JavaScript möglich ist!

O , 24 20 19 18 Bytes

i`2:e;1:o;~2%'o'e?

Nimmt die Eingabe, kehrt es weist eauf 2 und oauf 1 und trägt ihn zu Tumblr es als O - Code auswertet.

Erläuterung:

i` Holen Sie sich die Eingabe und kehren Sie sie um, da O die Postfix-Notation verwendet
2: e; Weisen Sie "e" zu 2
1: o; Weisen Sie "o" 1 zu
~ 2% Auswerten und überprüfen, ob das Ergebnis gerade ist
'o'e? Geben Sie 'e' aus, wenn gerade, 'o', wenn ungerade

GNU Sed, 36

:
s/*oo\|+eo\|+oe/o/
t
s/\W\w\w/e/
t

Nach der Buchung habe ich diesen genau den gleichen Ansatz wie @ Manatwork Perl Antwort und Retina des @ randomra Antwort . Ich schätze, ich kann genauso gut den ganzen Weg gehen und sie auch ausleihen \W\w\w.

Vielen Dank an @Ruud für das Abschneiden von 4 Bytes.

Haskell, 160 Bytes

Rufen Sie an f.

f=until((==1).l)r
r s|l s<3=s|3#s?o=r('o':3%s)|3#s?sequence["+*","oe","oe"]=r('e':3%s)|0<1=1#s++r(1%s)
l=length
(#)=take
(%)=drop
(?)=elem
o=["+eo","+oe","*oo"]

JavaScript, 92 71 Bytes

f=i=>i>"0"?i:f(i.replace(/.[eo]{2}/,e=>"eo"[eval((e[1]>"e")+"^&"[+(e[0]<"+")]+(e[2]>"e"))]))

Es ist ein bisschen verschleiert, aber ich wollte etwas mit evalund bitweisen Operatoren machen. Kommentiert:

f = (i) => // function(i) { return
    i>"0"  // i[0] == "o" || i[0] == "e" :-) - the characters `*` and `+` are both <"0"
      ? i  // finish
      : f(i.replace( // recursively repeat with
          /.[eo]{2}/, // first occurrence of "something" followed by two values
          (e) =>    // replaced by
              "eo"[ // string indexing
                eval(
                    (e[1]>"e")        // e[1] == "o" ? "true" : "false"
                  + "^&"[+(e[0]<"+")] // e[0] == "+" ? "^" : "&"
                  + (e[2]>"e")        // e[2] == "o" ? "true" : "false"
                )
              ]     // like eval(…) ? "o" : "e"
        ))

Die Wiederholung von (e[…]>"e")ärgert mich ein bisschen, aber das Folgende ist auch nicht besser (103 Bytes):

f=i=>i>"0"?i:f(i.replace(/e|o/g,x=>+(x>"e")).replace(/.\d\d/,e=>"eo"[eval(e[1]+"^&"[+(e[0]<"+")]+e[2])]))

Letztendlich ist der Ansatz von @ Arkain mit einfachem Teilstring-Matching überlegen. Mit einigen Optimierungen zu einer Funktion gemacht:

f=i=>i>"0"?i:f(i.replace(/.[eo]{2}/,v=>"eo"[+"+oe+eo*oo".includes(v)]))

Dart, 173 Bytes

f(i){var l=i.split(''),e='e',o='o';g(p){if(l[p]!=e&&l[p]!=o){var x=p+1,y=p+2;g(x);g(y);l[p]=l[p]=='+'?l[x]!=l[y]?o:e:l[x]==o?l[y]:e;l.removeRange(x,p+3);}}g(0);print(l[0]);}

Das ist nicht wettbewerbsfähig, aber was auch immer. Der Kern der Lösung besteht darin, beginnend mit 0 jeden Operator rekursiv durch die Auswertung des diesem Operator folgenden Zeichenpaars zu ersetzen und diese Zeichen dann aus der Liste zu entfernen.

Haskell, 231 Bytes

Hier ist ein Ansatz mit einer seriösen Sprache;)

Golf Version:

p(s:_)[]=s
p s(x:y)=p(r$x:s)y
r[]=[]
r('e':'e':'+':x)=r$'e':x
r('e':'o':'+':x)=r$'o':x
r('o':'e':'+':x)=r$'o':x
r('o':'o':'+':x)=r$'e':x
r('e':'e':'*':x)=r$'e':x
r('e':'o':'*':x)=r$'e':x
r('o':'e':'*':x)=r$'e':x
r('o':'o':'*':x)=r$'o':x
r x=x

Beispiel:

*Main> p [] "+**+***+**++**+eooeoeeoeeoeooeo"
'o'

Ungolfed und ziemlich umfassende Version:

type Stack = String

parse :: String -> Char
parse = parse' []

parse' :: Stack -> String -> Char
parse' (s:_) []     = s
parse' s     (x:xs) = parse' (reduce $ x:s) xs

reduce :: Stack -> Stack
reduce [] = []
reduce ('e':'e':'+':xs) = reduce $ 'e':xs
reduce ('e':'o':'+':xs) = reduce $ 'o':xs
reduce ('o':'e':'+':xs) = reduce $ 'o':xs
reduce ('o':'o':'+':xs) = reduce $ 'e':xs
reduce ('e':'e':'*':xs) = reduce $ 'e':xs
reduce ('e':'o':'*':xs) = reduce $ 'e':xs
reduce ('o':'e':'*':xs) = reduce $ 'e':xs
reduce ('o':'o':'*':xs) = reduce $ 'o':xs
reduce xs               = xs

Beispiel:

*Main> parse "+**+***+**++**+eooeoeeoeeoeooeo"
'o'

Features: Pattern Matching und Rekursion.

Jolf, 11 Bytes

(Nicht konkurrenzfähig, da die Sprache die Frage datiert.) Probieren Sie es hier aus!

FVyAi"oe"@\x12

(Ersetzen Sie \x12durch das tatsächliche Zeichen \x12. Dies sollte automatisch im Interpreter erfolgen.)

Erläuterung:

FVyAi"oe"@\x12
    i          input
          \x12 character 12
         @     char code at
   A "oe"      replace all os with 1s and all es with 2s
  y            eval as jolf, returning the answer
 V             return parity "even" or "odd"
F              get first character
               implicit output

Python 3, 171 145 135 Bytes

Nicht wettbewerbsfähig, aber ich hatte Spaß daran, also konnte ich es einfach nicht für mich behalten. Im Gegensatz zum (sehr cleveren) rekursiven Iterator-Python-Eintrag von feersum kehrt dieser die Eingabe um und führt dann ein gutes altes stapelbasiertes Parsen der umgekehrten polnischen Notation durch.

def p(i):
 s=[]
 for c in i[::-1]:
  s+=[c>'e'if c>'a'else getattr(s.pop(),'__'+('axnodr'[c>'*'::2])+'__')(s.pop())]
 return'eo'[s[0]]

Haskell, 98 94 Bytes

Es tut mir leid, Sie mit einem weiteren Versuch von Haskell zu belästigen. wollte nur beweisen, dass es in weniger als 100 Bytes sehr gut möglich ist.

p(c:s)|any(<'a')s=p(c:p s)
p('+':x:y:s)|x/=y='o':s
p('*':'o':s)=s
p(c:_:_:s)|c<'a'='e':s
p s=s

Definiert eine Funktion p, die einen gültigen Ausdruck als Parameter akzeptiert und das Ergebnis als Zeichenfolge der Länge 1 zurückgibt.

Beispiel:

*Main> p "**o++*ee*++eoe*eo+eoo"
"o"

Die Funktion reduziert wiederholt den Operator ganz rechts in der Zeichenfolge, bis keine Operatoren mehr übrig sind.

Add ++ , 46 Bytes

D,g,@,d"oe"$eA"e"=+o
D,f,@,bR€gbU32CjbV2%"eo":

Probieren Sie es online!

In der Fußzeile werden einfach alle Beispieleingaben und ihre entsprechenden Ausgaben aufgelistet.

Wie es funktioniert

Wie ein Verlust der Antworten hier, verwendet dies Ersatz und Bewertung. Unsere Hauptfunktion ist fund gist eine Hilfsfunktion. Wir werden "*e*o*e*oe"(was ist e) als Beispiel verwenden.

fBeginnt damit, die Eingabezeichenfolge zu nehmen und sie umzukehren "eo*e*o*e*". Wir bilden dann gjedes Element ab:

gBeginnt mit dem Duplizieren des Arguments, um eine Kopie bis zum letzten Befehl aufzubewahren. Wir prüfen dann, ob das Argument in der Zeichenfolge enthalten ist "oe", und geben 1 für Buchstaben und 0 für *oder +. Wir drücken dann das Argument erneut und prüfen, ob es gleich ist "e". Dieses Ergebnis wird dann zur vorherigen Prüfung hinzugefügt. Dies ergibt 0 für entweder *oder +, 1 für ound 2 für e. Wir nehmen dann das logische ODER zwischen diesem Wert und dem Argument. Wenn der Wert 0 ist , wird er durch das Argument (dh *oder +) ersetzt, andernfalls bleibt er unverändert (dh 1 und 2 ).

Dies konvertiert alle Buchstaben in der Umkehrung der Eingabe in einen numerischen Wert. Wir verbinden dann jedes Element durch Leerzeichen, um sicherzustellen, dass die Ziffern nicht verkettet werden. In unserem Beispiel ergibt dies die Zeichenfolge "2 1 * 2 * 1 * 2 *". Wir können dies dann unter Verwendung der Postfix-Notation von Add ++ auswerten, was 8 ergibt . Wir nehmen dann die Parität dieses Werts und ergeben entweder 0 für gerade Zahlen und 1 für ungerade Zahlen, bevor wir in die Zeichenfolge indexieren "eo"und den entsprechenden Buchstaben zurückgeben.