전문

정수 는 항상 짝수 또는 홀수 입니다. 정수조차도 2로 나눌 수 있고 홀수는 아닙니다.

두 개의 정수를 추가하면 summand가 짝수인지 홀수인지에 따라 결과가 짝수인지 홀수인지 유추 할 수 있습니다.

• 짝수 + 짝수 = 짝수
• 짝수 + 홀수 = 홀수
• 홀수 + 짝수 = 홀수
• 홀수 + 홀수 = 짝수

마찬가지로 두 정수를 곱하면 인수가 짝수인지 홀수인지에 따라 결과가 짝수인지 홀수인지를 유추 할 수 있습니다.

• 짝수 * 짝수 = 짝수
• 짝수 * 홀수 = 짝수
• 홀수 * 짝수 = 짝수
• 홀수 * 홀수 = 홀수

따라서 덧셈과 곱셈 만 포함하는 수학 표현식에서 모든 변수의 균등 또는 홀수를 알면 결과가 짝수인지 홀수인지 유추 할 수 있습니다.

예를 들어 (68 + 99) * 37짝수 + 홀수 ( 68 + 99)는 홀수이고 홀수 배는 다른 홀수 ( odd * 37)가 홀수이기 때문에 결과는 홀수 라고 확신 할 수 있습니다 .

도전

네 개의 문자 만 포함 된 문자열을받는 프로그램이나 함수를 작성하십시오 eo+*. 이 문자열은 덧셈 ( )과 곱셈 ( ) 만 포함하는 접두사 표기법으로 주어진 수학적 표현을 나타냅니다 . 각각 은 임의의 짝수를 나타내고 각각 은 임의의 홀수를 나타냅니다.+*eo

당신의 작업은 표현, 인쇄 또는 단일 반환 단순화하는 것입니다 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 바이트

4 바이트를 절약 해 준 aditsu에게 감사합니다.

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. 다른 모든 교체품은 전혀 효과가 없습니다.

펄, 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. 우리는 할 수있을 때까지 이것을 반복하고 마지막 한 글자는 우리의 출력입니다.

(이 솔루션은 manatwork의 Perl answer 와 유사합니다 .)

온라인으로 사용해보십시오! (데니스)

파이썬 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. 입력이 dem 등하므로 입력이 이미 문자열이 아닌 반복자 일 때 다시 호출하는 것은 무해합니다. or'oe'...로 시작하는 답변의 후반부는 골프를 타야하는 것처럼 보이지만 아무것도 찾을 수 없습니다.

Sp3000 덕분에 -1입니다.

매스 매 티카, 91 84 바이트

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

이것을 압축하는 방법을 찾고 있습니다 ...

파이썬 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표현식을 평가하는 데 사용 +하고 *with 를 사용 eval(f(i)+a+f(i))하여 연산자 a가 재귀 결과 사이에 삽입됩니다. eval은 e=0,o=1선택적 함수 인수에서 바인딩 을 사용합니다 . 그런 다음 출력은 mod 2로 취해집니다.

C, 79 바이트

간단한 재귀. 허용되는 4 개의 입력 문자 중 일부 (일치적인?) 비트 속성에 의존합니다.

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

쉘 + GNU 유틸리티, 33

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

입력은 STDIN에서 가져옵니다.

이것은 입력을 되돌리고 스택 기반 계산기로 평가하는 것과 동일한 트릭을 수행합니다 dc. 우리는 교체 e하고o 와 0와 1, 그러나 공간은 잘못된 번호에 숫자의 욕심 구문 분석을 방지하기 위해 삽입해야합니다.

대신 현재 정밀도를 스택으로 푸시 하는 명령 인 which e로 대체 되며 기본적으로 0 입니다.KdcoO 되는 것이다 dc스택에 전류 출력베이스 밀어 명령. 이것은 이상해야하므로 Fodc에서 다른 작업을 수행하기 전에 15로 설정했습니다 .

그렇다면 그것은 단순히 모드 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"

루비, 61 바이트

재귀 하강 구문 분석 및 부울 대수 사용

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

이 함수는 한 번에 stdin에서 한 문자를 읽습니다. a +또는 a를 읽는 경우 *홀수 또는 짝수를 결정하기 위해 자신을 두 번 호출합니다. 이 함수는 true홀수 및를 반환 false합니다 even. ^ XOR 및 & AND 연산자는 각각 덧셈과 곱셈 표현 "oddness"를 결정하는 데 사용됩니다.

ungolfed 버전은 다음과 같습니다.

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 바이트

나는 영리한 평가 방법을 시도했지만 원래 공간 외부의 코드 상자에 추가 된 모든 값은 프로그램 카운터에서 절대 도달하지 않는 것으로 나타났습니다. 그래서 덜 영리한 평가 방법을 사용했습니다. :피

$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

자바 스크립트, 110106 94 바이트

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

확실히 가장 작은 솔루션은 아니지만 JavaScript와 같은 장황한 언어로 가능한 가장 작은 솔루션 일 것입니다!

O , 24 20 19 18 바이트

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

, 입력을 받아이를 반전 할당 e에 2 및 o로 1 및 텀블러가 그것을 소식 O 코드로 평가한다.

설명:

O는 접미사 표기법을 사용하기 때문에 입력을 받고 뒤집습니다.
2 : e; `e`를 2에 할당
1 : o; `o`를 1에 할당
~ 2 % 평가 및 결과가 고른 지 확인
'오? 짝 수면 출력 'e', ​​홀수이면 'o'

GNU 세드, 36

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

게시 한 후 @manatwork의 Perl answer 및 @ randomra 's Retina answer 와 정확히 동일한 접근 방식을 보았습니다 . 그래서 나는 모든 길을 가고 그들 \W\w\w도 빌릴 수 있다고 생각합니다.

4 바이트를 깎아 준 @Ruud에게 감사드립니다.

하스켈, 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"]

자바 스크립트, 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])]))

결국 간단한 하위 문자열 일치를 사용한 @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부터 시작하여 모든 연산자를 평가자로 해당 연산자 다음에 오는 문자 쌍을 재귀 적으로 대체 한 다음 목록에서 해당 문자를 제거하는 것입니다.

하스켈, 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 바이트

경쟁적이지는 않지만 재미있게 놀았 기 때문에 제 자신에게 맡길 수 없었습니다. 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]]

하스켈, 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 을 생성 합니다. 그런 다음 인수를 다시 푸시하고 인수가 같은지 확인합니다 . 그런 다음이 결과가 이전 검사에 추가됩니다. 이것은 또는에 대해 0 ,에 대해 1 을 ,에 대해 2 를 산출 합니다 . 그런 다음이 값과 인수 사이의 논리합을 취합니다. 값이 0 이면 인수 (즉, 또는 ) 로 대체되고 , 그렇지 않으면 그대로 (예 : 1 및 2 ) 남습니다 .*+"e"*+oe*+

입력의 반대 문자를 모두 숫자 값으로 변환합니다. 그런 다음 각 요소를 공백으로 결합하여 숫자가 연결되지 않도록합니다. 이 예에서는 문자열을 생성합니다 "2 1 * 2 * 1 * 2 *". 그런 다음 Add ++의 접미사 표기법을 사용하여이를 평가하여 8을 산출 할 수 있습니다 . 그런 다음 문자열에 색인을 생성 하고 해당 문자를 반환 하기 전에이 값의 패리티를 가져와 짝수의 경우 0 , 홀수의 경우 1 을 산출합니다 "eo".