önsöz

Tamsayılar her zaman çift ​​veya tek . Tam sayılar bile iki tarafından bölünebilir, tek tam sayılar değildir.

İki tamsayı eklediğinizde, sonuçların summanların çift mi yoksa tek mi olduğuna bağlı olarak eşit mi yoksa tek mi olacağını görebilirsiniz:

• Çift + Çift = Çift
• Çift + Tek = Tek
• Tek + Çift = Tek
• Tek + Tek = Çift

Benzer şekilde, iki tam sayıyı çarptığınızda, faktörlerin eşit mi yoksa tek mi olduğuna bağlı olarak sonucun eşit mi yoksa tek mi olacağını tahmin edebilirsiniz:

• Çift * Çift = Çift
• Çift * Tek = Çift
• Tek * Çift = Çift
• Tek * Tek = Tek

Dolayısıyla, bir matematik ifadesinde yalnızca toplama ve çarpma gerektiren tüm değişkenlerin düzgünlüğünü veya tuhaflığını biliyorsanız, sonucun eşit mi yoksa tek mi olacağını tahmin edebilirsiniz.

Örneğin, (68 + 99) * 37bir tuhaflıkla sonuçlandığını söyleyebiliriz, çünkü bir çift artı bir garip ( 68 + 99) gariptir ve garip bir kez başka bir garip ( odd * 37) gariptir.

Meydan okuma

Yalnızca dört karakteri içeren bir dizgede geçen bir program veya işlev yazın eo+*. Bu dize , yalnızca önek ( +) ve çarpma ( *) ile ilgili ön ek notasyonunda verilen matematiksel ifadeyi temsil eder . Her biri bir emiktar rasgele sayıyı otemsil eder ve her biri bir takım rasgele sayıyı temsil eder.

Göreviniz, ifadeyi basitleştirmek, yazdırmak veya tek bir satır döndürmek eveya oifadenin sonucunun çift mi yoksa tek mi olduğuna bağlı olarak.

Girişin her zaman geçerli önek notasyonunda olacağını varsayabilirsiniz. Spesifik olarak, her biri +ve *ondan sonra meydana gelen her zaman iki uygun operand olacaktır. Bu işlenen tek olabilir eveya o, ya da başka bir +ya da *sırayla işlenen sahip olduğu ifade.

Örneğin, giriş *+eooolarak mul(add(e, o), o)veya (e + o) * onormal ek gösterimde okunabilir . eVe birinci otekabül işlenenlerdir +ve +eoson otekabül işlenenlerdir *.

Sadece açıklığa kavuşturmak için, önek notasyonu yanlış olan bazı geçersiz girişler:

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

Çıktıdaki tek izleyen yeni satır iyi, ancak aksi takdirde çıkacak olan tek eya da otek olanlar için düz .

Bayt cinsinden en kısa kod kazanır.

Test Kılıfları

^{(Boş satırlar yalnızca benzer durumları görsel olarak ayırmaya yardımcı olmak içindir.)}

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 bayt

4 bayt kaydettiğiniz için aditsu sayesinde.

qW:O%eu~"eo"=

Burada test odasını deneyin. (Test paketi, kalıcı bağlantı için çok uzun. Sadece bunları meydan okuma özelliklerinden kopyalayın.)

açıklama

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 bayt

@"eo".vjdXzGU9

Pyth, Pyth sözdizimindeki bir dizeyi kendisi değerlendirebilir. Bu nedenle yerini eve obirlikte 4ve 5. O zaman değerlendirme bana bir çift veya tek sayı verecek ve sonucu kolayca yazdırabilirim.

Çevrimiçi deneyin: Gösteri veya Test Paketi

Açıklama:

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

Değişim için ek açıklama. Galfabe ile başlatılan bir değişkendir abc...xyz. U9liste [0, 1, ..., 8]. XzGU9alfabenin harflerini listedeki değerlerle değiştirir. Yani adeğiştirilir alır 0, bile 1, ..., eile 4, ..., iile 8, jbirlikte 0, ..., ve oile 5. Bu nedenle eçift ​​sayı ve otek sayı ile yer değiştirdim. Diğer tüm değiştirmelerin hiçbir etkisi yoktur.

Perl, 50 45 40 karakter

(39 karakter kod + 1 karakter komut satırı seçeneği.)

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

Örnek çalışma:

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 bayt

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

Uygun bir dosya sürümü için -sbayrak kullanılır.

Biz garip ifadeleri (takas *oo, +oe, +eoiçin) obiz sonra kalan sembol harfli harfli ifadeler takas kadar e. Bunu yapabilinceye kadar tekrar ediyoruz ve son bir harf çıktımız olacak.

