text:
Proving you are the best StackExchange-User
Write one/two program(s)/function(s):

The first one should return a truthy value if given your Stack Exchange username.

~~Optional~~

An obfuscated one (as explained below) that does the same thing.

Rules for number 2:

May be no more than ten times the byte-count of number 1 or 100 bytes, whichever is higher.
Must be written in the same language as number 1.

Test cases
(for my case:)
input        output
-------------------
Seims        true
BestCoderXX  false

Winning
This is code-golf, so shortest byte count for number one wins.

Welcome to PPCG! You've chosen a minefield as your first challenge question, so fair warning for that. Additionally, I've voted to close your challenge as Too Broad, since "Make your code as obfuscated as possible" is exceedingly broad. That said, I hope you enjoy your time here and again, welcome!

@Seims I hope you see the value of the Sandbox. :D

"Your username may not occur in the code in any of these forms", that's not very clear, if the arguments of the function spell my name, but they don't change the outcome of the function, does that count?

And please, refrain from changing the challenge halfway trough

the title is irrelevant

also i have a sandboxed challenge about obfuscating the way you want a "fix" name printed, with measures the thing your challenge is lacking, you must specify measures which by an obfuscation-technique is better than the other.

JavaScript
[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]([][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]+([]+[])[([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]][([][[]]+[])[+!![]]+(![]+[])[+!![]]+([]+(+[])[([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]])[+!![]+[+!![]]]+(!![]+[])[!![]+!![]+!![]]]+(+(+!![]+[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+!![])+(+[]))+[])[+!![]]+(![]+[])[+[]]+(!![]+[])[+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([]+(+[])[([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]])[+!![]+[+!![]]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]+(![]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][(!![]+[])[!![]+!![]+!![]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([![]]+[][[]])[+!![]+[+[]]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]+!![]]]()+[])[!![]+!![]])()(+[]+[+[]]+(+[![]])+![])[+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[!![]+!![]]+(!![]+[])[!![]+!![]+!![]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(![]+[])[+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(![]+[])[!![]+!![]+!![]]+([][(!![]+[])[!![]+!![]+!![]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([![]]+[][[]])[+!![]+[+[]]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]+!![]]]()+[])[!![]+!![]]+(![]+[])[+!![]]+(!![]+[])[+!![]])()+[])[+!![]+[+!![]]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([![]]+[][[]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[!![]+!![]+!![]]]+(+!![]+[+!![]]+(!![]+!![]+!![]+!![])+![]+(+!![])+(+[])+(+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(+[])+![]+(!![]+!![]+!![])+(!![]+!![])+![]+(+!![])+(+[])+(!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(+[])+![]+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+[])+(!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(+!![])+![]+(+!![])+(+!![])+(+[])+![]+(!![]+!![]+!![]+!![])+(+[])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![])+(+!![])+![]+(+!![])+(!![]+!![])+(!![]+!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![])+![]+(+!![])+(+[])+(+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(+[])+![]+(!![]+!![]+!![])+(!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![]+!![]+!![])+(+!![])+![]+(!![]+!![]+!![]+!![]+!![]+!![])+(+!![])+![]+(!![]+!![]+!![]+!![]+!![]+!![])+(+!![])+![]+(!![]+!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+(!![]+!![])+![]+(!![]+!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![])+(+[])+![]+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+(+!![])+![]+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+(!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+(!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![])+(!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![])+(+!![])+![]+(!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+[])+(+!![])+![]+(+!![])+(!![]+!![])+(+[])+![]+(+!![])+(+[])+(+!![])+![]+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![])+(+[])+![]+(+!![])+(+[])+(+[])+![]+(+!![])+(+!![])+(+!![])+![]+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+[])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+[])+(+!![])+![]+(+!![])+(+!![])+(+[])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+[])+(+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![])+![]+(+!![])+(!![]+!![])+(+!![])+![]+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+(!![]+!![]+!![])+![]+(+!![])+(+[])+(+!![])+![]+(+!![])+(+[])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+[])+(+!![])+![]+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![])+(+[])+![]+(!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(+!![])+![]+(+!![])+(+[])+(!![]+!![])+![]+(+!![])+(+[])+(!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+[])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+[])+(+!![])+![]+(!![]+!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+[])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+[])+(+!![])+![]+(!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![])+(+!![])+![]+(!![]+!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+[])+(!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![])+![]+(+!![])+(+[])+(+!![])+![]+(+!![])+(+[])+(!![]+!![])+![]+(!![]+!![]+!![]+!![])+(+!![])+![]+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+(+!![])+![]+(!![]+!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+(!![]+!![]+!![])+![]+(+!![])+(!![]+!![])+(!![]+!![]+!![]+!![]+!![]))[(![]+[])[!![]+!![]+!![]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]+([][(!![]+[])[!![]+!![]+!![]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([![]]+[][[]])[+!![]+[+[]]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]+!![]]]()+[])[!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(![]+[])[+!![]])()([][[]]))[+!![]+[+[]]]+(![]+[])[!![]+!![]]+([![]]+[][[]])[+!![]+[+[]]]+(!![]+[])[+[]]](![])+(+[]+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]])())()

To run:
Open the console (Ctrl + Shift + I)
Type f =
Paste the above
To use:
f('the string you want to test')
EDIT: fixed ES6 version below
[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]([][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]+([]+[])[([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]][([][[]]+[])[+!![]]+(![]+[])[+!![]]+([]+(+[])[([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]])[+!![]+[+!![]]]+(!![]+[])[!![]+!![]+!![]]]+(+(+!![]+[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+!![])+(+[]))+[])[+!![]]+(![]+[])[+[]]+(!![]+[])[+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([]+(+[])[([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]])[+!![]+[+!![]]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]+(![]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][(!![]+[])[!![]+!![]+!![]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([![]]+[][[]])[+!![]+[+[]]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]+!![]]]()+[])[!![]+!![]])()(+[]+[+[]]+(+[![]])+![])[+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[!![]+!![]]+(!![]+[])[!![]+!![]+!![]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(![]+[])[+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(![]+[])[!![]+!![]+!![]]+([][(!![]+[])[!![]+!![]+!![]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([![]]+[][[]])[+!![]+[+[]]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]+!![]]]()+[])[!![]+!![]]+(![]+[])[+!![]]+(!![]+[])[+!![]])()+[])[+!![]+[+!![]]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([![]]+[][[]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[!![]+!![]+!![]]]+(+!![]+[+!![]]+(!![]+!![]+!![]+!![])+![]+(+!![])+(+[])+(+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(+[])+![]+(!![]+!![]+!![])+(!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![]+!![]+!![])+(+!![])+![]+(!![]+!![]+!![]+!![]+!![]+!![])+(!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![]+!![]+!![])+(+!![])+![]+(!![]+!![]+!![]+!![]+!![]+!![])+(+!![])+![]+(+!![])+(+[])+(+[])+![]+(+!![])+(+!![])+(+!![])+![]+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+[])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+[])+(+!![])+![]+(+!![])+(+!![])+(+[])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+[])+(+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![])+![]+(+!![])+(!![]+!![])+(+!![])+![]+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+(!![]+!![]+!![])+![]+(+!![])+(+[])+(+!![])+![]+(+!![])+(+[])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+[])+(+!![])+![]+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![])+(+[])+![]+(!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+[])+(!![]+!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![])+![]+(+!![])+(+[])+(+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![]+!![])+(+[])+![]+(!![]+!![]+!![]+!![]+!![])+(!![]+!![])+![]+(!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![])+(+!![])+![]+(!![]+!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+[])+(!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+[])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+[])+(+!![]))[(![]+[])[!![]+!![]+!![]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]+([][(!![]+[])[!![]+!![]+!![]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([![]]+[][[]])[+!![]+[+[]]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]+!![]]]()+[])[!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(![]+[])[+!![]])()([][[]]))[+!![]+[+[]]]+(![]+[])[!![]+!![]]+([![]]+[][[]])[+!![]+[+[]]]+(!![]+[])[+[]]](![])+(+[]+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]])())()

Note: This checks equality with the username of whoever runs it, not my username

What obfuscator do you use? This looks like Brainfuck

@Bálint JSFuck.

This doesn't work. What is your name? Not somebody.

@EᴀsᴛᴇʀʟʏIʀᴋ Note: This checks equality with the username of whoever runs it, not my username

Doesn't work for my name.

Ah, didn't work for me either when I tried "fede s." "fede s" "fedes" etc... It worked with "fede-s", so I'm guessing it might be the whitespace @EᴀsᴛᴇʀʟʏIʀᴋ ?

Then it needs to be fixed.

Python 2 (Non-Competing)
This was posted before the rules were changed significantly.
False = True; True = False; True = True; print (`'Riker'.lower().upper()`=="Riker" and "Riker" == `raw_input()`) <> True and raw_input()=="Riker"

Javascript
eval(function(B,á,l,i,n,t){if(n=function(B){return B},!"".replace(/^/,String)){for(;l--;)t[l]=i[l]||l;i=[function(B){return t[B]}],n=function(){return"\\w+"},l=1}for(;l--;)i[l]&&(B=B.replace(new RegExp("\\b"+n(l)+"\\b","g"),i[l]));return B}('3 4(0){2(!(0=="9á5")){{1 7}}6{{1 8}}}',10,10,"notMyName|return|if|function|HELLO_WORLD|lint|else|false|true|B".split("|"),0,{}));

I first created a half-readable code, then I ran it trough RegPack, then an obfuscator, then a minifier, then RegPack again, and lastly a different minifier.
Note: RegPack is worse than an obfuscator
Made a slight modification on variable names after @LeakyNun pointed out something

You should make the six variables spell your name :)

@LeakyNun That's actually a cool idea

Python 2 (Non-Competing)
This was posted before the rules were changed significantly.
print raw_input()=="Eᴀsᴛᴇʀʟʏ Iʀᴋ"

Quite obfuscated to non-programmers or people who only code in brainfuck.
@Downvoters: Also serves to point out the definition of "obfuscated" needs to be fixed.

