Escreva um programa que aceite como entrada um emoticon e saia se o emoticon estiver feliz ou triste.

O programa aceita uma sequência como entrada ou parâmetro e deve exibir a sequência "feliz" se a entrada estiver na lista de emoticons felizes ou "triste" se a entrada estiver na lista de emoticons tristes.

Você pode assumir que a entrada é sempre um emoticon válido (feliz ou triste), sem espaço ou guias ao redor.

Aqui está uma lista separada por espaços de emoticons felizes:

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

Aqui está uma lista separada por espaços de emoticons tristes:

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

Isso é código-golfe, então o programa mais curto vence.

Python, 86 bytes

Eu deveria ser enviado para a prisão.

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

O menor tempo que consegui pensar foi equivalente à resposta de Martin no CJam, então decidi esconder todos os emojis tristes (menos o caractere do meio, se houver) no verso do meu código e usar o __file__truque do Python .

Muahahaha.

CJam, 33 32 bytes

Agradecemos a Dennis por economizar 1 byte.

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

Parece que é mais curto fazer a mesma coisa sem um regex ...

Teste aqui.

Explicação

Isso se baseia na mesma observação que a resposta da Retina, mas desta vez combinar rostos felizes não tem nenhum benefício, então, em vez disso, combinaremos rostos tristes (porque há menos uma boca para levar em consideração). Caso contrário, a solução é exatamente a mesma, exceto que ela não é implementada via substituição de regex:

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 bytes

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

Podemos reconhecer todos os emoticons pelas bocas, porque nenhuma das bocas é usada como chapéu ou olhos no outro conjunto (apenas no mesmo conjunto). Os felizes têm mais uma boca para levar em consideração, mas têm o benefício de que as bocas não aparecem no outro conjunto, nem mesmo como nariz (o contrário não é verdadeiro: cé uma boca triste e uma feliz). nariz). Isso significa que podemos evitar o uso de âncoras, mas apenas garantir que haja mais caracteres do outro lado da boca.

Portanto, as bocas válidas para rostos felizes estão ] ) D 3 > }à direita ou < [ ( {à esquerda. Nós os combinamos com .+[])D3>}]|[<[({].+e substituí-los por happy. Se não correspondermos, haverá dois ou três caracteres na sequência (o emoticon), mas se o fizermos, haverá cinco ( happy). Então, em um segundo passo, substituímos dois ou três caracteres por sad.

JavaScript (ES6), 46

Usando um regexp para encontrar emoticons tristes, que são aqueles que começam com >)]} ou terminam em <([{c. Nota lateral: outros regexps aqui podem ser mais curtos, mas não tenho certeza de entendê-los.

Nota habitual: teste a execução do snippet em qualquer navegador compatível com EcmaScript 6 (principalmente no Chrome mais novo, mas não no MSIE. Testei no Firefox, o Safari 9 pode ser usado)

Grandes notícias Parece que as funções de seta finalmente chegaram ao Chrome! Rel 45, agosto 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 bytes - economizou 18 bytes graças a Alex A.

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

Python 3 , 77 75 74 72 61 55 bytes

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

Experimente online!

Como funciona

Se uma sequência de rosto começa ])>}ou termina com [(c<{, é triste, caso contrário, é feliz. A indexação de tupla é usada como if.

Braquilog , 50 bytes

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

Explicação

(                              ),"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 bytes.

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 bytes

Deve haver uma maneira de reduzir o tamanho aqui.

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

Entrada é uma seqüência de caracteres sorridente. O primeiro e o último caracteres serão comparados para determinar se é triste. Se não, é feliz.

Consegui salvar 2 bytes também não exibindo, mas atribuindo-os à variável padrão (ans) do MATLAB e exibindo ans após a instrução if. Mas estou convencido de que isso pode ser melhorado de alguma forma.

Melhoria de 2 bytes alterando a função s (e), para e = input (''); .

PowerShell, 92 bytes

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

Um pouco prolixo, mas como um bônus, ele não usa regex!

Isso tira proveito da <string>.IndexOf()função .NET que retorna -1se o caractere não for encontrado na string. Portanto, se o primeiro caractere não for "feliz", o primeiro IndexOf()será -1 - da mesma forma que o último. Portanto, se for um rosto triste, os IndexOf()s sempre somarão -2, significando o -eq-2é $TRUEe, portanto , serão sadimpressos.

Variante de bônus: PowerShell com Regex, 95 bytes

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

Python 3 , 75 bytes

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

Experimente online

A importação de regex o torna um pouco demorada, além da incapacidade de usá-lo Nonecomo um índice de matriz. Mas eu gosto de regex :)

Java 8, 52 bytes

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

Experimente online.

Explicação:

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"

O Java é String#matchesincluído implicitamente ^...$para corresponder à String inteira, e é por isso que é mais curto procurar rostos tristes em vez de procurar rostos felizes como a maioria das outras respostas .+[\\])D3>}]|[<\\[({].+(porque meu regex falharia na resposta Retina de @MartinEnder , por exemplo, devido a o caso de teste feliz :c)).

Explicação Regex:

^.+[\\[(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