(Bu çözüm, insan eserinin Perl cevabına benzer .)

Çevrimiçi deneyin! (Dennis tarafından)

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

iterFonksiyonu çağrıları arasında ayrıştırıldı nasıl dize kadar hatırlar bir FIFO kuyruğuna girdi dizesi yapmak için iyi bir yoldur f. Önemsizdir, bu nedenle giriş bir dize yerine bir yineleyici olduğunda tekrar aramak zararsızdır. or'oe'İle başlayan cevabın son yarısı ... golf oynamalı gibi görünüyor, ama hiçbir şey bulamadım.

Sp3000 sayesinde -1.

Mathematica, 91 84 bayt

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

Bunu sıkıştırmanın bir yolunu mu arıyorsunuz?

Python 2,80 bayt

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]

Bu, Polonya notasyonu işlemlerini uygulamak için bir kullanan feersum'un çok akıllıca cevabı üzerine kuruludur iter. Yeni bir fikir kullanmaktır evalifadeleri değerlendirmek +ve *birlikte eval(f(i)+a+f(i))operatör, aözyinelemeli sonuçlar arasındaki infix yerleştirilir. Değerlendirmede e=0,o=1, isteğe bağlı işlev bağımsız değişkenlerinde bağlamalar kullanılır. Çıkış daha sonra mod 2 olarak alınır.

C, 79 bayt

Basit özyineleme. İzin verilen dört giriş karakterinin bazı (rastlantısal?) Bit yönünde özelliklerine güvenir.

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

Shell + GNU yardımcı programları, 33

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

Giriş STDIN'den alınmıştır.

Bu, girişi tersine çevirmek ve yığın tabanlı bir hesaplayıcı ile değerlendirmekle aynı hile yapar - bu durumda dc. Biz yerini alabilir eve oile 0ve 1ancak daha sonra boşluk yanlış numaraları içine basamak hırslı ayrıştırma önleyecek şekilde yerleştirilebilir olması gerekir.

Bunun yerine eile değiştirilir Kki bu dcvarsayılan 0'dır ve yığın, mevcut hassas itmek için komut oile değiştirilir Oki bu dcistif akım çıkış baz itmek için komut. Bu garip olmalı, bu yüzden Fodc'de başka bir şey yapmadan önce 15'e ayarladık .

O zaman sadece mod 2 alma ve basma meselesi 2%p. Yalnızca olası değerler artık 0ve 1o çıkış baz Sonra 15. olduğunu fark etmez, bu yüzden trgeri çevirir oveya e.

Gözlerini kısarsan, bu kaynak adeta benziyor dc Forever OK.

Cidden , 24 bayt

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

Daha verimli yığın manipülasyonu muhtemelen bunu kısaltabilir, ama meh, ondan memnunum.

Gibi bir dize olarak girdi alır "+*oee"

Çevrimiçi deneyin (giriş manuel olarak girilmelidir)

Açıklama:

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

Özyinelemeli alçalma ayrıştırma ve boole cebri kullanma.

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

Fonksiyon her seferinde stdin'den bir karakter okur. A +veya a okursa *, tek veya çift belirlemek için kendini iki kez arar. İşlev true, odd ve falsefor için döner even. ^ XOR ve & VE operatörleri sırasıyla toplama ve çarpma ifadelerin "oddness" belirlemek için kullanılır.

İşte bir ungolfed versiyonu:

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

puts f ? 'o' : 'e'

_{İlk sürümdeki bir hatayı işaret ettiğiniz için @Shel teşekkürler.}

Minkolang 0.14 , 40 bayt

Zekice bir değerlendirme yöntemi yapmaya çalıştım, ancak orijinal alanın dışındaki kod kutusuna eklenen değerlere hiçbir zaman program sayacı tarafından erişilemeyeceği ortaya çıktı. Bu yüzden daha az akıllıca bir değerlendirme yöntemi yaptım. : P

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

Burada dene.

açıklama

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

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

Kesinlikle en küçük çözüm değil, muhtemelen JavaScript gibi ayrıntılı bir dilde mümkün olan en küçük çözüm!

O , 24 20 19 18 bayt

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

, Girişi alır tersine çevirir, atar eiçin 2 ve oiçin 1 ve Tumblr için mesaj O kodu olarak değerlendirir.

Açıklama:

Girdi alın ve ters çevirin, çünkü O postfix notation kullanır
2: E; 2'ye e atayın
1: O; 1'e atayın
~% 2 Değerlendir ve sonucun eşit olup olmadığını kontrol et
'O'e? 'E' çıktısı, eğer 'o' tek ise