Java
public boolean eval( String username )
{
    int s = 2304854;
    int w = 1660790;
    String r = "";
    int l = username.length();
    int b = 0;
    Random ra = new Random( s );
    boolean sw = false;
    for ( int i = 0; i < l; i++ )
    {
        if ( !sw && i > 5 )
        {
            sw = true;
            ra = new Random( w );
        }
        int ran = ra.nextInt( 25 ) + 97;
        b |= ( ( i == 5 ? ' ' : ran - ( ( i == 0 || i == 6 ) ? 32 : 0 ) == username.getBytes()[ i ] ? 1 : 0 ) << i );
    }
    return b == 2015 && l == 10;
}

None- Golfed
public boolean isShaunWild(String name){
    return name.equals("Shaun Wild");
}

Just a bit of fun haha. Horribly unreadable and hard to understand what it is without reading through it a couple of million times :)

+1) I was thinking about similar solution, but first i split it into couple functions, and seed wasn't plain number, but it was result of some obscure calculations

I was actually going to do that but I didn't want to put it across more than one function and I ran out of time at my office and had to leave so I couldn't obfuscate the seeds further.

Pyth
q1409257787840474805614C

Test suite.
Encodes the input string in base-256, and then check if it is equal to 1409257787840474805614.

But this is simple string encoding....

@BaldBantha could you tell that spells “leaky nun”?

05AB1E
žnžo‡"Vnrtmz"Q

Uses the Atbash cipher.
Try it online

Perl 5
eval eval '"'.('`'|'%').('['^'-').('`'|'!').('`'|',').('{'^'[').('['^'.').('`'|'.').('['^'+').('`'|'!').('`'|'#').('`'|'+').('{'^'[').('['^'.').'='.'>'.('['^'*').'\\'.'{'.'_'.(';'&'=').('^'^('`'|')')).(';'&'=').('`'^'!').';'.'\\'.'"'.'!'.('{'^'.').';'.('`'^"'").'!'.('`'^'!').(':'&'=').('{'^'-').('`'^',').('`'^'"').('^'^('`'|')'))."'".'\\'.'@'.('{'^',').'-'.('^'^('`'|',')).'('.('`'^',').'('.('`'^'%').('{'^'*').('{'^'#').'-'.('^'^('`'|'*')).(';'&'=').'<'.'>'.'#'.'('.('{'^'"').('^'^('`'|')'))."'".'\\'.'@'.('{'^')').'-'.('^'^('`'|'+')).('{'^'*').('{'^'#').'-'.('^'^('`'|'*')).'-'.'<'.'>'.'#'.('^'^('`'|'+')).'\\'.'$'.('^'^('`'|')'))."'".'\\'.'@'.('{'^')').('^'^('`'|'.')).('^'^('`'|'+')).('{'^'*').('{'^'#').','.('`'^'#').'-'.'<'.'>'.'#'.('^'^('`'|'*')).('{'^'+').('^'^('`'|')'))."'".'\\'.'@'.('{'^'.').('^'^('`'|'/')).('^'^('`'|'+')).('{'^'*').('{'^'#').','.('{'^'(').('`'^'%').'<'.'>'.'#'.','.('{'^',').'_'.('^'^('`'|')'))."'".'\\'.'@'.('{'^')').'-'.'%'.('{'^'*').('{'^'#').'-'.'#'.')'.'<'.'>'.'#'.','.('{'^',').('^'^('`'|')'))."'".'\\'.'@'.('{'^')').'-'.('{'^'.').('{'^'*').('{'^'#').'-'.'#'.'!'.'<'.'>'.'#'.('^'^('`'|'*')).('{'^'.').('^'^('`'|')'))."'".'\\'.'@'.('{'^')').('^'^('`'|'.')).('{'^'.').('{'^'*').('{'^'#').','.('`'^'#').('^'^('`'|'+')).'<'.'>'.'#'.('^'^('`'|'*')).('{'^'*').('^'^('`'|')'))."'".'\\'.'@'.('{'^'.').'.'.'%'.('{'^'*').('{'^'#').','.('`'^'$').('^'^('`'|'/')).'<'.'>'.'#'.('^'^('`'|'.')).('{'^'(').('^'^('`'|')'))."'".'\\'.'@'.('{'^')').'-'.('^'^('`'|'+')).('{'^'*').('{'^'#').','.('{'^'/').'-'.'<'.'>'.'#'.'-'.'%'.('^'^('`'|')'))."'".'\\'.'@'.('{'^')').'_'.','.('{'^'.').('{'^'*').('{'^'#').','.('{'^'/').'-'.'<'.'>'.'#'.('^'^('`'|'*')).('{'^'.').('^'^('`'|')'))."'".'\\'.'@'.('{'^'(').'-'.('{'^'.').('{'^'*').('{'^'#').','.('`'^'#').'='.'<'.'>'.'#'.('^'^('`'|'.')).('{'^'+').('^'^('`'|')'))."'".'\\'.'@'.('{'^'.').'-'.('`'^'%').('{'^'*').('{'^'#').','.('{'^'(').('`'^'!').'<'.'>'.'#'.('^'^('`'|'*')).('{'^'.').('^'^('`'|')'))."'".'\\'.'@'.('{'^'.').','.('^'^('`'|'+')).('{'^'*').('{'^'#').'-'.('^'^('`'|'-')).('`'^'!').'<'.'>'.'#'.')'.'#'.('^'^('`'|')'))."'".'\\'.'@'.('{'^'/').','.('{'^'.').('{'^'*').('{'^'#').','.('`'^'#').'%'.'<'.'>'.'#'.'-'.'#'.('^'^('`'|')'))."'".'\\'.'@'.('{'^'(').('^'^('`'|'/')).('^'^('`'|'+')).('{'^'*').('{'^'#').'_'.','.('`'^'#').'-'.'<'.'>'.'#'.','.('{'^'/').('^'^('`'|')'))."'".'\\'.'@'.('{'^'.').','.'%'.('{'^'*').('{'^'#').','.('{'^'(').'='.'<'.'>'.'#'.'('.('{'^',').('^'^('`'|')'))."'".'\\'.'@'.('{'^'/').','.'%'.('{'^'*').('{'^'#').'-'.('^'^('`'|'-')).(';'&'=').'<'.'>'.'#'.')'.'%'.('^'^('`'|')'))."'".'\\'.'@'.('{'^'(').'-'.('^'^('`'|'+')).('{'^'*').('{'^'#').'-'.('^'^('`'|'-')).'%'.'<'.'>'.'#'.('^'^('`'|'*')).('{'^'#').('^'^('`'|')'))."'".'\\'.'@'.('{'^')').('^'^('`'|'/')).'%'.('{'^'*').('{'^'#').'-'.'#'.'-'.'<'.'>'.'#'.')'.'\\'.'$'.('^'^('`'|')'))."'".'\\'.'@'.('{'^'(').('^'^('`'|'.')).('{'^'.').('{'^'*').('{'^'#').','.('{'^'/').('^'^('`'|'+')).'<'.'_'.'>'.'#'.'('.('{'^'(').('^'^('`'|')'))."'".'\\'.'@'.('{'^'(').'.'.'%'.('{'^'*').('{'^'#').'-'.('^'^('`'|'-')).'%'.'<'.'>'.'#'.','.('{'^',').('^'^('`'|')'))."'".'\\'.'@'.('{'^')').'-'.('{'^'.').('{'^'*').('{'^'#').'-'.'#'.'!'.'<'.'>'.'#'.('^'^('`'|'*')).('{'^',').('^'^('`'|')'))."'".'\\'.'@'.('{'^')').('^'^('`'|'.')).('{'^'.').('{'^'*').('{'^'#').'-'.'#'.('^'^('`'|'+')).'<'.'>'.'#'.('^'^('`'|'*')).('{'^'*').('^'^('`'|')'))."'".'\\'.'@'.('{'^'.').'.'.'%'.('{'^'*').('{'^'#').','.('`'^'$').('^'^('`'|'/')).'<'.'>'.'#'.('^'^('`'|'.')).('{'^'(').('^'^('`'|')'))."'".'\\'.'@'.('{'^'(').','.'%'.('{'^'*').('{'^'#').'-'.'#'.')'.'<'.'>'.'#'.')'.'!'.'_'.('^'^('`'|')'))."'".'\\'.'@'.('{'^'(').','.('{'^'.').('{'^'*').('{'^'#').'-'.('^'^('`'|'*')).'-'.'<'.'>'.'#'.('^'^('`'|'.')).('{'^')').('^'^('`'|')'))."'".'\\'.'@'.('{'^'(').'-'.('{'^'.').('{'^'*').('{'^'#').','.('`'^'#').'='.'<'.'>'.'#'.('^'^('`'|'.')).('{'^'+').('^'^('`'|')'))."'".'\\'.'@'.('{'^'.').'-'.('^'^('`'|'+')).('{'^'*').('{'^'#').','.('`'^'$').('^'^('`'|'/')).'<'.'>'.'#'.'('.('{'^'.').('^'^('`'|')'))."'".'\\'.'@'.('{'^'.').','.('^'^('`'|'+')).('{'^'*').('{'^'#').'-'.('^'^('`'|'-')).('`'^'!').'<'.'>'.'#'.('^'^('`'|'.')).('{'^'#').('^'^('`'|')'))."'".'\\'.'@'.('{'^')').('^'^('`'|'/')).'%'.('{'^'*').('{'^'#').'-'.('^'^('`'|'-')).'-'.'<'.'>'.'#'.'('.('{'^'"').('^'^('`'|')'))."'".'\\'.'@'.('{'^'(').'_'.('^'^('`'|'.')).('{'^'.').('{'^'*').('{'^'#').','.('{'^'/').('^'^('`'|'+')).'<'.'>'.'#'.'('.('{'^'(').('^'^('`'|')'))."'".'\\'.'@'.('{'^'(').('^'^('`'|'.')).('{'^'.').('{'^'*').('{'^'#').'-'.('^'^('`'|'-')).('^'^('`'|'+')).'<'.'>'.'#'.','.('{'^',').('^'^('`'|')'))."'".'\\'.'@'.('{'^')').'-'.('{'^'.').('{'^'*').('{'^'#').'-'.'#'.'!'.'<'.'>'.'#'.('^'^('`'|'*')).('{'^'-').('^'^('`'|')'))."'".'\\'.'@'.('{'^')').('^'^('`'|'/')).'%'.('{'^'*').('{'^'#').','.('{'^'(').')'.'<'.'>'.'#'.'('.('{'^'#').('^'^('`'|')'))."'".'\\'.'@'.('{'^'.').('^'^('`'|'.')).('^'^('`'|'+')).('{'^'*').('{'^'#').','.('`'^'#').('`'^'!').'<'.'>'.'#'.('^'^('`'|'.')).('{'^'.').('^'^('`'|')'))."'".'\\'.'@'.('{'^'.').','.('^'^('`'|'+')).('{'^'*').('{'^'#').'_'.'-'.('^'^('`'|'-')).('`'^'!').'<'.'>'.'#'.')'.'\\'.'$'.('^'^('`'|')'))."'".'\\'.'@'.('{'^')').','.('{'^'.').('{'^'*').('{'^'#').','.('{'^'(').('`'^'%').'<'.'>'.'#'.'-'.'#'.('^'^('`'|')'))."'".'\\'.'@'.('{'^'(').('^'^('`'|'/')).('^'^('`'|'+')).('{'^'*').('{'^'#').','.('`'^'#').'-'.'<'.'>'.'#'.','.('{'^'#').('^'^('`'|')'))."'".'\\'.'@'.('{'^'.').','.('^'^('`'|'+')).('{'^'*').('{'^'#').','.('{'^'(').'='.'<'.'>'.'#'.'('.('{'^',').('^'^('`'|')'))."'".'\\'.'@'.('{'^'/').','.'%'.('{'^'*').('{'^'#').'-'.('^'^('`'|'-')).(';'&'=').'<'.'>'.'#'.','.('{'^'#').('^'^('`'|')'))."'".'\\'.'@'.('{'^'.').'-'.('^'^('`'|'+')).('{'^'*').('{'^'#').'-'.('^'^('`'|'-')).'%'.'<'.'_'.'>'.'#'.('^'^('`'|'*')).('{'^'#').('^'^('`'|')'))."'".'\\'.'@'.('{'^')').('^'^('`'|'/')).'%'.('{'^'*').('{'^'#').'-'.('^'^('`'|'-')).'-'.'<'.'>'.'#'.')'.'\\'.'$'.('^'^('`'|')'))."'".'\\'.'@'.('{'^'(').('^'^('`'|'.')).('{'^'.').('{'^'*').('{'^'#').','.('{'^'/').('^'^('`'|'+')).'<'.'>'.'#'.'('.('{'^'(').('^'^('`'|')'))."'".'\\'.'@'.('{'^'(').'.'.'%'.('{'^'*').('{'^'#').'-'.('^'^('`'|'-')).('^'^('`'|'+')).'<'.'>'.'#'.'('.('{'^'#').('^'^('`'|')'))."'".'\\'.'@'.('{'^'/').','.('{'^'.').('{'^'*').('{'^'#').'-'.'\\'.'$'.('^'^('`'|'/')).'<'.'>'.'#'.('^'^('`'|'*')).('{'^'+').('^'^('`'|')'))."'".'\\'.'@'.('{'^'(').('^'^('`'|'.')).('{'^'.').('{'^'*').('{'^'#').'-'.'#'.(';'&'=').'<'.'>'.'#'.('^'^('`'|'.')).('{'^'.').')'.('^'^('`'|')'))."'".'\\'.'@'.('{'^'/').('^'^('`'|'/')).('^'^('`'|'+')).('{'^'*').('{'^'#').','.('{'^'/').('^'^('`'|'.')).('`'^'"').'\\'.'}'.('!'^'+').'"'

