คำนำ

นัมเบอร์อยู่เสมอทั้งแม้หรือคี่ แม้จำนวนเต็มหารด้วยสองก็ไม่ได้เป็นจำนวนเต็มคี่

เมื่อคุณเพิ่มจำนวนเต็มสองจำนวนคุณสามารถอนุมานได้ว่าผลลัพธ์จะเป็นแบบคู่หรือคี่โดยขึ้นอยู่กับว่าการสรุปนั้นเป็นแบบคู่หรือคี่:

• Even + Even = Even
• คู่ + คี่ = คี่
• คี่ + คู่ = คี่
• Odd + Odd = Even

ในทำนองเดียวกันเมื่อคุณคูณจำนวนเต็มสองจำนวนคุณสามารถอนุมานได้ว่าผลลัพธ์จะเป็นเลขคู่หรือคี่ขึ้นอยู่กับว่าปัจจัยเป็นเลขคู่หรือคี่:

• คู่ * แม้แต่ = แม้แต่
• คู่ * Odd = Even
• คี่ * คู่ = คู่
• คี่ * คี่ = คี่

ดังนั้นหากคุณทราบความสม่ำเสมอหรือความแปลกของตัวแปรทั้งหมดในนิพจน์ทางคณิตศาสตร์ที่เกี่ยวข้องกับการบวกและการคูณคุณสามารถอนุมานได้ว่าผลลัพธ์จะเป็นแบบคู่หรือคี่

ตัวอย่างเช่นเราสามารถพูดได้อย่างมั่นใจว่า(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...xyzU9[0, 1, ..., 8]XzGU9a0b1e4i8j0o5eo

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 ของ manatwork )

ลองออนไลน์! (โดยเดนนิส)

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

iterฟังก์ชั่นเป็นวิธีที่ดีที่จะทำให้สายป้อนเข้าไปในคิว FIFO fซึ่งจำได้ว่ามากของสตริงที่ได้รับการแยกวิเคราะห์ข้ามสายของ มันเป็น idempotent ดังนั้นจึงไม่เป็นอันตรายที่จะเรียกมันอีกครั้งเมื่ออินพุตนั้นเป็นตัววนซ้ำมากกว่าสตริง ครึ่งท้ายของคำตอบที่เริ่มต้นด้วยor'oe'... ดูเหมือนว่าควรจะเล่นกอล์ฟได้ แต่ฉันไม่พบอะไรเลย

-1 ขอบคุณ Sp3000

Mathematica, 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จะถูกวางไว้ระหว่างผลการเรียกซ้ำ Eval ใช้การโยงe=0,o=1ในอากิวเมนต์ฟังก์ชันทางเลือก เอาต์พุตจะถูกนำมา mod 2

C, 79 ไบต์

การเรียกซ้ำแบบตรงไปตรงมา อาศัยคุณสมบัติ bitwise (โดยบังเอิญ?) ของอักขระอินพุตที่อนุญาตสี่ตัว

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แปลกลับไปหรือoe

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"

Ruby, 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 สำหรับการชี้จุดบกพร่องในรุ่นเริ่มต้น}

Minkolang 0.14 , 40 ไบต์

ฉันพยายามทำวิธี eval ฉลาด แต่ปรากฎว่าค่าใด ๆ ที่เพิ่มไปยัง codebox นอกพื้นที่เดิมจะไม่สามารถเข้าถึงได้โดยเคาน์เตอร์โปรแกรม ดังนั้นฉันจึงใช้วิธีการที่ชาญฉลาดน้อยกว่า : 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"});

ไม่ใช่โซลูชันที่เล็กที่สุด แต่น่าจะเป็นโซลูชันที่เล็กที่สุดเท่าที่จะเป็นไปได้ในภาษา verbose เช่น JavaScript!

O , 24 20 19 18 ไบต์

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

จะเข้าฝืนมันกำหนดeไป2และoเพื่อ1และโพสต์ไปยัง Tumblrประเมินว่ามันเป็นรหัส O

คำอธิบาย:

i` ป้อนข้อมูลและย้อนกลับเนื่องจาก O ใช้สัญลักษณ์ของ postfix
2: E; กำหนด `e 'ถึง 2
1: o; กำหนด `o 'ถึง 1
~ 2% Eval และตรวจสอบว่าผลลัพธ์เป็นเลขคู่หรือไม่
'o'e? เอาท์พุท '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")annoys me เล็กน้อย แต่สิ่งต่อไปนี้ไม่ได้ดีกว่า (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])]))

ดังนั้นในที่สุดวิธีการของ @ Arkain ที่มีการจับคู่สตริงย่อยแบบง่าย ๆ นั้นยอดเยี่ยมมาก สร้างเป็นฟังก์ชั่นพร้อมการเพิ่มประสิทธิภาพบางอย่าง:

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 ไบต์

นี่คือวิธีการใช้ภาษาที่ร้ายแรง;)

รุ่น Golfed:

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'

คุณสมบัติ: การจับคู่รูปแบบและการเรียกซ้ำ

Jolf 11 ไบต์

(Noncompetitive เนื่องจากภาษาโพสต์คำถาม) ลองที่นี่!

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

Python 3, 171 145 135 ไบต์

ไม่ใช่การแข่งขัน แต่ฉันสนุกที่จะทำดังนั้นฉันจึงไม่สามารถรักษาตัวเองไว้ได้ ซึ่งแตกต่างจากรายการ Python recursive-iterator (ฉลาดมาก) โดย 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และ2eสำหรับ จากนั้นเราจะใช้ตรรกะหรือระหว่างค่านี้และอาร์กิวเมนต์ หากค่าเป็น0มันจะถูกแทนที่ด้วยอาร์กิวเมนต์ (เช่น*หรือ+) มิฉะนั้นมันจะถูกปล่อยให้เป็น - คือ (เช่น1และ2 )

สิ่งนี้จะแปลงตัวอักษรทั้งหมดในด้านหลังของอินพุตเป็นค่าตัวเลข จากนั้นเราจะเข้าร่วมแต่ละองค์ประกอบด้วยช่องว่างเพื่อให้แน่ใจว่าตัวเลขจะไม่ต่อกัน "2 1 * 2 * 1 * 2 *"ตัวอย่างเช่นเรานี้อัตราผลตอบแทนสตริง จากนั้นเราสามารถประเมินนี้โดยใช้สัญกรณ์เพิ่ม postfix ++ 's ยอม8 จากนั้นเราจะนำความเท่าเทียมกันของค่านี้ซึ่งให้ผลเป็น0สำหรับเลขคู่และ1สำหรับเลขคี่ก่อนทำดัชนีลงในสตริง"eo"และส่งคืนตัวอักษรที่สอดคล้องกัน