Escriba un programa que acepte como entrada un emoticón y salga si el emoticón es feliz o triste.

El programa acepta una cadena como entrada o parámetro, y debe mostrar la cadena "feliz" si la entrada está en la lista de emoticones felices, o "triste" si la entrada está en la lista de emoticones triste.

Puede suponer que la entrada siempre es un emoticón válido (feliz o triste), sin espacios ni pestañas.

Aquí hay una lista de emoticones felices separados por espacios:

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

Aquí hay una lista de emoticones tristes separados por espacios:

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

Este es el código de golf, por lo que gana el programa más corto.

Python, 86 bytes

Debería ser enviado a prisión.

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

Lo más corto que pude encontrar fue equivalente a la respuesta CJam de Martin, así que decidí esconder todos los emojis tristes (menos el carácter del medio, si los hubiera) en el reverso de mi código y usar el __file__truco de Python .

Muahahaha

CJam, 33 32 bytes

Gracias a Dennis por guardar 1 byte.

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

Parece que es más corto hacer lo mismo sin una expresión regular ...

Pruébalo aquí.

Explicación

Esto se basa en la misma observación que la respuesta de Retina, pero esta vez emparejar caras felices no tiene ningún beneficio, por lo que combinaremos caras tristes (porque hay una boca menos para tener en cuenta). La solución es exactamente la misma, excepto que no se implementa a través de la sustitución de expresiones regulares:

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 reconocer todos los emoticones por sus bocas, porque ninguna de las bocas se usa como sombrero u ojos en el otro conjunto (solo en el mismo conjunto). Los felices tienen una boca más para tener en cuenta, pero tienen el beneficio de que las bocas no aparecen en el otro conjunto, ni siquiera como narices (lo contrario no es cierto: ces tanto una boca triste como una feliz nariz). Esto significa que podemos evitar el uso de anclas, sino asegurarnos de que haya más caracteres al otro lado de la boca.

Entonces las bocas válidas para caras felices están ] ) D 3 > }a la derecha o < [ ( {a la izquierda. Emparejamos aquellos con .+[])D3>}]|[<[({].+y los reemplazamos con happy. Si no coincidimos, habrá dos o tres caracteres en la cadena (el emoticón), pero si lo hiciéramos, habrá cinco ( happy). Entonces, en un segundo paso, reemplazamos dos o tres caracteres con sad.

JavaScript (ES6), 46

Usar una expresión regular para encontrar emoticones tristes, que son los que comienzan >)]}o terminan con <([{c. Nota al margen: otras expresiones regulares aquí pueden ser más cortas, pero no estoy seguro de entenderlas.

Nota habitual: prueba ejecutando el fragmento en cualquier navegador compatible con EcmaScript 6 (notablemente no es el Chrome más nuevo pero no MSIE. Probé en Firefox, Safari 9 podría funcionar)

Grandes noticias Parece que las funciones de flecha finalmente llegaron a Chrome. Rel 45, agosto de 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 - ahorró 18 bytes gracias 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'])>}']

Pruébalo en línea!

Como funciona

Si una cadena de la cara comienza ])>}o termina con [(c<{, es triste, de lo contrario es feliz. La indexación de tuplas se usa como if.

Brachylog , 50 bytes

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

Explicación

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

Debe haber una manera de reducir el tamaño aquí.

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

La entrada es una cadena sonriente. El primer y el último personaje se compararán para determinar si es triste. Si no, es feliz.

Pude guardar 2 bytes al no mostrarlos, sino asignarlos a la variable predeterminada (ans) de MATLAB y luego mostrar ans después de la instrucción if. Pero estoy convencido de que se puede mejorar de alguna manera.

Mejora de 2 bytes cambiando la función s (e), a e = input (''); .

PowerShell, 92 bytes

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

Un poco prolijo, pero como beneficio adicional, ¡no usa expresiones regulares!

Esto aprovecha la <string>.IndexOf()función .NET que regresa -1si el carácter no se encuentra en la cadena. Entonces, si el primer personaje no es un personaje "feliz", el primero IndexOf()será -1, del mismo modo para el último personaje. Entonces, si es una cara triste, la IndexOf()s siempre sumará a -2, lo que significa que -eq-2es $TRUE, y así sadse imprime.

Variante de bonificación: PowerShell con 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

Pruébalo en línea

La importación de expresiones regulares hace que sea demasiado larga, así como la imposibilidad de usarla Nonecomo índice de matriz. Pero me gusta la expresión regular :)

Java 8, 52 bytes

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

Pruébalo en línea.

Explicación:

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 se String#matchesagrega implícitamente ^...$para que coincida con la cadena completa, por lo que es más corto buscar caras tristes en lugar de buscar caras felices como lo hacen la mayoría de las otras respuestas .+[\\])D3>}]|[<\\[({].+(porque mi expresión regular fallaría en la respuesta Retina de @MartinEnder , por ejemplo, debido a El caso de prueba feliz :c)).

Explicación de expresiones regulares:

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