Original code was a one liner, now... it's technically still a one liner.
Try it here!

Oracle SQL 11.2
Returns 0 if true, 1 if false
SELECT SIGN(ABS(TRUNC(SUM(ASCII(SUBSTR(:1,LEVEL,1))*POWER(10,LEVEL*(LENGTH(:1)-1.14265533)))/CEIL(AVG(LEVEL))-
       CEIL(AVG(POWER(ASCII(SUBSTR(:1,LEVEL,1)),6.42)))+76158.880743588573892)))
FROM DUAL CONNECT BY LEVEL<=LENGTH(:1)

JavaScript ES6
My answer assumes an only-ASCII encoding. This, I am sure, is the optimal solution for JavaScript ES6 in such a setting--this is the only encoding I wish to cover. If anyone wishes to tackle non-ASCII JS, be my guest ;) This clocks in at 61 bytes, leaving me 610 bytes to obfuscate.
n=>n=="C\u1d0f\u0274\u1d0f\u0280 O'B\u0280\u026a\u1d07\u0274"

Here is my obfuscated version, clocking in 588 bytes, less than 610.
(c,f,d,W=this,k=e=>+(`0x`+e),C=(O,...m)=>new(O[w=`constructor`]!=C[w]?O[w]:O)(...m))=>(($,_)=>$<=_&&_<=$)([g=W[(-~(Math.sqrt((P=parseInt)(P,b=31))+P(NaN,b+=5))+0xec)[D=`toString`](b)],t=n=>(j=n=>W[n[D](b)])(n),E=W[505019[D](b)]([...[1663483,552948,1629769,516801].map(e=>e[D](b)).join``].map((s,i)=>+(42742[D](2)[i])?s.toUpperCase():s).join``),A=n=>(p,c)=>p+n+c,...[for(x of c)x.charCodeAt()]].slice(-c.length),g(`[${[...`1${[...`mn0nkjp0mio0nkjp0mkg0ji0np0jp0mm0mkg0mho0nkjh0mio`].reduce(A(-~[]))}`.match(/../g).map(e=>""[w][E](P(e,b)-4)).reduce(a)].reduce((p,c)=>c<"!"?`${p},`:p+c)}]`))

Bonus material
This was my original, 947-byte obfuscation for the original challenge:
(c,d,f,M=Math,W=Z=this,q=($,_)=>$<=_&&_<=$,k=e=>+[`${+[+[]][+[]]}x`+e][+[]],
C=(O,...m)=>new(O[w=`constructor`]!=C[w]?O[w]:O)(...m))=>q([[d=[f=[~c]]+f],g
=W[(-~(M.sqrt(parseInt(P=parseInt,b=~-[[_=+!+[]<<-~![]][+[]]<<[_<<_/_][+[]]]
))+P(NaN,b+=5))+(e=>+[`${+[+[]][+[]]}x`+e][+[]])(C([],...C(Set,[..."abced"].
map(j=>j+i+(u+=[[u,u]],(i=j>i?j:i)?i:[]),i=u=[])[M.atan2(u[l="length"],~[]<<
~[])>>[]])).reduce(a=(p,c)=>p+c,[]+[]))|+[])[D=`toString`](b)],t=n=>(j=n=>W[
n[D](b)])(n),E=t(h=505019)([...[1663483,552948,1629769,h+=11782].map(e=>e[D]
(b)).reduce(a)].map((s,i)=>+[42742[D](2)][+[]][i]?s.toUpperCase():s).reduce(
a)),A=n=>(p,c)=>p+n+c,...[for(x of c)x[`c${E.slice(-7)}${[[]+[]][+[]][w][E](
P(42/_,_<<_<<_))+`${[]+[]}t`}`]()]].slice(-c[l]),g(`[${[...`1${[...`mn0nkjp`
+`0mio0nkjp0mkg0ji0np0jp0mm0mkg0mho0nkjh0mio`].reduce(A(-~[]))}`.match(/../g
).map(e=>[[]+[]][+[]][w][E](P(e,b)-4)).reduce(a)].reduce((p,c)=>c<"!"?`${p},
`:p+c)}]`))

+1 for making the evil more evil

@Seims Well, actually, I made the evil less evil in order for it to fit under 610 bytes ^_^

JavaScript (ES6)
(s)=>/(.)(.)(.)(.)(.)(.)(.)\3[^\1]{6}\2[^\2]{5}\5[^\3]{6}\4[^\4]{5}\6[^\5]{7}\7[^\6]{10}\1[^\7]+/.test(s+atob("YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXogQUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVo="))

C++11
Golfed (129 characters including whitespaces):
#include<iostream>
#include<string>
int main(){std::string s;std::cin>>s;std::cout<<(s.compare("dorukayhan")==0?"true":"false");}

Obfuscated (much less than 1290 characters):
                                                             #define import using namespace
                                                                         #include<iostream>
                                                                           #include<string>
                                                                            #define def int
import std                                                                                ;

def main()                                                                                {
    string s                                                                              ;
    cin >> s                                                                              ;
    char c[] = {100, 111, 114, 117, 107, 97, 121, 104, 97, 110, 0}                        ;
    cout << (s.compare(c) == 0 ? "true" : "false")                                       ;}


text:
Is the gas lighter than air?
Air balloons need a gas that is lighter than air. However, hydrogen is flammable, while helium is not sustainable, so we need a replacement! You must write code that determines whether any given gas is lighter than air.

Input: a molecular chemical formula of a gas (ASCII)
Output: true if the gas is lighter than air; false otherwise (see here for consensus on what can be used as true and false).
If the chemical formula doesn't represent a gas (at standard conditions), or if it's a nonsense, any behavior is acceptable.
That is to say, you can assume the following:

The input is a valid chemical formula
The input is a molecular chemical formula: all element symbols are mentioned only once, and there are no parentheses
The chemical substance exists at normal conditions
The chemical substance is a gas at normal conditions

As a special case, H2O (water vapor) is considered a gas, because you can mix a significant quantity of it with air at standard conditions.

