Scrivi un programma che accetta come input un'emoticon e ne esce se l'emoticon è felice o triste.

Il programma accetta una stringa come input o parametro e dovrebbe visualizzare la stringa "felice" se l'input è nella lista delle emoticon felici, o "triste" se l'input è nella lista delle emoticon tristi.

Puoi supporre che l'input sia sempre un'emoticon valida (felice o triste), senza spazi o tab in giro.

Ecco un elenco separato da spazi di emoticon felici:

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

Ecco un elenco separato da spazi di emoticon tristi:

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

Questo è code-golf, quindi vince il programma più breve.

Python, 86 byte

Dovrei essere mandato in prigione.

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

Il più breve che riuscissi a trovare era equivalente alla risposta di CJam di Martin, quindi decisi che avrei nascosto tutti gli emoji tristi (meno l'eventuale carattere di mezzo) nel retro del mio codice e avrei usato il __file__cheat di Python .

Muahahaha.

CJam, 33 32 byte

Grazie a Dennis per aver salvato 1 byte.

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

Sembra che sia più breve fare la stessa cosa senza regex ...

Provalo qui.

Spiegazione

Questo si basa sulla stessa osservazione della risposta Retina, ma questa volta abbinare facce felici non ha alcun vantaggio, quindi abbineremo invece facce tristi (perché c'è una bocca in meno da tenere in considerazione). In caso contrario, la soluzione è esattamente la stessa, tranne per il fatto che non è implementata tramite la sostituzione 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 byte

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

Possiamo riconoscere tutte le emoticon dalle loro bocche, perché nessuna delle bocche viene utilizzata come cappello o occhi nell'altro set (solo nello stesso set). I felici hanno un'altra bocca da prendere in considerazione, ma hanno il vantaggio che le bocche non appaiono affatto nell'altra serie, nemmeno come il naso (non è vero il contrario: cè sia una bocca triste che una felice naso). Questo significa che possiamo evitare di usare le ancore, ma assicuriamo invece che ci siano più personaggi sull'altro lato della bocca.

Quindi le bocche valide per i volti felici sono ] ) D 3 > }a destra o < [ ( {a sinistra. Abbiniamo quelli con .+[])D3>}]|[<[({].+e li sostituiamo con happy. Se non abbinassimo ci saranno due o tre caratteri nella stringa (l'emoticon), ma se lo facessimo ci saranno cinque ( happy). Quindi, in un secondo passaggio, sostituiamo due o tre caratteri con sad.

JavaScript (ES6), 46

Usare una regexp per trovare emoticon tristi, ovvero quelle che iniziano >)]}o finiscono con <([{c. Nota a margine: altri regexps qui potrebbero essere più brevi ma non sono sicuro di capirli.

Nota usuale: test di esecuzione dello snippet su qualsiasi browser compatibile con EcmaScript 6 (in particolare non il più recente Chrome ma non MSIE. Ho provato su Firefox, Safari 9 potrebbe andare)

Grandi novità Sembra che le funzioni delle frecce siano finalmente arrivate su 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 byte - risparmiato 18 byte grazie ad Alex A.

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

Python 3 , 77 75 74 72 61 55 byte

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

Provalo online!

Come funziona

Se una sequenza di facce inizia ])>}o finisce con [(c<{, è triste, altrimenti è felice. L'indicizzazione tupla viene utilizzata come if.

Brachylog , 50 byte

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

Spiegazione

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

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 byte

Deve esserci un modo per ridurre le dimensioni qui.

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

L'input è una stringa di smiley. Il primo e l'ultimo personaggio verranno confrontati per determinare se è triste. Altrimenti, è felice.

Sono stato in grado di salvare 2 byte non visualizzando entrambi, ma assegnandoli invece alla variabile predefinita (ans) di MATLAB e quindi visualizzando ans dopo l'istruzione if. Ma sono convinto che possa essere migliorato in qualche modo.

Miglioramento di 2 byte modificando la funzione s (e), in e = input (''); .

PowerShell, 92 byte

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

Un po 'prolisso, ma come bonus, non usa regex!

Questo sfrutta la <string>.IndexOf()funzione .NET che ritorna -1se il personaggio non lo è trovato nella stringa. Quindi, se il primo personaggio non è un personaggio "felice", il primo IndexOf()sarà -1 - allo stesso modo per l'ultimo personaggio. Quindi, se è una faccia triste, la IndexOf()s si somma sempre a -2, il che significa che -eq-2è $TRUEe quindi sadviene stampata.

Variante bonus: PowerShell con Regex, 95 byte

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

Python 3 , 75 byte

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

Provalo online

L'importazione regex lo rende un po 'troppo lungo, così come l'impossibilità di utilizzarlo Nonecome indice di array. Ma mi piace regex :)

Java 8, 52 byte

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

Provalo online.

Spiegazione:

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#matchesaggiunge implicitamente ^...$di abbinare l'intera stringa, motivo per cui è più breve cercare facce tristi invece di cercare facce felici come fanno la maggior parte delle altre risposte .+[\\])D3>}]|[<\\[({].+(perché il mio regex fallirebbe nella risposta Retina di @MartinEnder , ad esempio, a causa di il felice test case :c)).

Spiegazione 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