Lời nói đầu

Số nguyên luôn luôn là số chẵn hoặc lẻ . Ngay cả số nguyên cũng chia hết cho hai, số nguyên lẻ thì không.

Khi bạn thêm hai số nguyên, bạn có thể suy ra kết quả sẽ là chẵn hay lẻ dựa trên việc triệu hồi là chẵn hay lẻ:

• Chẵn + Chẵn = Chẵn
• Chẵn + lẻ = lẻ
• Chẵn + Chẵn = lẻ
• Tỷ lệ cược + lẻ = chẵn

Tương tự như vậy, khi bạn nhân hai số nguyên, bạn có thể suy ra kết quả sẽ là chẵn hay lẻ dựa trên việc các yếu tố là chẵn hay lẻ:

• Chẵn * Chẵn = Chẵn
• Chẵn * lẻ = chẵn
• Chẵn * lẻ = chẵn
• Tỷ lệ lẻ * lẻ = lẻ

Do đó, nếu bạn biết độ chẵn hoặc lẻ của tất cả các biến trong biểu thức toán học chỉ liên quan đến phép cộng và phép nhân, bạn có thể suy ra kết quả sẽ là chẵn hay lẻ.

Ví dụ, chúng ta có thể tự tin nói rằng (68 + 99) * 37kết quả là số lẻ vì số chẵn cộng với số lẻ ( 68 + 99) là số lẻ và số lần lẻ đó một số lẻ khác ( odd * 37) cho số lẻ.

Thử thách

Viết chương trình hoặc hàm lấy trong một chuỗi chỉ chứa bốn ký tự eo+*. Chuỗi này biểu thị một biểu thức toán học được đưa ra trong ký hiệu tiền tố chỉ liên quan đến phép cộng ( +) và phép nhân ( *). Mỗi eđại diện cho một số số chẵn tùy ý, và mỗi ođại diện cho một số số lẻ tùy ý.

Nhiệm vụ của bạn là đơn giản hóa biểu thức, in hoặc trả về một ehoặc odựa trên kết quả của biểu thức là chẵn hay lẻ.

Bạn có thể giả định rằng đầu vào sẽ luôn ở trong ký hiệu tiền tố hợp lệ. Cụ thể, mỗi +và *sẽ luôn có hai toán hạng tương ứng xảy ra sau nó. Những toán hạng có thể là một single ehay o, hay cách khác +hoặc *biểu hiện mà lần lượt có toán hạng.

Ví dụ, đầu vào *+eoocó thể được đọc là mul(add(e, o), o), hoặc (e + o) * otrong ký hiệu trung bình thông thường . Các evà là người đầu tiên olà toán hạng tương ứng với +, và +eovà cuối cùng olà toán hạng tương ứng với *.

Để làm rõ, đây là một số đầu vào không hợp lệ có ký hiệu tiền tố không chính xác:

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

Một dòng mới duy nhất trong đầu ra là tốt, nhưng nếu không thì một số echẵn hoặc olẻ là tất cả những gì nên là đầu ra.

Mã ngắn nhất tính bằng byte thắng.

Các trường hợp thử nghiệm

^{(Các dòng trống chỉ để giúp phân tách trực quan các trường hợp tương tự.)}

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 byte

Cảm ơn aditsu đã lưu 4 byte.

qW:O%eu~"eo"=

Hãy thử bộ thử nghiệm ở đây. (Bộ kiểm tra quá dài cho permalink. Chỉ cần sao chép chúng từ thông số thử thách.)

Giải trình

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.

Bình thường, 16 14 byte

@"eo".vjdXzGU9

Pyth có thể tự đánh giá một chuỗi, đó là theo cú pháp Pyth. Vì vậy, tôi thay thế evà ovới 4và 5. Sau đó, việc đánh giá sẽ cho tôi một số chẵn hoặc lẻ và tôi có thể dễ dàng in kết quả.

Dùng thử trực tuyến: Trình diễn hoặc Test Suite

Giải trình:

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

Giải thích thêm cho sự thay thế. Glà một biến được khởi tạo với bảng chữ cái abc...xyz. U9là danh sách [0, 1, ..., 8]. XzGU9thay thế các chữ cái trong bảng chữ cái bằng các giá trị của danh sách. Vì vậy, ađược thay thế bằng 0, bvới 1, ..., evới 4, ..., ivới 8, jvới 0, ..., và ovới 5. Do đó, tôi eđược thay thế bằng một số chẵn và omột số lẻ. Tất cả các thay thế khác không có hiệu lực nào cả.

Perl, 50 45 40 ký tự

(Mã 39 ký tự + 1 ký tự tùy chọn dòng lệnh.)

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

Chạy mẫu:

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

Võng mạc , 29 byte

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

Đối với phiên bản một tệp thuận tiện, -scờ được sử dụng.

Chúng tôi trao đổi biểu hiện kỳ quặc ( *oo, +oe, +eo) để ođến khi chúng tôi có thể, sau đó trao đổi các biểu thức biểu tượng chữ chữ còn lại e. Chúng tôi lặp lại điều này cho đến khi chúng tôi có thể và một chữ cái cuối cùng là đầu ra của chúng tôi.