GNU Sed, 36

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

Gönderimden sonra, @ manatwork'ün Perl cevabı ve @ randomra'nın Retina cevabı ile aynı yaklaşımı gördüm . Sanırım, sonuna kadar gidip de ödünç alabilirim \W\w\w.

4 byte'lık tıraş için @Ruud'a teşekkürler.

Haskell, 160 bayt

Çağrı 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 bayt

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

Biraz şaşkın, ancak evalbitsel operatörleri kullanarak bir şeyler yapmak istedim . Açıklamalı:

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")Sıkıntı tekrarı beni biraz rahatsız ediyor, fakat aşağıdakiler de daha iyi değil (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])]))

Sonuçta, @ Arkain'in basit alt dize eşleştirme yaklaşımı superiour'dur. Bazı optimizasyonlarla bir işlev haline getirildi:

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

Dart, 173 bayt

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

Bu rekabetçi değil, ama her neyse. Çözümün özü, 0'dan başlayarak, her operatörü tekrar tekrar o operatörü izleyen karakter çiftlerinin değerlendirilmesiyle değiştirir ve ardından bu karakterleri listeden kaldırır.

Haskell, 231 bayt

İşte ciddi bir dil kullanarak bir yaklaşım;)

Golf versiyonu:

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

Örnek:

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

Ungolfed ve oldukça kapsamlı sürüm:

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

Örnek:

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

Özellikler: Desen eşleştirme ve özyineleme.

Jolf, 11 bayt

(Dil soruları yayınladığı için rekabetçi değildir.) Burada deneyin!

FVyAi"oe"@\x12

( \x12Gerçek karakterle değiştiriniz \x12. Bu, tercümanda otomatik olarak yapılmalıdır.)

Açıklama:

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 bayt

Rekabetçi değil, ama bunu yaparken eğlendim, o yüzden kendime saklayamadım. Feersum tarafından (çok zeki) özyinelemeli yineleyici Python girdisinden farklı olarak , bu girdi girişi tersine çevirir ve daha sonra ters Polonya gösteriminin iyi eski yığın tabanlı ayrıştırmasını yapar.

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 bayt

Başka bir Haskell girişimiyle sizi rahatsız ettiğim için özür dilerim; sadece 100 bayttan daha az sürede mümkün olduğunu kanıtlamak istedim.

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

pHerhangi bir geçerli ifadeyi parametre olarak kabul eden bir işlevi tanımlar ve sonucu 1 uzunluğunda bir dize olarak döndürür.

Örnek:

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

İşlev, hiçbir işleç kalmayana kadar dizedeki en sağdaki işleci tekrar tekrar azaltarak çalışır.

++ , 46 bayt ekle

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

Çevrimiçi deneyin!

Altbilgi basitçe tüm örnek girişleri ve bunlara karşılık gelen çıktıları numaralandırır.

Nasıl çalışır

Buradaki cevapların kaybolması gibi, bu da değiştirme ve değerlendirmeyi kullanır. Bizim ana işlevi olan fve gbir yardımcı fonksiyonudur. Biz kullanacağız "*e*o*e*oe"(ki eörnek olarak).

fGiriş dizesini alarak ve onu tersine çevirerek başlar "eo*e*o*e*". Daha sonra gher elemanın haritasını çıkarırız:

gson komutu kadar bir kopyasını tutmak için, argümanı çoğaltarak başlar. Dizgedeki olduğu edip etmediğini kontrol "oe"verimli, 1 mektuplar için ve 0 için *veya +. Ardından tartışmaya tekrar basarız ve eşit olup olmadığını kontrol ederiz "e". Bu sonuç daha sonra önceki çeke eklenir. Bu verir 0 biri için *ya da +, 1 için ove 2 için e. Ardından mantıksal OR'u bu değer ile argüman arasında alırız. Değer 0 ise, argüman (yani *veya +) ile değiştirilir, aksi halde olduğu gibi bırakılır (yani 1 ve 2 ).

Bu, girişin tersindeki tüm harfleri sayısal bir değere dönüştürür. Ardından, rakamların birleştirilmemesini sağlamak için her bir öğeye boşluklarla katılırız. Örneğimiz için bu, dizeyi verir "2 1 * 2 * 1 * 2 *". Bunu daha sonra, 8 + veren Add ++ 'ın postfix notasyonu kullanarak değerlendirebiliriz . Daha sonra bu değerin paritesini alırız, dizgeye endekslenmeden ve ilgili harfi döndürmeden önce ya çift ​​sayılar için 0 , tek sayılar için 1 elde edilir "eo".