Преамбула

Цілі ліки завжди або парні, або непарні . Навіть цілі числа діляться на два, непарні цілі числа - ні.

Додавши два цілих числа, ви можете зробити висновок про те, чи буде результат парним чи непарним, виходячи з того, чи були збитки парними чи непарними:

• Рівний + рівний = рівний
• Нечетно + непарне = непарне
• Непарне + парне = Непарне
• Непарний + Непарний = Непарний

Аналогічно, при множенні двох цілих чисел ви можете зробити висновок про те, чи буде результат парним чи непарним на основі того, чи були коефіцієнти парними чи непарними:

• Навіть * Навіть = Навіть
• Непарний = Непарний
• Непарне * Нечетно = Четне
• Непарний * Непарний = Непарний

Таким чином, якщо ви знаєте парність чи непарність усіх змінних у математичному виразі, що включає лише додавання та множення, ви можете зробити висновок, чи результат буде парним чи непарним.

Наприклад, ми можемо впевнено сказати, що це (68 + 99) * 37призводить до непарного, оскільки парний плюс непарний ( 68 + 99) є непарним, а непарний раз інший непарний ( odd * 37) дає непарний.

Виклик

Напишіть програму або функцію, яка містить рядок, що містить лише чотири символи eo+*. Цей рядок представляє математичний вираз, поданий у позначеннях префіксів, що включає лише додавання ( +) та множення ( *). Кожен eпредставляє деяке довільне парне число, і кожен oпредставляє деяке довільне непарне число.

Ваше завдання - спростити вираз, роздрукувати або повернути сингл eабо oна основі того, чи є результат виразу парним чи непарним.

Можна припустити, що вхід завжди буде у дійсній позначці префікса. Зокрема, кожен +і *завжди матиме два відповідні операнди, що виникають після нього. Ці операнди можуть бути один eабо o, або інший , +або *вираз , яке в свою чергу , має операнди.

Наприклад, вхід *+eooможе бути прочитаний як mul(add(e, o), o)або (e + o) * oу звичайній інфіксації . Перші eта oоперанди відповідають операндам +, а +eoостанні o- операндами, що відповідають *.

Для того, щоб зрозуміти, ось кілька недійсних даних, які мають неправильне позначення префікса:

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

Один єдиний новий рядок у висновку - це добре, але в іншому випадку все, що повинно виводитися, є рівним eдля парного або oнепарного.

Виграє найкоротший код у байтах.

Випробування

^{(Порожні рядки мають лише допомогти візуально розділити подібні випадки.)}

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 байт

Завдяки aditsu за збереження 4 байтів.

qW:O%eu~"eo"=

Спробуйте набір тестів тут. (Тестовий набір занадто довгий для постійної посилання. Просто скопіюйте їх із специфікації виклику.)

Пояснення

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 14 байт

@"eo".vjdXzGU9

Pyth може сам оцінити рядок, тобто в синтаксисі Pyth. Тому я замінюю eі oна 4і 5. Тоді оцінка дасть мені парне або непарне число, і я можу легко надрукувати результат.

Спробуйте в Інтернеті: Демонстрація або Тестовий набір

Пояснення:

@"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"

Додаткове пояснення заміни. Gє змінною, ініціалізованою з алфавітом abc...xyz. U9це перелік [0, 1, ..., 8]. XzGU9замінює літери алфавіту значеннями списку. Тож aзаміняється на 0, bз 1, ..., eз 4, ..., iз 8, jз 0, ... і oна 5. Тому мене eзамінюють парним числом і oнепарним числом. Усі інші заміни взагалі не мають ефекту.

Perl, 50 45 40 символів

(Код 39 символів + параметр командного рядка з 1 символом.)

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

Проба зразка:

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

Сітківка , 29 байт

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

Для зручної версії одного файлу використовується -sпрапор.

Ми помінятися непарні вираження ( *oo, +oe, +eo) до , oпоки ми не можемо, а потім поміняти залишилися символ літери букв виразу e. Ми повторюємо це, поки не зможемо, і остання літера є нашим результатом.