(Giải pháp này tương tự như câu trả lời Perl của manatwork .)

Hãy thử trực tuyến! (bởi Dennis)

Con trăn 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)]

Các iterchức năng là một cách tốt để làm cho chuỗi đầu vào vào một hàng đợi FIFO mà nhớ bao nhiêu của chuỗi đã được phân tích qua các cuộc gọi của f. Nó là idempotent, vì vậy sẽ vô hại khi gọi lại khi đầu vào đã là một trình vòng lặp chứ không phải là một chuỗi. Một nửa câu trả lời bắt đầu bằng or'oe'... có vẻ như nó có thể chơi được, nhưng tôi không thể tìm thấy bất cứ điều gì.

-1 nhờ Sp3000.

Toán học, 91 84 byte

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

Tìm kiếm một cách để nén ...

Python 2, 80 byte

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]

Điều này được xây dựng dựa trên câu trả lời rất thông minh của frageum sử dụng iterđể thực hiện các hoạt động ký hiệu Ba Lan. Ý tưởng mới là sử dụng evalđể đánh giá các biểu thức +và *với eval(f(i)+a+f(i)), nơi toán tử ađược đặt giữa các kết quả đệ quy. Eval sử dụng các ràng buộc e=0,o=1trong các đối số chức năng tùy chọn. Đầu ra sau đó được lấy mod 2.

C, 79 byte

Đệ quy đơn giản. Dựa vào một số thuộc tính bit (trùng hợp?) Của bốn ký tự đầu vào được phép.

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

Tiện ích Shell + GNU, 33

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

Đầu vào được lấy từ STDIN.

Điều này thực hiện cùng một thủ thuật đảo ngược đầu vào và đánh giá với một máy tính dựa trên ngăn xếp - trong trường hợp này dc. Chúng ta có thể thay thế evà obằng 0và 1, nhưng sau đó các khoảng trắng sẽ cần được chèn vào để ngăn phân tích các chữ số thành các số không chính xác.

Thay vào đó eđược thay thế bằng Kđó là dclệnh để đẩy độ chính xác hiện hành để ngăn xếp, mà theo mặc định là 0. Và ođược thay thế bằng Ođó là dclệnh để đẩy cơ sở sản lượng hiện tại vào stack. Điều này cần phải là số lẻ, vì vậy chúng tôi đặt nó thành 15 với Fotrước khi làm bất cứ điều gì khác trong dc.

Sau đó, nó chỉ đơn giản là vấn đề lấy mod 2 và in ấn 2%p. Các giá trị duy nhất có thể là bây giờ 0và 1, do đó, không có vấn đề gì khi cơ sở đầu ra là 15. Sau đó trdịch trở lại ohoặc e.

Tôi thích điều đó nếu bạn nheo mắt, nguồn này gần như là như thế dc Forever OK.

Nghiêm túc , 24 byte

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

Thao tác ngăn xếp hiệu quả hơn có thể có thể làm cho việc này ngắn hơn, nhưng meh, tôi hài lòng với nó.

Đưa đầu vào dưới dạng một chuỗi, như "+*oee"

Dùng thử trực tuyến (đầu vào phải được nhập thủ công)

Giải trình:

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

Sử dụng phân tích cú pháp gốc đệ quy và đại số boolean.

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

Hàm đọc một ký tự từ stdin tại một thời điểm. Nếu nó đọc a +hoặc a *, nó tự gọi hai lần để xác định số lẻ hoặc số chẵn. Hàm trả về truelẻ và falsecho even. Các ^ toán tử XOR và & AND được sử dụng để xác định "độ lẻ" của các biểu thức cộng và nhân tương ứng.

Đây là một phiên bản chưa được chỉnh sửa:

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

puts f ? 'o' : 'e'

_{Cảm ơn @Shel đã chỉ ra một lỗi trong phiên bản ban đầu.}

Chồn 0,14 , 40 byte

Tôi đã cố gắng thực hiện một phương thức eval thông minh, nhưng hóa ra rằng bất kỳ giá trị nào được thêm vào codebox bên ngoài không gian ban đầu sẽ không bao giờ được truy cập bởi bộ đếm chương trình. Vì vậy, tôi đã làm một phương pháp eval ít thông minh hơn. : P

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

Hãy thử nó ở đây.

Giải trình

$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 byte

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

Chắc chắn không phải là giải pháp nhỏ nhất, nhưng có thể là giải pháp nhỏ nhất có thể có trong một ngôn ngữ dài dòng như JavaScript!

O , 24 20 19 18 byte

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

Đưa đầu vào, đảo ngược nó, gán echo 2 và ođể 1 và viết nó để Tumblr đánh giá nó như O mã.

Giải trình:

i` Nhận đầu vào và đảo ngược nó, bởi vì O sử dụng ký hiệu postfix
2: e; Chỉ định `e` cho 2
1: o; Chỉ định `o` cho 1
~ 2% Eval và kiểm tra nếu kết quả là chẵn
'o'e? Đầu ra 'e' nếu chẵn, 'o' nếu lẻ

GNU Sed, 36

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

Sau khi đăng tôi thấy chính xác phương pháp này tương tự như @ của Perl câu trả lời manatwork và Retina câu trả lời @ randomra của . Vì vậy, tôi đoán rằng tôi cũng có thể đi tất cả các cách và mượn của họ \W\w\wlà tốt.

Cảm ơn @Ruud đã cạo 4 byte.

Haskell, 160 byte

Gọi 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 byte

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

Nó hơi khó hiểu, nhưng tôi muốn làm một cái gì đó bằng cách sử dụng evalvà các toán tử bitwise. Chú thích:

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

Sự lặp lại (e[…]>"e")làm phiền tôi một chút, nhưng sau đây cũng không tốt hơn (103 byte):

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

Vì vậy, cuối cùng, cách tiếp cận của @ Arkain với kết hợp chuỗi con đơn giản là siêu hạng. Được thực hiện thành một chức năng, với một số tối ưu hóa:

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

Phi tiêu, 173 byte

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

Đây không phải là cạnh tranh, nhưng bất cứ điều gì. Ý chính của giải pháp là, bắt đầu từ 0, thay thế đệ quy mọi toán tử bằng cách đánh giá cặp ký tự theo sau toán tử đó và sau đó xóa các ký tự đó khỏi danh sách.

Haskell, 231 byte

Đây là một cách tiếp cận sử dụng một ngôn ngữ nghiêm túc;)

Phiên bản chơi gôn:

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

Thí dụ:

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

Phiên bản đầy đủ và khá toàn diện:

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

Thí dụ:

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

Các tính năng: Khớp mẫu và đệ quy.

Jolf, 11 byte

(Không cạnh tranh, vì ngôn ngữ hoãn câu hỏi.) Hãy thử ở đây!

FVyAi"oe"@\x12

(Thay thế \x12bằng ký tự thực tế \x12. Điều này sẽ được thực hiện tự động trong trình thông dịch.)

Giải trình:

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 byte

Không cạnh tranh, nhưng tôi rất vui khi làm điều đó, vì vậy tôi không thể giữ nó cho riêng mình. Không giống như mục nhập Python đệ quy (rất thông minh) của feerum , cái này đảo ngược đầu vào và sau đó thực hiện phân tích cú pháp dựa trên ngăn xếp cũ của ký hiệu Ba Lan ngược.

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 byte

Xin lỗi đã làm phiền bạn với một nỗ lực Haskell khác; chỉ muốn chứng minh rằng nó rất có thể trong ít hơn 100 byte.

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

Xác định hàm pchấp nhận bất kỳ biểu thức hợp lệ nào dưới dạng tham số và trả về kết quả dưới dạng chuỗi có độ dài 1.

Thí dụ:

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

Hàm hoạt động bằng cách liên tục giảm toán tử ngoài cùng bên phải trong chuỗi cho đến khi không còn toán tử nào.

Thêm ++ , 46 byte

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

Hãy thử trực tuyến!

Chân trang chỉ đơn giản là liệt kê tất cả các đầu vào ví dụ và đầu ra tương ứng của chúng.

Làm thế nào nó hoạt động

Giống như mất câu trả lời ở đây, điều này sử dụng thay thế và đánh giá. Chức năng chính của chúng tôi là f, và glà một chức năng trợ giúp. Chúng tôi sẽ sử dụng "*e*o*e*oe"(đó là e) làm ví dụ.

fbắt đầu bằng cách lấy chuỗi đầu vào và đảo ngược nó, mang lại "eo*e*o*e*". Sau đó chúng tôi ánh xạ gqua từng yếu tố:

gbắt đầu bằng cách sao chép đối số, để giữ một bản sao cho đến lệnh cuối cùng. Sau đó chúng tôi kiểm tra xem đối số có trong chuỗi hay không "oe", thu được 1 cho các chữ cái và 0 cho *hoặc +. Sau đó chúng tôi đẩy đối số một lần nữa và kiểm tra xem nó có bằng không "e". Kết quả này sau đó được thêm vào kiểm tra trước. Điều này mang lại 0 cho một *hoặc +, 1 cho ovà 2 cho e. Sau đó chúng ta lấy OR logic giữa giá trị này và đối số. Nếu giá trị là 0 , nó được thay thế bằng đối số (tức là *hoặc +), nếu không, nó sẽ được giữ nguyên (nghĩa là 1 và 2 ).

Điều này chuyển đổi tất cả các chữ cái ngược lại của đầu vào thành một giá trị số. Sau đó, chúng tôi nối từng phần tử theo khoảng trắng để đảm bảo các chữ số không được nối. Ví dụ của chúng tôi, điều này mang lại chuỗi "2 1 * 2 * 1 * 2 *". Sau đó, chúng ta có thể đánh giá điều này, bằng cách sử dụng ký hiệu hậu tố của Add ++, mang lại 8 . Sau đó, chúng tôi lấy tính chẵn lẻ của giá trị này, mang lại 0 cho số chẵn và 1 cho số lẻ, trước khi lập chỉ mục vào chuỗi "eo"và trả về chữ cái tương ứng.