Whether or not a gas is lighter than air can be determined by calculating its molar mass:
Extract the chemical element symbols from the formula. Their atomic masses are given by the following table:

H - 1
He - 4
B - 11
C - 12
N - 14
O - 16
F - 19
Ne - 20
Others - greater values

Calculate the molar mass, which is the sum of all the atomic masses. If the molar mass is less than 29, the gas is lighter than air.

Test cases:

H2      true
He      true
B2H6    true
CH4     true
C2H2    true
C2H4    true
HCN     true
N2      true
NH3     true
H2O     true
CO      true
HF      true
Ne      true
O2      false
C2H6    false
C4H10   false
H2S     false
COH2    false
CO2     false
SiH4    false
NO      false
BN      behavior nor specified: not a gas
HBO2    behavior nor specified: not a gas
F2O     behavior nor specified: incorrect formula
CH3     behavior nor specified: incorrect formula
HCOOH   behavior nor specified: not a molecular formula
B(OH)3  behavior nor specified: not a molecular formula
XYZ     behavior nor specified: nonsense

(Note: this is meant to be an enumeration of all possible inputs that generate true. If I forgot some, I'll add it. In any case, Wikipedia is the answer for questions like "Does substance X exist?", "Is it a gas?")

A related (but different) question: calculate the molar mass

Can we assume that He are Neare noble and so don't combine?

This seems like just take your linked "calculate the molar mass" challenge and add a conditional on the output. How does that make this challenge different enough to not be a duplicate?

'Others - greater values'. What are the others, and those greater values? Maybe I just don't know enough chemisty, but it's not obvious to me why F2O and CH3 and invalid.

@TimmyD This is significantly easier (fewer possibilities; no floating-point), so I think you can make code significantly smaller. And also maybe different approaches are possible with this challenge (dictionary?).

Can I assume that the input will not have parentheses?

@LeakyNun Yes (it's a molecular formula - they don't have parentheses); see test cases for other forms that won't appear

Can I assume that H10 will not appear (two-digit)?

@MorganThrapp Please note that code doesn't need to detect errors. "Behavior not specified" in test cases means "the code can apply some faulty logic and come up with a result". If you don't know any chemistry, you can write an acceptable answer. If you know chemistry then maybe you can write a better answer (though I highly doubt that).

@LeakyNun H10 can appear (updated the list of test cases)

Why is F2O an invalid formula? Oxygen Difluoride (https://en.wikipedia.org/wiki/Oxygen_difluoride) appears to exist...

@TomWill It's in the wrong order - the correct formula is OF2. Doesn't matter much though, because code is not required to detect this.

People who voted to close, please explain what is bad about this question now (what is unclear) and how it could be improved (which parts to clarify)

@anatolyg You wrote "it's a molecular formula - they don't have parentheses". Molecular formulas are sometimes written with parentheses. E.g., B(OH)3, from your OP, is one way of writing the molecular formula for boric acid, since it indicates the molecule consists of boron with three hydroxy (OH) groups attached (see https://en.wikipedia.org/wiki/Boric_acid).  As another example, the molecular formula for dimethylnitrosamine is typically written as (CH3)2NNO, to indicate the presence of two methyl (CH3) groups (see https://en.wikipedia.org/wiki/N-Nitrosodimethylamine).

Perl 5, 52 bytes
51 plus 1 for -p:
$_=/^(B2H6|C2H2|C2?H4|H(CN|F|2O?|e)|N2|NH3|Ne|CO)$/

or
$_=/^(B2H6|C2H2|C2?H4|H(CN|F|2O)|[HN][e2]|NH3|CO)$/

or any of a few similar scripts.
Based (obviously) on MattPutnam's Clojure answer.

Retina, 108 104 bytes
[A-Z]
;$&
Ne
xF
F
xxxO
O
xxN
N
xxC
C
xB
B
11$*x
e
xxx
H
x
x(?=x*(\d+))
$1$*x
[A-Z]
30$*x
[^x]

M`x{29}
0

Try it online!
Test suite.

JavaScript (ES6), 119 bytes
s=>s.replace(/([A-Z][a-z]?)(\d*)/g,(_,a,n)=>m+=[11,12,19,1,4,14,20,16]["B C F H HeN NeO".search(a)/2]*(n||1),m=0)&&m<29

Any unknown atom causes the result to compute to NaN which is not less than 29.

Clojure, 69 bytes
#(#{"H2""He""B2H6""CH4""C2H2""C2H4""HCN""N2""NH3""H2O""CO""HF""Ne"}%)

If that's the full list of truthy answers...

Can you compress it? I see a lot of quote characters there.

Python, 235 Bytes
import re
a={"H":1,"He":4,"B":11,"C":12,"N":14,"O":16,"F":19,"Ne":20}
try:print(str(29>sum([int(p[1])*a[p[0]] for p in [c if c[1]!="" else (c[0],"1") for c in re.findall(r'([A-Z][a-z]*)(\d*)',input())]])).lower())
except:print("false")

Explanation:
import re # For the Regex
a={...} # Defining masses
try... except: # Catches unexpected elements and return false
re.findall(r'([A-Z][a-z]*)(\d*)',input()) # Group capture of the elements (credit to Draxx)
c if c[1]!="" else (c[0],"1") for c in # Sometimes, they may not have numbers after them, thus, if else!
int(p[1])*a[p[0]] # Mass of each elements
str(29>sum(...)).lower() # Boolean whether the statement is true/false translated to lower case string

Or, taking the MattPutnam way of doing things...
Python, 71 Bytes
lambda n:n in"H2 He B2H6 CH4 C2H2 C2H4 HCN N2 NH3 H2O CO HF Ne".split()

(Credit to @Lynn)

lambda n:n in"H2 He B2H6 CH4 C2H2 C2H4 HCN N2 NH3 H2O CO HF Ne".split() might work

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

sort: votes


text:
Approximate the Fransén-Robinson constant
Given an input n, output the value of the Fransén-Robinson constant with n digits after the decimal place, with rounding.
Rules

You may assume that all inputs are integers between 1 and 60.
You may not store any related values - the constant must be calculated, not recalled.
Rounding must be done with the following criteria:

If the digit following the final digit is less than five, the final digit must remain the same.
If the digit following the final digit is greater than or equal to five, the final digit must be incremented by one.

You must only output the first n+1 digits.
Standard loopholes apply.

Test Cases
>>> f(0)
3

>>> f(1)
2.8

>>> f(11)
2.80777024203

>>> f(50)
2.80777024202851936522150118655777293230808592093020

>>> f(59)
2.80777024202851936522150118655777293230808592093019829122005

>>> f(60)
2.807770242028519365221501186557772932308085920930198291220055

What if you do not have support for arbitrary precision floats?

@flawr I suppose that the language would have to use some form of string concatenation or similar. Otherwise, it may not be the language for this challenge.

Too bad, that basically only leaves us with hardcoding the numbers. PS: Why don't you add f(60) to the test cases? That way participants wouldn't have to fetch it externally=)

@flawr Hardcoding is disallowed by rule 2.

Are trailing zeroes ok?

@Mego I would say "no", due to rule 4, but trailing zeroes don't seem like a problem very much, since it's still the same value. They're fine.

Shouldn't f(59) end with a 6, because of rounding?

@NoOneIsHere - only if f(60) was rounded down. If f(61) ended with ....200549, then f(59) rounds down to end with a 5.

@VTCAKAVSMoACE: Has it been two weeks yet? You may be able to see I love to complain.

@NoOneIsHere Oh, whoops, sorry. I haven't been around much recently.

Mathematica, 44 39 36 25 UTF-8 bytes

-5 bytes thanks to Sp3000
-3 bytes thanks to kennytm
-11 bytes thanks to senegrom

Crossed out 44 is still regular 44!!
N[∫1/x!{x,-1,∞},#+1]&

Example:
f=N[∫1/x!{x,-1,∞},#+1]&
f[2]

Outputs 2.81.
Explanation
N[               , # + 1]
  ∫1/x!{x,-1,∞}

First step takes Numeric of the rest, with # (first parameter) + 1 precision. ! (factorial) does what you'd expect. {x, -1, Infinity} sets the bounds for the (strangely formatted) Integral.

I can't test this, so I assume this rounds correctly?

@VTCAKAVSMoACE I checked for n = 60, it rounds correctly. (The 61st digit is an 8). You can look at Wolfram's docs for N.

Coolio. Just checking.

You can probably use a literal ∞ in place of Infinity. I'd suggest dividing by 0, if that didn't produce ComplexInfinity instead...

@Sp3000 How would dividing by 0 save any bytes? (Note: Head[1/0]@1 == Infinity)

@LegionMammal978 It wouldn't have saved any over ∞ even if it did return Infinity, but it'd have been an amusing alternative.

Gamma[x] can be replaced by (x-1)!. And then you could change to x! by integrating in {x,-1,∞}.

I think the integration could be shortened by using the literal ∫ in UTF-8

@senegrom I tried that, but it doesn't work. How do you suggest using it?

try N[∫1/x!{x,-1,∞},#+1]& where  is Unicode-F74C; displays as `` in Mathematica. (note that the space before & is also not necessary...)

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/


text:
Alternating Sign Sequence
Introduction
The sign of a number is either a +, or a - for every non-zero integer. Zero itself is signless (+0 is the same as -0). In the following sequence, we are going to alternate between the positive sign, the zero and the negative sign. The sequence starts with 1, so we write 1 with a positive sign, with zero (this one is weird, but we just multiply the number by 0) and the negative sign:
1, 0, -1

The next number is 2, and we do the same thing again:
2, 0, -2

The sequence eventually is:
1, 0, -1, 2, 0, -2, 3, 0, -3, 4, 0, -4, 5, 0, -5, 6, 0, -6, 7, 0, -7, ...

Or a more readable form:
a(0) = 1
a(1) = 0
a(2) = -1
a(3) = 2
a(4) = 0
a(5) = -2
a(6) = 3
a(7) = 0
a(8) = -3
a(9) = 4
...

The Task
Given a non-negative integer n, output the nth term of the above sequence. You can choose if you use the zero-indexed or one-indexed version.
Test cases:
Zero-indexed:
a(0) = 1
a(11) = -4
a(76) = 0
a(134) = -45
a(296) = -99

Or if you prefer one-indexed:
a(1) = 1
a(12) = -4
a(77) = 0
a(135) = -45
a(297) = -99

This is code-golf, so the submission with the smallest number of bytes wins!

Is it Ok if you start with [0, 0, 0, -1, 0, 1...

@muddyfish no sorry, it has to start with 1.

Jelly, 7 bytes
+6d3’PN

Zero-indexed.
Test cases here.
Explanation:
+6      Add 6:     x+6
d3      Divmod:    [(x+6)/3, (x+6)%3]
’       Decrement: [(x+6)/3-1, (x+6)%3-1]
P       Product    ((x+6)/3-1) * ((x+6)%3-1)

JavaScript ES6, 18 bytes
n=>-~(n/3)*(1-n%3)

Turned out very similar to @LeakyNun's answer but I didn't see his until after I posted mine.
Explanation and Ungolfed
-~ is shorthand for Math.ceil, or rounding up:
n =>               // input in var `n`
    Math.ceil(n/3) // Get every 3rd number 1,1,1,2,2,2, etc.
    *
    (1-n%3)        // 1, 0, -1, 1, 0, -1, ...

function f(n){n=i.value;o.value=-~(n/3)*(1-n%3);}
Input: <input id=i oninput="f()"/>

Output: <input id=o readable/>

(I hereby attest that he did not see my solution before he posted his solution)

Math.ceil and -~ are different; Math.ceil(1) == 1 whereas -~1 == 2

1 byte shorter: n=>~(n/3)*~-(n%3)

MarioLANG, 93 81 bytes
one-indexed
Try It Online
;(-))+(-
"============<
>:(![<:![<:)![
 !=#="!#="!=#=
!  < !-< !- <
#==" #=" #=="

Explanation :
we begin by taking the imput
;

wich give us
          v
... 0 0 input 0 0 ...

we then decrement the left byte and increment the right byte with
;(-))+(
=======

we end up with
           v
... 0 -1 input +1 0 ...

we then set up the loop
;(-))+(-
"============<
>  ![< ![<  ![
   #=" #="  #=
!  < !-< !- <
#==" #=" #=="

the loop will go until the memory look like
         v
... 0 -X 0 +X 0 ...

we then only need to output the result
;(-))+(-
"============<
>:(![<:![<:)![
 !=#="!#="!=#=
!  < !-< !- <
#==" #=" #=="

Nice! You seem to like MarioLang.

@EasterlyIrk The feeling doesn't seem mutual from MarioLang to EtherFrog, though: ;( and >:(. Although, two times [<: could be considered slightly happy. ;P

Python 2, 24 bytes
lambda n:(n/3+1)*(1-n%3)

Full program:
a=lambda n:(n/3+1)*(1-n%3)

print(a(0))   #   1
print(a(11))  #  -4
print(a(76))  #   0
print(a(134)) # -45
print(a(296)) # -99

MATL,  15  12 bytes
3/XkG3X\2-*_

This uses one based indexing.
Try it online! or verify test cases
Explanation:
    G          #Input
     3X\       #Modulus, except multiples of 3 give 3 instead of 0
        2-     #Subtract 2, giving -1, 0 or 1
3/Xk           #Ceiling of input divided by 3.
          *    #Multiply
           _   #Negate

To take care of most of the issues something like Q3/Xk-1:1G_)* may work better. It can probably be modified ever further for 1-based indexing instead.

Haskell, 27 bytes
f x=div(x+3)3*(1-mod(x+3)3)

Slightly more interesting 28 byte solution:
(((\i->[i,0,-i])=<<[1..])!!)

(Both are 0-indexed)

05AB1E, 7 bytes
Code:
(3‰`<*(

Explained:
(           # negate input: 12 -> -12
 3‰         # divmod by 3: [-4, 0]
   `        # flatten array: 0, -4
    <       # decrease the mod-result by 1: -1, -4
     *      # multiply: 4
      (     # negate -4

Bash, 28 25 Bytes
echo $[(1+$1/3)*(1-$1%3)]

@DigitalTrauma, tkx, didn't know this...

MATL, 8 bytes
:t~y_vG)

The result is 1-based.
Try it online!
Explanation
This builds the 2D array
 1  2  3  4  5 ...
 0  0  0  0  0 ...
-1 -2 -3 -4 -5 ...

and then uses linear indexing to extract the desired term. Linear indexing means index down, then across (so in the above array the first entries in linear order are 1, 0, -1, 2, 0, ...)
:     % Vector [1 2 ... N], where N is implicit input
t~    % Duplicate and logical negate: vector of zeros
y_    % Duplicate array below the top and negate: vector [-1 -2 ... -N]
v     % Concatenate all stack contents vertically
G)    % Index with input. Implicit display

Perl 5, 22 bytes
21 plus one for -p:
$_=(-$_,$_+2)[$_%3]/3

Uses 1-based indexing.
Explanation:
-p sets the variable $_ equal to the input. The code then sets it equal to the $_%3th element, divided by 3, of the 0-based list (-$_,$_+2) (where % is modulo). Note that if $_%3 is two, then there is no such element, and the subsequent division by 3 numifies the undefined to 0. -p then prints $_.

Batch (Windows), 86 bytes
Alternate.bat
SET /A r=%1%%3
SET /A d=(%1-r)/3+1
IF %r%==0 ECHO %d%
IF %r%==1 ECHO 0
IF %r%==2 ECHO -%d%

This program is run as Alternate.bat n where n is the number you wish to call the function on.

Pyke, 8 7 bytes (old version)
3.DeRt*

Try it here!
 - Note that link probably won't last for long
3.D      - a,b = divmod(input, 3)
   e     - a = ~a -(a+1)
     t   - b -= 1
      *  - a = a*b
         - implicit output a

Newest version
3.DhRt*_

Try it here!
3.D      - a,b = divmod(input, 3)
   h     - a+=1
     t   - b-=1
      *  - a = a*b
       _ - a = -a
         - implicit output a

Can you provide a link to the (old version)

Latest commit where the old code works here (this is earlier today)

Perl 6,  26  23 bytes
{({|(++$,0,--$)}...*)[$_]}
{($_ div 3+1)*(1-$_%3)}
( The shorter one was translated from other answers )
Explanation (of the first one):
{ # bare block with implicit parameter ｢$_｣
  (

    # start of sequence generator

    { # bare block
      |(  # slip ( so that it flattens into the outer sequence )
        ++$, # incrementing anon state var =>  1, 2, 3, 4, 5, 6
        0,   # 0                           =>  0, 0, 0, 0, 0, 0
        --$  # decrementing anon state var => -1,-2,-3,-4,-5,-6
      )
    }
    ...  # repeat
    *    # indefinitely

    # end of sequence generator

  )[ $_ ] # get the nth one (zero based)
}

Test:
#! /usr/bin/env perl6
use v6.c;
use Test;

# store it lexically
my &alt-seq-sign = {({|(++$,0,--$)}...*)[$_]}
my &short-one = {($_ div 3+1)*(1-$_%3)}

my @tests = (
    0 =>   1,
   11 =>  -4,
   76 =>   0,
  134 => -45,
  296 => -99,
  15..^30  => (6,0,-6,7,0,-7,8,0,-8,9,0,-9,10,0,-10)
);

plan @tests * 2 - 1;

for @tests {
  is alt-seq-sign( .key ), .value, 'alt-seq-sign  ' ~ .gist;

  next if .key ~~ Range; # doesn't support Range as an input
  is short-one(    .key ), .value, 'short-one     ' ~ .gist;
}

1..11
ok 1 - alt-seq-sign  0 => 1
ok 2 - short-one     0 => 1
ok 3 - alt-seq-sign  11 => -4
ok 4 - short-one     11 => -4
ok 5 - alt-seq-sign  76 => 0
ok 6 - short-one     76 => 0
ok 7 - alt-seq-sign  134 => -45
ok 8 - short-one     134 => -45
ok 9 - alt-seq-sign  296 => -99
ok 10 - short-one     296 => -99
ok 11 - alt-seq-sign  15..^30 => (6 0 -6 7 0 -7 8 0 -8 9 0 -9 10 0 -10)

J, 19 15 bytes
>.@(%&3)*1-3|<:

Probably need to golf this further...
1-indexed.
Ungolfed:
>> choose_sign      =: 1-3|<:      NB. 1-((n-1)%3)
>> choose_magnitude =: >.@(%&3)    NB. ceil(n/3)
>> f                =: choose_sign * choose_magnitude
>> f 1 12 77
<< 1 _4 0

Where >> means input (STDIN) and << means output (STDOUT).

J,  27 bytes
Whilst not the golfiest, I like it better, as it uses an agenda.
>.@(>:%3:)*1:`0:`_1:@.(3|])

Here is the tree decomposition of it:
         ┌─ >.
  ┌─ @ ──┤    ┌─ >:
  │      └────┼─ %
  │           └─ 3:
  ├─ *
──┤           ┌─ 1:
  │      ┌────┼─ 0:
  │      │    └─ _1:
  └─ @. ─┤
         │    ┌─ 3
         └────┼─ |
              └─ ]

This is very similar to Kenny's J answer, in that it chooses the magnitude and sign, but it's different in that I use an agenda to choose the sign.

MATL, 8 bytes
_3&\wq*_

This solution uses 1-based indexing into the sequence.
Try it Online
Modified version showing all test cases
Explanation
        % Implicitly grab the input
_       % Negate the input
3&\     % Compute the modulus with 3. The second output is floor(N/3). Because we negated
        % the input, this is the equivalent of ceil(input/3)
w       % Flip the order of the outputs
q       % Subtract 1 from the result of mod to turn [0 1 2] into [-1 0 1]
*       % Take the product with ceil(input/3)
_       % Negate the result so that the sequence goes [N 0 -N] instead of [-N 0 N]
        % Implicitly display the result

Pyth, 10 bytes
*h/Q3-1%Q3

Try it online!
Explanation:
*     : Multiply following two arguments
h/Q3  : 1 + Input/3
-1%Q3 : 1 - Input%3

Note: I've assumed the zero-indexed sequence.

You would probably like to include this link. Also, welcome to PPCG!

I got quite close to your solution... *@(1ZtZ)%Q3h/Q3

@FliiFe (1ZtZ) = -L1 2

Actually, 10 bytes
3@│\u)%1-*

Try it online!
Explanation:
3@│\u)%1-*
3@│         push 3, swap, duplicate entire stack ([n 3 n 3])
   \u)      floor division, increment, move to bottom ([n 3 n//3+1])
      %1-   mod, subtract from 1 ([1-n%3 n//3+1])
         *  multiply ([(1-n%3)*(n//3+1)])

GeoGebra, 44 bytes
Element[Flatten[Sequence[{t,0,-t},t,1,n]],n]

where n is one-indexed.
Explanation:
Element[                      , n] # Return the nth element of the list                  .
 Flatten[                    ]     # Strip all the unnecessary braces from the list     /|\
  Sequence[{t,0,-t}, t, 1, n]      # Generate a list of lists of the form {t, 0, -t}     |
                             # This list will start with {1,0,-1} and end with {n,0,-n}  |

It is not necessary to generate all triplets through {n, 0, -n}, but it's shorter than writing ceil(n/3) or something to that effect.
Note that n must be defined to create this object (if it isn't defined at the time this is run, GeoGebra will prompt you to create a slider for n).

Hi and welcome to PPCG! Do you have a link I can test this (preferably online)?

@EᴀsᴛᴇʀʟʏIʀᴋ, thanks! Here's a link to an online applet thingamabob. The page looked blank for a little while, but then it showed up.

Oh cool. But how where do I put in the formula? >_> I tried pasting it into the blank, and it prompted to create a slider, but nothing else happened.

@EᴀsᴛᴇʀʟʏIʀᴋ: Over on the left-hand side, where it says "Input..." First, to initialise n, enter something like n=297 (this will give you a slider that's configured nicely). Then paste the formula into the Input box, which should now be below the n. (Make sure to hit return ;) The formula should evaluate to the nth term of the sequence, and it should change when you move the slider.

Labyrinth, 17 15 14 bytes
Saved 3 bytes using Sok's idea of using 1-(n%3) instead of ~(n%3-2).
1?:#/)}_3%-{*!

The program terminates with an error (division by zero), but the error message goes to STDERR.
Try it online!
Explanation
The program is completely linear, although some code is executed in reverse at the end.
1     Turn top of stack into 1.
?:    Read input as integer and duplicate.
#     Push stack depth (3).
/)    Divide and increment.
}     Move over to auxiliary stack.
_3%   Take other copy modulo 3.
-     Subtract from 1. This turns 0, 1, 2 into 1, 0, -1, respectively.
{*    Move other value back onto main stack and multiply.
!     Output as integer.

The instruction pointer now hits a dead end and turns around, so it starts to execute the code from the end:
*     Multiply two (implicit) zeros.
{     Pull an (implicit) zero from the auxiliary to the main stack.
-     Subtract two (implicit) zeros from one another.
      Note that these were all effectively no-ops due to the stacks which are
      implicitly filled with zeros.
%     Attempt modulo, which terminates the program due to a division-by-zero error.

Erlang, 40 bytes
F=fun(N)->trunc((N/3+1)*(1-N rem 3))end.

Sadly Erlang has no '%' modulo operator and 'rem' requires the spaces, even before the 3.

Hexagony, 25 bytes
?'+}@/)${':/3$~{3'.%(/'*!

Or, in non-minified format:
    ? ' + }
   @ / ) $ {
  ' : / 3 $ ~
 { 3 ' . % ( /
  ' * ! . . .
   . . . . .
    . . . .

Try  it online!
My first foray into Hexagony, so I'm certain I've not done this anywhere near as efficiently as it could be done...
Calculates -(n%3 - 1) on one memory edge, n/3 + 1 on an adjacent one, then multiplies them together.

Wow, very interesting to see this! :)

R, 28 bytes
-((n=scan())%%3-1)*(n%/%3+1)

Looks like this is a variation of most of the answers here.  Zero based.
   n=scan()                  # get input from STDIN
  (        )%%3-1            # mod by 3 and shift down (0,1,2) -> (-1,0,1)
-(               )           # negate result (1,0,-1), this handles the alternating signs
                  *(n%/%3+1) # integer division of n by 3, add 1, multiply by previous

The nice thing about it is that it handles multiple inputs
> -((n=scan())%%3-1)*(n%/%3+1)
1: 0 3 6 9 1 4 7 10 2 5 8 11
13:
Read 12 items
 [1]  1  2  3  4  0  0  0  0 -1 -2 -3 -4
>

Originally I wanted to do the following, but couldn't trim off the extra bytes.
rbind(I<-1:(n=scan()),0,-I)[n]

Uses rbind to add 0's and negatives to a range of 1 to n then return the n'th term (one based).
# for n = 5
rbind(                    )    # bind rows
            n=scan()           # get input from STDIN and assign to n
      I<-1:(        )          # build range 1 to n and assign to I
                     ,0        # add a row of zeros (expanded automatically)
                       ,-I     # add a row of negatives
                           [n] # return the n'th term

APL, 12 chars
-×/1-0 3⊤6+⎕

0 3⊤ is APL's divmod 3.

Java 7, 38 37 36 bytes
My first golf, be gentle
int a(int i){return(1+i/3)*(1-i%3);}

Try it here! (test cases included)
Edit: I miscounted, and also golfed off one more character by replacing (-i%3+1) with (1-i%3).

Hello, and welcome to PPCG! You can remove the space after return, and use a Java 8 lambda.

I should specify that this was Java 7.  I'll remove that space, though. Thanks!

Octave, 23 bytes
With no mod cons...
@(n)(-[-1:1]'*[1:n])(n)

Uses 1-based indexing magic.

Explanation
Creates an anonymous function that will:
(-[-1:1]'*[1:n])(n)
  [-1:1]              % make a row vector [-1 0 1]
 -      '             % negate and take its transpose making a column vector
          [1:n]       % make a row vector [1..n], where n is the input
         *            % multiply with singleton expansion
               (n)    % use linear indexing to get the nth value

After the multiplication step we'll have a 3xn matrix like so (for n=12):
 1    2    3    4    5    6    7    8    9   10   11   12
 0    0    0    0    0    0    0    0    0    0    0    0
-1   -2   -3   -4   -5   -6   -7   -8   -9  -10  -11  -12

Making n columns is overkill, but it's a convenient number that is guaranteed to be large enough. Linear indexing counts down each column from left to right, so the element at linear index 4 would be 2.
All test cases on ideone.

JavaScript, 22 bytes
r=n%3
o=(1-r)/3*(n-r+3)

n is the number you wish to call the function on. o is the output number.

dc, 10
?2+3~1r-*p

Uses 1-based indexing.
?              # Push input to stack
 2+            # Add 2
   3~          # divmod by 3
     1r-       # subtract remainder from 1
        *      # multiply by quotient
         p     # print

APL, 14 bytes
{⍵⌷∊{⍵0,-⍵}¨⍳⍵}

This is 1-indexed, i.e.:
     {⍵⌷∊{⍵0,-⍵}¨⍳⍵}¨1 2 3 4 5 6 7 8
1 0 ¯1 2 0 ¯2 3 0

Explanation:
{⍵⌷                   select the ⍵th element
   ∊                  from all elements in
    {⍵0,-⍵}           the values ⍵, 0, and -⍵
           ¨⍳⍵}       for each number in 1..⍵

Retina, 45 bytes
.+
11$&$*
(111)+(1)*
$#2$#1
T`d`+0-`^.
^0.+
0

Try it online!
Test suite.
Takes input/output in base-ten. 1-indexed.
Unary input, base-ten output, 1-indexed: 40 bytes
$
11
(111)+(1)*
$#2$#1
T`d`+0-`^.
^0.+
0

Try it online!
Test suite.

Batch, 30 29 bytes
@cmd/cset/a(1+%1/3)*(1-%1%%3)

The cmd/c makes set/a echo the result of the calculation. Edit: Saved 1 byte by removing the unnecessary space.

GNU Coreutils, 27 Bytes
echo "(1+$1/3)*(1-$1%3)"|bc

I count 27 bytes.  But this is even shorter: bc<<<"(1+$1/3)*(1-$1%3)"

@DigitalTrauma, I wrote exactly this answer before, but I am not sure if <<< is POSIX-ly correct, and I want to avoid Bash-ism here, as I have a plain Bash answer here, too.

MATLAB / Octave, 27 bytes
@(n)ceil(n/3)*(mod(-n,3)-1)

This creates an anonymous function that can be called using ans(n). This solution uses 1-based indexing.
All test cases

Mathematica 26 bytes
With 4 bytes saved thanks to Martin Ender.
⎡#/3⎤(-#~Mod~3-1)&

Uses the same approach as Suever.

C#, 34 bytes
n=>n%3==1?0:(n/3+1)*(n%3==0?1:-1);

To assign the lambda to a variable, write:
Func<int,int>f=n=>n%3==1?0:(n/3+1)*(n%3==0?1:-1);

With C# 6, you can also assign the lambda to a method:
int F(int n)=>n%3==1?0:(n/3+1)*(n%3==0?1:-1);

CJam, 11 bytes
ri3+3md(W**

0-based input.
Test it here.
Explanation
ri   e# Read input and convert to integer N.
3+   e# Add 3.
3md  e# Divmod 3, putting N/3+1 and N%3 on the stack.
(W*  e# Decrement, multiply by -1, turning 0, 1, 2 into 1, 0, -1, respectively.
*    e# Multiply.

><>, 16+3 = 19 bytes
:3%:1$-}-3,1+*n;

Needs the input to be present on the stack, so +3 bytes for the -v flag. Try it online!
The program outputs the zero-indexed sequence, using the formula:
f(n) = ((n-(n%3))/3) * (1-(n%3))

Java 7, 36 bytes
int c(int n){return(n/3+1)*(1-n%3);}

Ungolfed & test code:
Try it here.
class Main{

    static int c(int n){
        return (n / 3 + 1) * (1 - n % 3);
    }

    public static void main(String[] a){
        System.out.println(c(0));
        System.out.println(c(11));
        System.out.println(c(76));
        System.out.println(c(134));
        System.out.println(c(296));
    }
}

Zero-indexed output:
1
-4
0
-45
-99

Desmos, 125 86 bytes
b=\operatorname{ceil}\left(\frac{a}{3}\right)
b\operatorname{mod}\left(-a,3\right)-b
a=1

Simple fix for \operatorname{ceil}\left(\frac{a}{3}\right)
125 bytes:
\operatorname{ceil}\left(\frac{a}{3}\right)\operatorname{mod}\left(-a,3\right)-\operatorname{ceil}\left(\frac{a}{3}\right)
a=1

This is as close as I could get to divmod.  Might be able to get rid of subtracting -\operatorname{ceil}\left(\frac{a}{3}\right) to shave some bytes off.

Cubix, 30 bytes
1..-.w>?^I3%?;,)O@...o-'. ? ^
I 3 % ? ; , ) O @ . . .
o - ' .  ? Push literal 1, subtract TOS, change direction and check

For zero value ^ w O @ Redirect up, sidestep left (ends up on another face), output number (zero in this case) and terminate
For positive value ; < ' - o ; ; ; u , ) O @ pop, redirect, push character -, output character, pop, pop, pop, u-turn to left, integer divide TOS, increment TOS, output number and terminate

What happend to the other answer? :)

My apologies for the edit mess up, I thought I had lost the previous post

Oh, it's okay :)

Python 3, 30 25 bytes
I tried to replicate the results of Leaky Nun's Python post for 10 minutes before realising it was for Python 2, not 3.
Zero-indexed:
lambda n:(n//3+1)*(1-n%3)

Full program:
a = lambda n:(n//3+1)*(1-n%3)
print(a(0))   #   1
print(a(11))  #  -4
print(a(76))  #   0
print(a(134)) # -45
print(a(296)) # -99

Hello, and welcome to PPCG!

Thanks for the welcome, @NoOneIsHere. Pleasure to be here!

Java, 19 bytes
Using lambda expressions.
i->(1+i/3)*(1-i%3);

Try it here!

18 bytes

Oasis, 12 bytes (non-competing)
n3÷>n3÷y>n-*

Try it online!
Oasis is a language designed by Adnan which is specialized in sequences.
Currently, this language can do recursion and closed form.
This answer can only demonstrate closed form. For recursion, see for example this answer.
We use this formula: a(n) = (n/3+1)*((n/3*3)+1-n) which is modified from the formula used in my Python answer, since there is no modulo at the moment.
n3÷>n3÷y>n-*

n             push n (input)
 3÷           integer-division by 3
   >          +1
    n         push n (input)
     3÷       integer-division by 3
       y      *3
        >     +1
         n    push n (input)
          -   subtract the top of stack from the second top of stack
           *  multiply the top of stack to the second top of stack

Python 2, 64 bytes
Although Leaky Nun has already posted a much shorter, brilliant Python answer, I decided to see whether this could be done recursively, calculating each new term from the last two. The result was interesting:
f=lambda n,a=1,b=0:(n<1)*`a`or f(n-1,b,[[0,-a][b==0],1-b][a==0])

Try it online!

Lua, 50 bytes
function a(n)print((math.floor(n/3)+1)*(1-n%3))end

Try it online!

VBA Excel , 46 bytes
using immediate window and Range A1 as input
a=[A1]:b=a Mod 3:?IIf(b=0,-a/3,IIf(b=1,a/3,0))

Common Lisp, 73 43 bytes
(lambda(n)(*(1+(floor n 3))(- 1(mod n 3))))

Try it online!

Vyxal, 52 bitsv2, 6.5 bytes
Þn2ẇ0Zfi

Try it Online!
Bitstring:
0010101100100111101111111101010011100010011001000000

Silly vyxal (1 indexed)

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
Longest arithmetic subsequence
Given a non empty finite sequence of integers, return an arithmetic subsequence of maximal length.
If there are multiple of the same maximal length, any of them can be returned.
Definitions:
An arithmetic sequence is a sequence \$a(1),a(2),a(3),a(4),...\$ such that there is a constant \$c\$ such that \$a(m+1)-a(m) = c\$ for all \$m\$. In other words: The difference between two subsequent terms is constant.
Given a sequence \$b(1),b(2),b(3),b(4),...\$ a subsequence is a sequence \$b(s(1)),b(s(2)),b(s(3)),b(s(4)),...\$ where \$1 <= s(1)\$ and \$s(m) < s(m+1)\$ for all \$m\$. In other words: Take the original sequence and remove as many entries as you want.
Examples
Input                     Output
[4,1,2,3,6,5]             [1,3,5] or [1,2,3]
[5,4,2,-1,-2,-4,-4]       [5,2,-1,-4]
[1,2,1,3,1,4,1,5,1]       [1,1,1,1,1] or [1,2,3,4,5]
[1]                       [1]

Some longer test cases:
Length: 25
Input: [-9,0,5,15,-1,4,17,-3,20,13,15,9,0,-6,11,17,17,9,26,11,5,11,3,16,25]
Output: [15,13,11,9] or [17,13,9,5]

Length: 50
Input: [35,7,37,6,6,33,17,33,38,30,38,12,37,49,44,5,19,19,35,30,40,19,11,5,39,11,20,28,12,33,25,8,40,6,15,12,27,5,21,6,6,40,15,31,49,22,35,38,22,33]
Output: [6,6,6,6,6] or [39,33,27,21,15]

Length: 100
Input: [6,69,5,8,53,10,82,82,73,15,66,52,98,65,81,46,44,83,9,14,18,40,84,81,7,40,53,42,66,63,30,44,2,99,17,11,38,20,49,34,96,93,6,74,27,43,55,95,42,99,31,71,67,54,70,67,18,13,100,18,4,57,89,67,20,37,47,99,16,86,65,38,20,43,49,13,59,23,39,59,26,30,62,27,83,99,74,35,59,11,91,88,82,27,60,3,43,32,17,18]
Output: [6,18,30,42,54] or [8,14,20,26,32] or [46,42,38,34,30] or [83,63,43,23,3] or [14,17,20,23,26] or [7,17,27,37,47] or [71,54,37,20,3]

Background
I got this idea when I recalled the Green-Tao-Theorem from 2004, which states that the sequence of primes contains finite arithmetic sequences of arbitrary length.

Jelly, 8 bytes
ŒPIE$ÐfṪ

Try it online! or verify all test cases.
How it works
ŒPIE$ÐfṪ  Main link. Argument: A (list of integers)

ŒP        Powerset; generate all sublists of A, sorted by length.
     Ðf   Filter the powerset by the link to the left:
    $       Combine the two atoms to the left into a monadic link.
  I           Compute all increments.
   E          Test whether they're all equal.
          This returns all arithmetic subsequences, sorted by length.
       Ṫ  Tail; extract the last sequence.

Pyth, 12 11 bytes
ef!P{-VTtTy

Test suite.
          y  powerset of implicit input, generate all subsequences
ef       T   find the last subsequence (sorted increasing in length) where...
       Tt      bifurcate over tail, giving [1,2,3,4,5] [2,3,4,5]
     -V        vectorize over -, giving differences of each consecutive pair
    {          dedup (remove duplicate elements)
   P           pop, resulting in [] if all differences were equal
  !            boolean not, resulting in True if all differences were equal

Thanks to @LeakyNun for a byte!

MATL, 19 18 17 16 18 bytes
1 byte saved (and 2  bytes added back) thanks to Luis!
"GX@XN!"@dun2<?vx@

A fairly naive approach which brute force checks all ordered permutations of the input. Obviously this can take a while for longer sequences. To save a byte, I have started with the smallest sub-sequences (length = 1) and worked up to the larger sequences (length = N).
Try it Online!
Explanation
                % Impilicitly grab input array (N)
"               % For each value in this array
    G           % Explicitly grab the input
    X@          % Loop index, will be [1, 2, ... length(N)] as we iterate
    XN          % Determine all permutations of k elements (nchoosek). The output is
                % each k-length permutation of the input as a different row. Order doesn't
                % matter so the result is always ordered the same as the input
    !           % Take the transpose so each k-length permutation is a column
    "           % For each column
        d       % Compute the difference between successive elements
        un      % Determine the number of unique differences
        2<?     % If there are fewer than 2 unique values
            vx  % Vertically concatenate everything on the stack so far and delete it
            @   % Push the current permuatation to the stack
                % Implicit end of if statement
                % Implicit end of for loop
                % Implicit end of for loop
                % Implicitly display the stack

@LuisMendo Thanks! I always wondered how to get the loop iteration #.

@LuisMendo Oh good catch, you're right. That double diff gives an empty array which can't be negated.

Husk, 6 bytes
►oEẊ-Ṗ

Try it online!
Explanation
The return value of E is useful here for getting the longest list that satisfies a condition.
►oEẊ-Ṗ   Implicit argument: a list.
     Ṗ   List of all its subsequences.
►        Find one that maximizes:
 o        Composition of two functions:
   Ẋ       1. Apply to adjacent elements:
    -         Subtraction.
  E        2. Are all elements equal?
              Returns length+1 if they are, 0 if not.

Python 2, 124 115 98 97 bytes
p=[[]]
for n in input():p+=[x+[n][:2>len(x)or n-x[-1]==x[1]-x[0]]for x in p]
print max(p,key=len)

Very slow and memory intensive. Test it on Ideone.
Alternate version, 98 bytes
p={()}
for n in input():p|={x+(n,)[:2>len(x)or n-x[-1]==x[1]-x[0]]for x in p}
print max(p,key=len)

This completes all test cases instantly. Test it on Ideone.

byte or speed, that is the question

Pyth checkout 8593c76, March 24th, 10 bytes
efq-VTtT)y

This is exactly the same as Doorknob's answer, except that back in march, there was a 2 byte function (q ... )) which checked whether all of the elements of a list were the same, which is the same as !P{, which is the best you can do currently.

JavaScript (ES6), 157 bytes
a=>{for(m=i=0,l=a.length;i<l;i++)for(j=i;++j<l;)for(t=n=a[k=i],c=0;k<l;k++)a[k]==t&&(t+=a[j]-n,++c>m)?q=a[m=c,p=n,j]-n:q;return a.slice(-m).map(_=>(p+=q)-q)}

Almost 20 times longer than the Jelly answer... Ungolfed:
function subsequence(a) {
    var max = 0;
    for (var i = 0; i < a.length; i++) {
        for (var j = i + 1; j < a.length; j++) {
            var target = a[i];
            var count = 0;
            for (var k = i; k < a.length; k++) {
                if (a[k] == target) {
                    count++;
                    target += a[j] - a[i];
                    if (count > max) {
                        max = count;
                        start = a[i];
                        step = a[j] - a[i];
                    }
                }
            }
        }
    }
    var result = new Array(max);
    for (var i = 0; i < max; i++) {
        result[i] = start + step * i;
    }
    return result;
}

Japt -h, 13 bytes
à ñÊkÈän än d

Try it

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
My "keybore" is key-boring me! Help me find a minimal keystrokes
Credits to @Agawa001 for coming up with this question.
Explanation
My new "keybore" only has 2 buttons, namely + and -.
The number in the memory starts at 0.
Each consecutive press of + or - will increment/decrement the memory for exactly how many times it has been pressed consecutively.
Therefore, if you press + 4 times, first time it adds 1, the second time it adds 2, the third time it adds 3, the fourth time it adds 4, giving you 10 (ten).
Now, if you press - 3 times, the first time it subtracts 1, the second time 2, the third time 3, leaving you with 4 (four).
TL;DR
Given a string of + and -, divide it at each change of character. Then each resulting string of m + symbols adds the m-th triangle number, and each string of n - symbols subtracts the n-th triangle number.
Walk-through
Now, if you still do not understand, I will show you how +++--+-- creates 1.
Program   | Counter | Memory
----------------------------
          |  0      | 0
+         | +1      | 1
++        | +2      | 3
+++       | +3      | 6
+++-      | -1      | 5
+++--     | -2      | 3
+++--+    | +1      | 4
+++--+-   | -1      | 3
+++--+--  | -2      | 1

Task

You will take a positive integer as input, either as functional argument or from STDIN.
Then, you will output/print the minimum number of keystrokes needed to create that number using the method above.

Testcases
Since rearranging the + or - runs gives the same number, for each such group only the lexicographically earliest sequence is listed.
Input | Output | Possible corresponding sequences
-------------------------------------------------
    4 |      5 | -+++-
    6 |      3 | +++
    9 |      5 | ++++-
   11 |      7 | +++-+++
   12 |      7 | +++++--, ++++-++
   19 |      8 | -++++++-
   39 |     12 | +++++++++---
   40 |     13 | +++++++++---+, ++++++++-+++-
   45 |      9 | +++++++++
   97 |     20 | ++++++++++++++--+---, +++++++++++++-++++--, ++++++++++++-++++++-
  361 |     34 | ++++++++++++++++++++++++++-+++-+++

Extra resources

Proof that any number can be made: basically, by repeating ++-, you can obtain any even number. To obtain the odd numbers, just put a + at the end.
Another general way to obtain any number. For example, to generate 50, a way is to press + 50 times, and then press - 49 times.
Solution of the first 50 numbers.
Obligatory JSFiddle.

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

Does that mean... you are keybored?

I think you're OK with 10 test cases now (including mine).

@ΈρικΚωνσταντόπουλος The 12 test case has been added, with a slight modification (since +++++-- is also an alternative, but I removed ++-++++ since that's equivalent to ++++-++). I've still got one more case I'd like to add later in case anyone comes up with an efficient solution, if I manage generate it.

@Sp3000 I did not want ++-++++ removed. Also, this was MY edit, not YOURS.

@ΈρικΚωνσταντόπουλος Only 1 solution from each set of equivalent solutions is listed - I thought that if all the minimal solutions were listed, the test cases would be unnecessarily long (there's 6 solutions for 40 and 17 solutions for 97). I do apologise if that intention was not clear. Also you were missing +++++-- (or, equivalently, --+++++), which is why I felt the need to edit in the first place.

@Sp3000 Then, why 97 has 3 solutions visible?

@ΈρικΚωνσταντόπουλος The other 14 solutions are just one of those three solutions with the + or - groups rearranged.

Correction: There's actually 20, not 17 (miscounted), but they're still all rearrangements of those three types.

I am surprised this resisted a straightforward solution until now...

@Sp3000 I mean, 3 are visible on 97, while the others have 1 or 2.

s=>s.replace(/([-+])\1*/g,t=>r+=(l=t.length)*++l/2*(t<'-'||-1),r=0)&&r, so if anyone posts that as a challenge, I have a 70 byte solution in JavaScript (ES6).

@ΈρικΚωνσταντόπουλος Do you get that, if you rearrange the +/- runs as long as they still alternate between + and -, you always get another valid solution? e.g. ++++++++-+++-, -++++++++-+++, +++-++++++++- and -+++-++++++++ are all equivalent solutions for 40 because they all correspond to 36+6-1-1, but +++++++++---+ is different (45+1-6). 97 has 3 solutions listed because that's how many groups of equivalent solutions there are (and also why that test case is there), while others have 1 or 2 because that's how many groups of equivalent solutions they have.

I would like to post a non-inefficient solution, but it will be large in size. How about a bonus to reduce the size? :D

better simpler proof that any number can be made: "+"*n+"-"*(n-1) yields n

MATL, 43 29 bytes
E:"@TFEqZ^!"@Y'tQ**s]vGE=a?@.

This is memory- and time-inefficient. The online compiler can handle up to input 45 only.
Try it online!
Here's a modified version with all test cases up to 40 (it takes almost a minute in the online compiler).
Explanation
This tests all possible key-press sequences of each length, in order of increasing length, until a valid sequence is found.
E:       % Range [1 2 ... 2*N] where N is implicit input. The required sequence length is
         % less than 2*N, so this is enough
"        % For each
  @      %   Push current value: length of sequence
  TFEq   %   Push array [1 -1]
  Z^     %   Cartesian power. Gives all possible sequences of 1, -1 of that length
  !      %   Transpose. Each sequence is now a row
  "      %   For each sequence
    @    %     Push current sequence
    Y'   %     Run-length decoding: Pushes an array of values 1 and -1, and then an
         %     array of run-lengths
    tQ*  %     Duplicate, add 1, multiply. Gives twice the triangular number for each run
    *    %     Multiply element-wise by 1 or -1 to produce correct sign
    s    %     Sum of array. This is the number produced by the current sequence
  ]      %   End for
  v      %   Concatenate all numbers into an array
  GE=a   %   True if any of those numbers equals twice the input
  ?      %   If so
    @    %     Push current sequence length. This is the final result
    .    %     Break loop
         %   End if
         % End for
         % Implicit display

@Sp3000 I've added one too, so, for reference, 4, 6, 9 and 19 are the test cases referred to, in order.

Python 2, 119 bytes
def g(n,i=0,s=''):
 c=x=t=0
 for d in s:C=int(d)*2-1;t=(c==C)*t+1;c=C;x+=c*t
 return(x==n)*len(s)or g(n,i+1,bin(i)[3:])

Very slow brute-force approach. The third line computes the score of a string x; the other lines loop over all possible binary strings until one whose score equals the argument is found.
@Leaky saved three bytes!

s/x==n and len/(x==n)*len/

It might save some bytes to get rid of s and just use repeated division, like this: def f(n): \n while n>0:print n%2;n/=2

Pyth, 25 bytes
ffqyQ.as-Mc*RhdY2{s.pM./T

Try it online.
This is extremely inefficient, and runs out of memory for f(n) ≥ 11. It calculates f(22) = 10 in about 10 seconds on my laptop.
Explanation

Starting from 1, loop through numbers T. (f)

Generate all partitions of T. (./T)
Generate all permutations of those. (.pM)
Flatten the list. (s)
Uniquify the list. ({) This step could be removed, but it makes the  code much faster.
Filter the resulting permutations of partitions: (f)

Multiply each number d of the partition (*R) by itself plus one (hd). This gives double the number to add/subtract to the result.
Chop the list to parts of length 2. (c…2)
Subtract any second number in those parts from the second number. (-M)
Sum the results. This gives double the resulting number if the partition permutation was interpreted as number of additions, then subtractions, etc.
Take the absolute value. (.a) If the result was negative, swapping the additions and subtractions gets the positive result.
Check if the result equals double the input. (qyQ) In this case the partition permutation is correct, return it.

If the filter returned any results, there was a solution of length T. Return and print T.

Python, 105 100 bytes
Uses an inefficient breadth-first search.
def k(n):
 m=t=l=0;h=[]
 while m-n:o=1-2*(t>0);(m,t,l),*h=h+[(m+t-o,t-o,l+1),(m+o,o,l+1)]
 return l

h is a list used as a queue
m is the value of the sequence at the head of the list
t is the last number added to m
l is the length of the sequence that generated m
o is +/-1, the sign is opposite the sign of t

Edit: Leaky Nun shaved five bytes.

s/m,t,l,h=0,0,0,[]/m=t=l=0,h=[]/

s/while m!=n/while m-n/