Am I happy or sad? [duplicate]

Question

You are trying to guess my emotion.

I will give you an adjective, as the input to the function/program.

Your task is to output my emotion, either :) for happy, or :( for sad.

Details

For these adjectives, you must output the happy face :)

contented
delighted
merry
overjoyed
pleased
blessed
chipper
content
convivial
gleeful
gratified
intoxicated
jolly
light
peppy
perky
playful
sparkling
sunny

For these adjectives, you must output the sad face :(

melancholy
bitter
somber
dismal
mournful
blue
dejected
despairing
despondent
disconsolate
distressed
down
downcast
gloomy
glum
heavyhearted
lugubrious
morbid
morose
troubled
bereaved

Other adjectives are undefined. You may output whatever you want for other adjectives.

Specs

• All in lowercase. All matches regex ^[a-z]+$.

Scoring

This is code-golf. Shortest solution in bytes wins.

Tips

There is a trick.

Answer 1

CJam, 9 bytes

':q,"()"=

The "trick" is the parity of the word lengths.

Test it here.

Explanation

':     e# Push character ':'.
q,     e# Get length of input.
"()"=  e# Using length as cyclic index into "()", giving '(' for even lengths
       e# and ')' for odd lengths.

Answer 2

Brainfuck, 71 bytes

+[--------->+<]>+.>,+[[-]>[->+<]+>[<->-]<<,+]>[<<+>>-]<+++[<------>-]<.

Assumes that EOF = -1.

Explaination:

The first part, +[--------->+<]>+., prints : and stores its ascii value (58) in cell #2.

The second part, >,+[[-]>[->+<]+>[<->-]<<,+], is a bit more complicated. For each character in the input, it moves the value in cell #4 into cell #5, it adds one to cell #4, and sets cell #4 = cell #4 - cell #5. Basically, what this does is it changes cell #4 into 1 - cell #4. When every character has been read, cell #4 is length of input % 2.

The third part, >[<<+>>-] adds the value of cell #4 to cell #2.

The last part, >,+[[-]>[->+<]+>[<->-]<<,+] subtracts 18, which is the difference in the ascii table from the colon and the left parentesens from cell #2 and prints it.

Answer 3

J, 15 bytes

':',"0'()'{~2|#

':',"0 concats ':' with the 0-cells of the string '()', making an array of :( and :). {~ is get with switched argument order, 2| is the parity of the length # of the RHS.

  p =: ':',"0'()'{~2|#
  p 'happy'
:)
  p 'somber'
:(

Use (>;p)"0 to test a list of words and compare their output.

Answer 4

Reng v.3.3, 12 bytes

":("k2,+roo~

This puts 58, 40 on the stack, gets the length of the input stack, 2, modulos by 2, + adds it to the (, r reverses, oo outputs two characters, and ~ terminates the program. Try it here! Input is like "somber". I don't think we need a GIF for this ;)

Answer 5

05AB1E, 10 bytes

Code:

':žuâ`¹gÉ@

Dammit, also 10 bytes: gÉ40+ç':sJ.

Uses CP-1252 encoding. Try it online!.

Answer 6

Jelly, 8 bytes

Code:

”:³Lị“)(

Explanation:

”:         # The ":" character
  ³L       # Get the length of the input
    ị“)(   # Find the index of the length in the ")(" string.
           # Uses cyclic indexing for indices exceeding the length of the string.

Uses the Jelly-encoding.

Try it online!.

Answer 7

MATL, 11 10 bytes

58')('jn)h

1 byte saved thanks to @Luis's tip to just rely upon modular indexing rather than an explicit modulus.

Try it Online!

Explanation

58      % Number literal (ASCII for ':')
')('    % String literal
j       % Explicitly grab input as string
n       % Compute the length of the input string
)       % Index into ')(' using modular indexing
h       % Horizontally concatenate ':' with the result
        % Implicitly display resulting string

Answer 8

Retina, 21 18 14 bytes