(Це рішення схоже на відповідь Perl на маніпуляцію .)

Спробуйте в Інтернеті! (автор Денніс)

Пітон 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)]

Ця iterфункція - хороший спосіб перетворити рядок введення у чергу FIFO, яка запам'ятовує, яка частина рядка була проаналізована на виклики f. Це ідентично, тому нешкідливо викликати його знову, коли вхід є вже ітератором, а не рядком. Затяжна половина відповіді, що починається з or'oe'... здається, що це повинно бути погработним, але я нічого не міг знайти.

-1 завдяки Sp3000.

Математика, 91 84 байт

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

Шукаєте спосіб стиснення цього ...

Python 2, 80 байт

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]

Це побудовано на дуже розумній відповіді feersum, яка використовує iterдля здійснення операцій з польською нотацією. Нова ідея полягає у використанні evalдля оцінки виразів +і *з eval(f(i)+a+f(i)), де оператор aрозміщується в інфікуванні між рекурсивними результатами. Евал використовує прив'язки e=0,o=1в аргументах додаткової функції. Потім виводиться mod 2.

C, 79 байт

Пряма рекурсія. Покладається на деякі (збігаються?) Побітові властивості чотирьох дозволених вхідних символів.

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

Комунальні послуги Shell + GNU, 33

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

Вхід береться від STDIN.

Це робить той самий трюк повернення вводу та оцінки за допомогою калькулятора на основі стека - у цьому випадку dc. Ми могли б замінити eі oна, 0і 1тоді, але тоді потрібно буде вставити пробіли, щоб запобігти жадібному розбору цифр на неправильні числа.

Замість eзамінюється Kяка є dcкомандою , щоб підштовхнути поточну точність в стек, який за замовчуванням дорівнює 0. А oзамінюється Oяка є dcкомандою , щоб підштовхнути поточну вихідну базу в стек. Це має бути непарним, тому ми встановимо його до 15, Foперш ніж робити що-небудь ще в DC.

Тоді просто питання приймати мод 2 та друкувати 2%p. Єдині можливі значення тепер 0і 1, тому не має значення , що вихідна база 15. Потім trперекладається назад oабо e.

Мені подобається, що якщо ти косиш очима, це джерело майже схоже dc Forever OK.

Серйозно , 24 байти

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

Більш ефективна маніпуляція зі стеком, можливо, може зробити це коротшим, але я це задоволений.

Приймає дані як рядок, як "+*oee"

Спробуйте в Інтернеті (введення потрібно ввести вручну)

Пояснення:

,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"

Рубін, 61 байт

Використання рекурсивного розбору спуску та булевої алгебри.

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

Функція зчитує один символ із stdin за раз. Якщо він читає a +або a *, він дзвонить собі двічі, щоб визначити непарне або парне. Функція повертається trueдля непарних і falseдля even. Оператори ^ XOR і & AND використовуються для визначення відповідно "непарності" виразів додавання та множення.

Ось незворушена версія:

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

puts f ? 'o' : 'e'

_{Дякуємо @Shel за вказівку на помилку в початковій версії.}

Мінколанг 0,14 , 40 байт

Я намагався зробити розумний метод eval, але виявляється, що будь-які значення, додані до кодової скриньки поза вихідним простором, ніколи не досягнуть лічильником програми. Тому я зробив менш розумний метод eval. : P

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

Спробуйте тут.

Пояснення

$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 байт

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

Безумовно, не найменше рішення, але, мабуть, найменше рішення можливе на багатослівній мові, як JavaScript!

О , 24 20 19 18 байт

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

Приймає вхідний сигнал, змінює його, призначає eна 2 і oна 1 і повідомлення його Tumblr оцінює його в якості коду виведення.

Пояснення:

i` Отримайте введення та поверніть його назад, оскільки O використовує позначення постфікса
2: е; Призначте `e` до 2
1: о; Призначте `o` до 1
~ 2% Eval і перевірте, чи результат рівний
'ой? Виведіть "e", якщо парне, "o", якщо непарне

GNU Sed, 36

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

Після відправки я побачив такий самий підхід , як @ manatwork - х Perl відповідь і Retina відповідь @ randomra в . Тому я здогадуюсь, що я можу пройти весь шлях і позичити їх \W\w\wтакож.

Дякуємо @Ruud за бриття 4-х байт.

Haskell, 160 байт

Дзвінок 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 байт

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

Це трохи заплутано, але я хотів щось зробити за допомогою evalоператорів та побітних операцій. Повідомлення:

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

Повторення (e[…]>"e")мене трохи дратує, але наступне теж не краще (103 байти):

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

Отже, врешті-решт, підхід @ Аркайна з простим узгодженням підрядків - це надмірно. Виконаний у функції, з деякими оптимізаціями:

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

Дарт, 173 байти

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]);}

Це не конкурентоспроможно, але все одно. Суть рішення, починаючи з 0, рекурсивно замінює кожного оператора на оцінку парою символів, що слідує за цим оператором, а потім видаляє ці символи зі списку.

Haskell, 231 байт

Ось підхід із використанням серйозної мови;)

Версія для гольфу:

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

Приклад:

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

Бездоганний і досить вичерпний варіант:

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

Приклад:

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

Особливості: узгодження шаблонів та рекурсія.

Джольф, 11 байт

(Неконкурентоспроможний, оскільки мова подає запитання.) Спробуйте це тут!

FVyAi"oe"@\x12

(Замініть \x12фактичним символом \x12. Це слід зробити автоматично в перекладачі.)

Пояснення:

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

Пітон 3, 171 145 135 байт

Не конкурентоспроможний, але мені це було весело, тому я просто не міг утримати його. На відміну від (дуже розумного) рекурсивно-ітераторного запису Python за допомогою feersum , цей реверсує вхід, а потім робить гарний старий хороший синтаксичний аналіз зворотної польської нотації.

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 байт

Вибачте, що вас турбує ще одна спроба Haskell; просто хотів довести, що це дуже добре можливо менше ніж 100 байт.

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

Визначає функцію, pяка приймає будь-який дійсний вираз як параметр і повертає результат у вигляді рядка довжиною 1.

Приклад:

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

Функція працює шляхом багаторазового зменшення правого правого оператора в рядку, поки не залишиться жодного оператора.

Додайте ++ , 46 байт

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

Спробуйте в Інтернеті!

Нижній колонтитул просто перелічує всі приклади входів та їх відповідні виходи.

Як це працює

Як і втрачені тут відповіді, для цього використовується заміна та оцінка. Наша основна функція - це fі gє допоміжною функцією. Ми будемо використовувати "*e*o*e*oe"(що є e) як приклад.

fпочинається з прийняття вхідного рядка та його реверсування, отримання "eo*e*o*e*". Потім ми картаємо gкожен елемент:

gпочинається з дублювання аргументу, щоб зберегти копію до остаточної команди. Потім ми перевіряємо, чи є аргумент у рядку "oe", отримуючи 1 для літер та 0 для *або +. Потім знову натискаємо на аргумент і перевіряємо, чи дорівнює він "e". Потім цей результат додається до попередньої перевірки. Це дає 0 для *або +, 1 для oі 2 для e. Потім ми беремо логічне АБО між цим значенням і аргументом. Якщо значення дорівнює 0 , воно замінюється аргументом (тобто *або +), інакше воно залишається таким, як є (тобто 1 і 2 ).

Це перетворює всі літери на звороті вводу в числове значення. Потім ми з'єднуємо кожен елемент пробілами, щоб цифри не були об'єднані. У нашому прикладі це дає рядок "2 1 * 2 * 1 * 2 *". Потім ми можемо оцінити це, використовуючи нотацію постфікса Add ++, отримуючи 8 . Потім ми беремо паритет цього значення, отримуючи або 0 для парних чисел, і 1 для непарних чисел, перед тим як індексувати в рядок "eo"і повертати відповідну букву.