Bir ifade girişi kabul eden bir program yazın ve ifade mutlu veya üzgünse çıkar.

Program giriş veya parametre olarak bir dize kabul eder ve giriş mutlu ifade listesindeyse "mutlu" ya da giriş üzgün ifade listesinde ise "sad" dizesini göstermelidir.

Girişin her zaman geçerli veya mutlu (üzgün) bir ifade olduğunu, etrafta boşluk veya sekme olmadan olduğunu varsayabilirsiniz.

İşte mutlu ifadelerin boşlukla ayrılmış bir listesi:

:-) :) :D :o) :] :3 :c) :> =] 8) =) :} :^) :-D 8-D 8D x-D xD X-D XD =-D =D =-3 =3 B^D (-: (: (o: [: <: [= (8 (= {: (^:

İşte üzgün ifadelerin boşlukla ayrılmış bir listesi:

>:[ :-( :( :-c :c :-< :< :-[ :[ :{ 8( 8-( ]:< )-: ): >-: >: ]-: ]: }: )8 )-8

Bu kod golf, yani en kısa program kazanır.

Python, 86 bayt

Hapishaneye gönderilmeliyim.

x=lambda c: ["happy","sad"][c[0]+c[-1:]in open(__file__).read(88)[::-1]]#<][><:>{:}(:)

En kısa sürede bulabildiğim en kısa zamanda Martin'in CJam cevabına eşdeğerdi, bu yüzden tüm üzücü emojileri (varsa eksi orta karakteri) kodumun tersine gizlemeye ve Python'un __file__hile hilesini kullanmaya karar verdim .

Muahahaha.

CJam, 33 32 bayt

1 byte tasarruf için Dennis teşekkürler.

q)"[(c<{"&\"])>}"&|"sad""happy"?

Aynı şeyi regex olmadan yapmak daha kısa gibi görünüyor ...

Burada test et.

açıklama

Bu, Retina cevabıyla aynı gözlemi temel alır, ancak bu kez mutlu yüzleri eşleştirmenin faydası yoktur, bu yüzden bunun yerine üzgün yüzleri eşleştireceğiz (çünkü hesaba katılacak daha az ağzı var). Çözüm, aksi takdirde tamamen aynıdır, ancak regex ikamesi yoluyla uygulanmaması dışında:

q)             e# Read input and split off last character.
"[(c<{"&       e# Set intersection with the sad right-hand mouths.
\              e# Pull up remaining emoticon.
"])>}"&        e# Set intersection with the sad left-hand mouths.
|              e# Set union, which amounts to a logical OR in this case.
"sad""happy"?  e# Pick the correct string.

Retina , 38 36 bayt

.+[])D3>}]|[<[({].+
happy
^...?$
sad

Tüm ifadeleri ağızlarından tanıyabiliriz, çünkü ağızlardan hiçbiri diğer sette şapka veya göz olarak kullanılmaz (sadece aynı sette). Mutlu olanlar, göz önünde bulundurmaları gereken bir ağıza daha sahipler, ancak burunlarının diğer sette görünmemesi, burun gibi olmasa da yararları var (bunun tersi doğru değil: chem üzgün bir ağız hem de mutlu burun). Bu, çapa kullanmaktan kaçınabileceğimiz anlamına gelir, ancak bunun yerine ağzın diğer tarafında daha fazla karakter olduğundan emin olun.

Bu yüzden mutlu yüzler için geçerli ağızlar ] ) D 3 > }sağda veya < [ ( {soldadır. Bunları eşleştiririz .+[])D3>}]|[<[({].+ve onunla değiştiririz happy. Eşleşmezse, dizgede iki veya üç karakter olacak (ifade), fakat eğer öyleyse beş olacak ( happy). Bu yüzden ikinci bir adımda iki veya üç karakterin yerini alıyoruz sad.

JavaScript (ES6), 46

İle başlayan >)]}veya biten üzücü ifadeleri bulmak için bir regexp kullanmak <([{c. Not: Buradaki diğer regexps'ler daha kısa olabilir ancak bunları anladığınızdan emin değilim.

Olağan not: Test herhangi ECMAscript 6 uyumlu tarayıcı üzerinde pasajını çalışan (özellikle değil . Yeni Krom ancak MSIE Firefox üzerinde test, Safari 9 gidebiliriz)

Büyük haber Ok işlevleri nihayet Chrome topraklarına ulaştı! Rel 45, Ağustos 2015

F=s=>/^[\])}>]|[[({<c]$/.test(s)?'sad':'happy'

//Same length
X=s=>/[\])}>].|.[[({<c]/.test(s)?'sad':'happy'

Y=s=>s.match`].|[)}>].|.[[({<c]`?'sad':'happy'
                 
//TEST
out=x=>O.innerHTML+=x+'\n';

sad='>:[ :-( :( :-c :c :-< :< :-[ :[ :{ 8( 8-( ]:< )-: ): >-: >: ]-: ]: }: )8 )-8'.split` `
happy=':-) :) :D :o) :] :3 :c) :> =] 8) =) :} :^) :-D 8-D 8D x-D xD X-D XD =-D =D =-3 =3 B^D (-: (: (o: [: <: [= (8 (= {: (^:'.split` ` 

out('The sad faces')                   
sad.forEach(x=>out(x + ' is ' + F(x)))
out('\nThe happy faces')
happy.forEach(x=>out(x + ' is ' + F(x)))

<pre id=O></pre>

Julia, 87 69 bayt - Alex A sayesinde 18 bayt kurtardı

s=readline();print(s[end-1] in")D]3>}"||s[1] in"([<{"?"happy":"sad")

Python 3 , 77 75 74 72 61 55 bayt

lambda e:('happy','sad')[e[-1]in'[(c<{'or e[0]in'])>}']

Çevrimiçi deneyin!

O nasıl çalışır

Bir yüz dizesi ile başlıyor ])>}veya bitiyorsa [(c<{, üzücü, aksi halde mutludur. Tuple indeksleme olarak kullanılır if.

Brachylog , 50 bayt

(rh{,"[(c<{":Im?};?h{,"])>}":Im?}),"sad".;"happy".

açıklama

(                              ),"sad".;"happy".  § If what's in the parentheses is true,
                                                  § output "sad", else output "happy".

 rhA                                              § Unify A with the last char of the input
    ,"[(c<{":ImA                                  § True if A is a char of "[(c<{"
                ;                                 § OR
                 ?hA                              § Unify A with the first char of the input
                    ,"])>}":ImA                   § True if A is a char of "])>}"

Python, 159 bayt.

i,e=raw_input(),0
for c in i:e=(e,i.index(c))[c in":=8xXB"]
f,s,h=i[:e],i[e+1:],0
for c in f:h+=c in"[(c<{"
for c in s:h+=c in")]}>D"
print["Sad","Happy"][h>0]

MATLAB, 85 83 bayt

Burada büyüklüğü azaltmanın bir yolu olmalı.

e=input('');if any([e(end)=='[(c<{',e(1)=='])>}']),'sad';else 'happy';end,disp(ans)

Giriş bir gülen yüz dizisidir. Üzgün ​​olup olmadığını belirlemek için ilk ve son karakterler karşılaştırılacaktır. Değilse, mutlu.

Her ikisini de göstererek değil, onları MATLAB'ın varsayılan değişkenine (ans) atayarak ve ardından if-ifadesinden sonra ans'ı göstererek 2 bayt kaydedebildim. Ama bir şekilde geliştirilebileceğine ikna oldum.

2 değiştirerek iyileşme bayt , fonksiyon s (e) için e = girişi ( ''); .

PowerShell, 92 Bayt

param([char[]]$a)if("<[({".IndexOf($a[0])+"})D3]>".IndexOf($a[-1])-eq-2){"sad"}else{"happy"}

Biraz wordy, ama bonus olarak, regex kullanmaz!

Bu .NET yararlanır <string>.IndexOf()donduğu fonksiyonu -1karakter eğer değil dizede buldular. Yani, ilk karakter "mutlu" bir karakter değilse, ilk karakter IndexOf()aynı şekilde son karakter için -1 olacaktır. O üzgün bir yüz parça varsa, bu, IndexOf()hep anlamına -2 için özetleyecek -eq-2olan $TRUEve böylece sadbasılmış olur.

Bonus varyantı: Regex'li PowerShell, 95 bayt

param([char[]]$a)if(($a[0]-match"[<\[\(\{]")-or($a[-1]-match"[\}\)D3\]>]")){"happy"}else{"sad"}

Python 3 , 75 bayt

lambda y:"sad"if re.match("(.*[[(c<{]$)|(^[\])>}])",y)else"happy"
import re

Çevrimiçi deneyin

Düzenli içe aktarma içe aktarma işlemi, Nonedizinin dizini olarak kullanılamamasının yanı sıra biraz da uzun olmasını sağlar . Ama regex'i severim :)

Java 8, 52 bayt

e->e.matches(".+[\\[(c<{]|[)>\\]}].+")?"sad":"happy"

Çevrimiçi deneyin.

Açıklama:

e->          // Method with String as both parameter return-type
  e.matches( ".+[\\[(c<{]|[)>\\]}].+")                   
             //  Checks if the input matches the regex
   ?"sad"    //  If it does: output "sad"
   :"happy"  //  Else: output "happy"

Java'nın String#matchesörtük ^...$olarak tüm String'i eşleştirdiğini ekler , bu yüzden diğer yüzlerdeki cevapların çoğunda olduğu gibi mutlu yüzleri kontrol etmek yerine üzgün yüzleri kontrol etmek daha kısadır .+[\\])D3>}]|[<\\[({].+(çünkü regex'im @MartinEnder'in Retina cevabında başarısız olacağı için) mutlu sınama durumu :c)).

Regex açıklaması:

^.+[\\[(c<{]|[)>\\]}].+$
^                           Start of the string
 .+                          One or more characters,
   [\\[(c<{]                 followed by one of "[(c<{"
            |               Or
             [)>\\]}]        One of ")>]}",
                     .+      followed by one or more characters
                       $    End of the string