Schreiben Sie ein Programm, das ein Emoticon als Eingabe akzeptiert und ausgibt, wenn das Emoticon glücklich oder traurig ist.

Das Programm akzeptiert eine Zeichenfolge als Eingabe oder Parameter und sollte die Zeichenfolge "happy" anzeigen, wenn sich die Eingabe in der Liste "happy emoticon" befindet, oder "sad", wenn sich die Eingabe in der Liste "sad emoticon" befindet.

Sie können davon ausgehen, dass die Eingabe immer ein gültiges (fröhliches oder trauriges) Emoticon ohne Leerzeichen oder Tabulatoren ist.

Hier ist eine durch Leerzeichen getrennte Liste glücklicher Emoticons:

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

Hier ist eine durch Leerzeichen getrennte Liste von traurigen Emoticons:

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

Das ist Code-Golf, also gewinnt das kürzeste Programm.

Python, 86 Bytes

Ich sollte ins Gefängnis geschickt werden.

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

Die kürzeste Antwort, die ich finden konnte, war gleichbedeutend mit Martins CJam-Antwort. Deshalb entschloss ich mich, alle traurigen Emojis (abzüglich des mittleren Zeichens, falls vorhanden) auf der Rückseite meines Codes zu verstecken und Pythons __file__Quine-Cheat zu verwenden.

Muahahaha.

CJam, 33 32 Bytes

Vielen Dank an Dennis für das Speichern von 1 Byte.

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

Sieht so aus, als wäre es kürzer, dasselbe ohne Regex zu tun ...

Teste es hier.

Erläuterung

Dies basiert auf der gleichen Beobachtung wie die Retina-Antwort, aber diesmal hat das Abgleichen von glücklichen Gesichtern keinen Vorteil, sodass wir stattdessen traurige Gesichter abgleichen (da ein Mund weniger zu berücksichtigen ist). Die Lösung ist ansonsten genau die gleiche, außer dass sie nicht durch reguläre Ausdrücke ersetzt wird:

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

Wir können alle Emoticons an ihren Mündern erkennen, da keiner der Münder als Hut oder Augen in der anderen Gruppe verwendet wird (nur in derselben Gruppe). Die glücklichen haben noch einen Mund, den sie berücksichtigen müssen, aber sie haben den Vorteil, dass die Münder im anderen Satz überhaupt nicht erscheinen, nicht einmal als Nasen (das Gegenteil ist nicht wahr: cist sowohl ein trauriger Mund als auch ein glücklicher Nase). Das heißt, wir können Anker vermeiden, sondern nur sicherstellen, dass sich mehr Zeichen auf der anderen Seite des Mundes befinden.

Die gültigen Münder für glückliche Gesichter sind also ] ) D 3 > }rechts oder < [ ( {links. Wir passen diese an .+[])D3>}]|[<[({].+und ersetzen sie durch happy. Wenn wir nicht übereinstimmen, enthält die Zeichenfolge zwei oder drei Zeichen (das Emoticon). Wenn wir dies tun, sind es fünf ( happy). In einem zweiten Schritt ersetzen wir also zwei oder drei Zeichen durch sad.

JavaScript (ES6), 46

Verwenden eines regulären Ausdrucks, um traurige Emoticons zu finden, die mit beginnen >)]}oder mit enden <([{c. Randnotiz: Andere reguläre Ausdrücke hier sind möglicherweise kürzer, aber ich bin nicht sicher, ob ich sie verstehe.

Üblicher Hinweis: Testen Sie die Ausführung des Snippets in jedem EcmaScript 6-kompatiblen Browser (insbesondere nicht in Chrome, aber nicht in MSIE. Ich habe es in Firefox getestet, Safari 9 könnte funktionieren).

Große Neuigkeit Es scheint, dass die Pfeilfunktionen endlich im Chrome-Land angekommen sind! Rel 45, August 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 - dank Alex A 18 Bytes gespart

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'])>}']

Probieren Sie es online!

Wie funktioniert es

Wenn eine Gesichtszeichenfolge mit beginnt ])>}oder mit endet[(c<{ , ist es traurig, sonst ist es glücklich. Tupel-Indexierung wird als verwendet if.

Brachylog , 50 Bytes

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

Erläuterung

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

Hier muss es eine Möglichkeit geben, die Größe zu reduzieren.

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

Die Eingabe ist eine Smiley-Zeichenfolge. Das erste und das letzte Zeichen werden verglichen, um festzustellen, ob es traurig ist. Wenn nicht, ist es glücklich.

Ich konnte 2 Bytes sparen, indem ich sie nicht anzeigte, sondern stattdessen der Standardvariablen (ans) von MATLAB zuwies und dann ans nach der if-Anweisung anzeigte. Aber ich bin überzeugt, dass es irgendwie verbessert werden kann.

Verbesserung um 2 Bytes durch Änderung der Funktion s (e) auf e = Eingabe (''); .

PowerShell, 92 Bytes

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

Ein bisschen wortreich, aber als Bonus wird Regex nicht verwendet!

Dies nutzt die .NET- <string>.IndexOf()Funktion, die zurückgibt, -1wenn das Zeichen nicht in der Zeichenfolge gefunden wird. Wenn also das erste Zeichen kein "fröhliches" Zeichen ist, ist das erste IndexOf()-1 - ebenfalls für das letzte Zeichen. Wenn es sich also um ein trauriges Gesicht handelt, IndexOf()summiert sich das s immer auf -2, was bedeutet, dass es -eq-2ist $TRUE, und wird daher sadgedruckt.

Bonusvariante: PowerShell mit 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

Probieren Sie es online aus

Der Regex-Import macht es ein bisschen zu lang, ebenso wie die Unfähigkeit, ihn Noneals Array-Index zu verwenden. Aber ich mag Regex :)

Java 8, 52 Bytes

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

Probieren Sie es online aus.

Erläuterung:

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#matchesfügt implizit hinzu ^...$, dass es mit der gesamten Zeichenfolge übereinstimmt. Aus diesem Grund ist es kürzer, nach traurigen Gesichtern zu suchen , anstatt nach glücklichen Gesichtern zu suchen , wie dies bei den meisten anderen Antworten der Fall ist.+[\\])D3>}]|[<\\[({].+ (da meine Regex beispielsweise aufgrund von in @MartinEnders Retina-Antwort fehlschlagen würde) der glückliche Testfall :c)).

Regex Erklärung:

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