(..)+
:(
\(.
)

3 bytes saved thanks to Martin Büttner. Another 4 saved thanks to Kenny Lau.

Try it online! (The first line is just to make it run for all test cases).

Uses the same approach as Martins answer.

Answer 9

Fuzzy Octo Guacamole, 22 bytes

^!_2rm{':('0}i{':)'1}_

Gets input, finds length%2, prints :) vs :( for on a remainder of 1 or 0.

Answer 10

Lua, 35 34 30 bytes

print(#(...)%2>0 and":)"or":(")

Answer 11

Jolf, 12 11 bytes

+':."()"mρl

I might (might) be was able to golf it down a byte by joining the faces. Try it here!

Explanation

+':."()"mρl
+':          ":" + 
   ."()"     the member from "()"
        mρl  that is the parity of the length of the implicit input

Answer 12

Javascript 30 bytes

a=>alert(a.length%2?":)":":(")

Javascript return version 23 bytes

a=>a.length%2?":)":":("

Try it out:

b=a=>a.length%2?":)":":("
alert(b(prompt("Please enter how you feel!")));

Answer 13

JavaScript ES6, 23 bytes

x=>":"+"()"[x.length%2]

Simple anonymous function.

Test

f = x => ":" + "()" [x.length % 2];
makeRow = (x, y) => t.innerHTML += `<tr><td>${x}</td><td>${y}</td></tr>`;
`contented
delighted
merry
overjoyed
pleased
blessed
chipper
content
convivial
gleeful
gratified
intoxicated
jolly
light
peppy
perky
playful
sparkling
sunny`.split(`\n`).forEach(e => makeRow(e, f(e)));

t.innerHTML += "<tr><th colspan=2>Sad cases</th></tr>";

`melancholy
bitter
somber
dismal
mournful
blue
dejected
despairing
despondent
disconsolate
distressed
down
downcast
gloomy
glum
heavyhearted
lugubrious
morbid
morose
troubled
bereaved`.split(`\n`).forEach(e => makeRow(e, f(e)));

html {
  font-family: Consolas, monospace;
}
table {
  border-collapse: collapse;
}
td,
th {
  padding: 10px;
  border: 1px solid;
}

<table id="t">
  <tr>
    <th>Word</th>
    <th>Output</th>
  </tr>
  <tr>
    <th colspan=2>Happy cases</th>
  </tr>
</table>

Answer 14

Labyrinth, 14 bytes

4
1
#$
;,98..@

Try it online!

Explanation

Labyrinth primer:

• Labyrinth has two stacks of arbitrary-precision integers, main and aux(iliary), which are initially filled with an (implicit) infinite amount of zeros.
• The source code resembles a maze, where the instruction pointer (IP) follows corridors when it can (even around corners). The code starts at the first valid character in reading order, i.e. in the top left corner in this case. When the IP comes to any form of junction (i.e. several adjacent cells in addition to the one it came from), it will pick a direction based on the top of the main stack. The basic rules are: turn left when negative, keep going ahead when zero, turn right when positive. And when one of these is not possible because there's a wall, then the IP will take the opposite direction. The IP also turns around when hitting dead ends.
• Digits are processed by multiplying the top of the main stack by 10 and then adding the digit. If the top of the stack is negative, the digit is subtracted instead.

The code starts in the top left corner, with the IP moving south. The 41 simply turns the top 0 on the main stack into 41, the character code of ).

We now enter a 2x2 (clockwise) loop which reads one character at a time, and toggles the top of the stack between 40 (() and 41 ()):

#   Push the stack depth, which is 1.
$   XOR the top two values on the stack, toggling between 40 and 41.
,   Read a character (positive value) or -1 at EOF. At EOF, we exit the loop.
;   Discard the character.

At the end of the loop, the main stack has the correct character code for either ( or ) and a -1 on top of that. The rest of the code is linear.

98  Turn the -1 on top of the stack into -198.
.   Print the top of the stack, modulo 256. -198 % 256 == 58, the character
    code of ':'.
.   Print the top of the stack, i.e. the mouth of the emoticon.
@   Terminate the program.