Écrivez un programme qui accepte en entrée une émoticône et sort si l'émoticône est heureuse ou triste.

Le programme accepte une chaîne comme entrée ou paramètre et doit afficher la chaîne "happy" si l'entrée est dans la liste d'émoticônes happy, ou "sad" si l'entrée est dans la liste d'émoticônes sad.

Vous pouvez supposer que l'entrée est toujours une émoticône valide (heureuse ou triste), sans espace ni onglets.

Voici une liste d'émoticônes joyeuses séparées par des espaces:

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

Voici une liste d'émoticônes tristes séparées par des espaces:

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

C'est le code-golf, donc le programme le plus court l'emporte.

Python, 86 octets

Je devrais être envoyé en prison.

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

Le plus court que j'ai pu trouver était équivalent à la réponse CJam de Martin, j'ai donc décidé de cacher tous les emojis tristes (moins le caractère central le cas échéant) à l'inverse de mon code et d'utiliser la __file__triche quine de Python .

Muahahaha.

CJam, 33 32 octets

Merci à Dennis d'avoir économisé 1 octet.

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

On dirait qu'il est plus court de faire la même chose sans regex ...

Testez-le ici.

Explication

Cela est basé sur la même observation que la réponse Retina, mais cette fois, faire correspondre les visages heureux n'a aucun avantage, nous allons donc faire correspondre les visages tristes à la place (car il y a une bouche de moins à prendre en compte). La solution est par ailleurs exactement la même, sauf qu'elle n'est pas implémentée via la substitution d'expression régulière:

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.

Rétine , 38 36 octets

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

Nous pouvons reconnaître toutes les émoticônes par leurs bouches, car aucune des bouches n'est utilisée comme un chapeau ou des yeux dans l'autre ensemble (uniquement dans le même ensemble). Les heureux ont une bouche de plus à prendre en compte, mais ils ont l'avantage que les bouches n'apparaissent pas du tout dans l'autre ensemble, pas même en tant que nez (l'inverse n'est pas vrai: cest à la fois une bouche triste et heureuse nez). Cela signifie que nous pouvons éviter d'utiliser des ancres, mais au lieu de cela, assurez-vous simplement qu'il y a plus de caractères de l'autre côté de la bouche.

Ainsi, les bouches valides pour les visages heureux sont ] ) D 3 > }à droite ou < [ ( {à gauche. Nous les associons .+[])D3>}]|[<[({].+et les remplaçons par happy. Si nous ne correspondons pas, il y aura deux ou trois caractères dans la chaîne (l'émoticône), mais si nous le faisons, il y en aura cinq ( happy). Donc, dans un deuxième temps, nous remplaçons deux ou trois caractères par sad.

JavaScript (ES6), 46

Utiliser une expression rationnelle pour trouver des émoticônes tristes, qui commencent >)]}ou finissent par <([{c. Remarque: d'autres expressions rationnelles ici peuvent être plus courtes, mais je ne suis pas sûr de les comprendre.

Remarque habituelle: test de l'exécution de l'extrait sur n'importe quel navigateur compatible EcmaScript 6 (notamment pas le plus récent Chrome mais pas MSIE. J'ai testé sur Firefox, Safari 9 pourrait aller)

Grande nouvelle Il semble que les fonctions fléchées soient enfin arrivées sur Chrome! Rel 45, août 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 octets - économisé 18 octets grâce à Alex A.

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

Python 3 , 77 75 74 72 61 55 octets

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

Essayez-le en ligne!

Comment ça marche

Si une chaîne de visage commence par ])>}ou se termine par [(c<{, c'est triste, sinon elle est heureuse. L'indexation de tuple est utilisée comme if.

Brachylog , 50 octets

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

Explication

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

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 octets

Il doit y avoir un moyen de réduire la taille ici.

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

L'entrée est une chaîne souriante. Les premier et dernier caractères seront comparés pour déterminer si c'est triste. Sinon, c'est content.

J'ai pu enregistrer 2 octets en n'affichant pas non plus, mais en les affectant à la variable par défaut de MATLAB (ans) à la place, puis en affichant ans après l'instruction if. Mais je suis convaincu que cela peut être amélioré d'une manière ou d'une autre.

Amélioration de 2 octets en changeant la fonction s (e), en e = entrée (''); .

PowerShell, 92 octets

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

Un peu verbeux, mais en bonus, il n'utilise pas regex!

Cela tire parti de la <string>.IndexOf()fonction .NET qui renvoie -1si le caractère n'est pas trouvé dans la chaîne. Donc, si le premier caractère n'est pas un caractère "heureux", le premier IndexOf()sera -1 - de même pour le dernier caractère. Donc, si c'est un visage triste, le IndexOf()s sera toujours égal à -2, ce qui signifie que le -eq-2est $TRUE, et sera donc sadimprimé.

Variante bonus: PowerShell avec Regex, 95 octets

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

Python 3 , 75 octets

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

Essayez-le en ligne

L'importation regex le rend un peu trop long, ainsi que l'impossibilité de l'utiliser Nonecomme index de tableau. Mais j'aime regex :)

Java 8, 52 octets

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

Essayez-le en ligne.

Explication:

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 String#matchesajoute implicitement ^...$pour correspondre à l'ensemble de la chaîne, c'est pourquoi il est plus court de rechercher des visages tristes au lieu de rechercher des visages heureux comme le font la plupart des autres réponses .+[\\])D3>}]|[<\\[({].+(car mon expression régulière échouerait dans la réponse Retina de @MartinEnder par exemple, en raison de le cas de test heureux :c)).

Explication de l'expression régulière:

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