text:
plz send teh codez!

Note to Moderators and editors:
  This post's title is for effect and should not be changed. The misspelling is intentional and part of the challenge.

Backstory
The (stereo)typical bad SO question asks something along the lines of "plz send teh codez!" In other words, it asks someone to do the work for the asker and provide a complete solution to a one-time problem. I quote this question on Meta.SE:

...its about a specific category of questions which consist of absolutely no research, no effort, and simply ask for the complete solution to a problem. These types of questions generally tend to assume that Stack Overflow is a free coding service...

So what is your actual challenge? Its simple:
Your program or function, etc. must take input as a string (from STDIN, parameter, etc.) and if the string contains Plz send teh codez! output -1 flag comment (downvote, flag as off-topic, and comment about how bad a question it is.) Otherwise output +1 (you are upvoting).
But wait… there's more!
Your program must not contain 5 or more of these character sets:

All special characters (anything not a space, newline (0x0a), case-insensitive alphabet, or digit)
Any digit (0-9)
Any of pzcm (case-insensitive)
Any of hten (case-insensitive)
Any of qwryuioasdfgjklxvb
Any of QWRYUIOASDFGJKLXVB

To be clear, you can only use up to 4 of those charsets.
Spaces, tabs and newlines are not restricted in any way, but they still are included in your byte count
Final restriction
Your program must contain Unicode ONLY in the range of 0x20 (space) to 0x7e (~), as well as 0x0a (LF newline) and 0x09 (tab). This is to exclude code golfing languages and give traditional languages a change or at least level the playing field.
Notes:

This is code-golf, the shortest answer in bytes wins!
Input can be from STDIN, a function parameter, command-line parameter, etc. but not a variable.
Output can be to STDOUT, a function return value, or even an error/exception. Can include a trailing newline.
Traditional languages are encouraged to compete because this challenge bans a lot of golfing languages by excluding high Unicode characters. C might even have a chance of winning!
Any questions? Comment below!

If it's too hard…
You can ignore the character sets in your answer, but it then becomes non-competitive.
NOTE: You can now use up to 4 character sets. You're welcome.
You can use this snippet to check if your code is valid:

let f = code => {
  let sets = Array(6).fill(false);
  code = code.replace(/\s/g, "");
  code = code.replace(/\d/g, _ => (sets[0] = true, ""));
  code = code.replace(/[pzcm]/gi, _ => (sets[1] = true, ""));
  code = code.replace(/[hten]/gi, _ => (sets[2] = true, ""));
  code = code.replace(/[qwryuioasdfgjklxvb]/g, _ => (sets[3] = true, ""));
  code = code.replace(/[QWRYUIOASDFGJKLXVB]/g, _ => (sets[4] = true, ""));
  if (code) sets[5] = true;
  return sets.reduce((a, b) => a + b, 0);
}
<textarea oninput="var x=f(value);O.innerHTML='You\'re using '+x+' charset'+(x===1?'':'s')+(x>4?', which is too many.':'. Nice job!')"></textarea>

CJam, 50 49 48 bytes
q"Plz send teh codez!"#)"- flag comment""+"?(T)@

Doesn't use digits or the capital letters set.
Try it online!
Explanation
q                       e# Push the input
"Plz send teh codez!"#  e# Find index of "Plz send teh codez!" in the input (-1 if not found)
)                       e# Increment the index
                        e# Check the truthiness of the index:
 "- flag comment"       e#   If truthy (i.e. it appeared in the input), push this string
 "+"                    e#   If falsy (it wasn't in the input), push this string
?                       e#
(                       e# Uncons from left, removes the first character of the string and
                        e#  pushes it on the stack
T)                      e# Push 0, and increment it to 1
@                       e# Bring third-from-top stack element to the top
                        e# Implicit output of stack contents

JavaScript (ES6), 60 bytes
x=>/Plz send teh codez!/.test(x)?~x+' flag comment':'+'+-~[]

Everything was straightforward, except avoiding using 1 anywhere. I use ~x to get -1 (since if x contains Plz send teh codez!, it's not a valid number and therefore ~x will give -1), and -~[] to get 1 (since if x is e.g. '7', -~x will be 8, so we can't rely on x).
Test snippet

let f =
x=>/Plz send teh codez!/.test(x)?~x+' flag comment':'+'+-~[];

console.log(f("Hello, Plz send teh codez!"))
console.log(f("Hello, Plz send teh codez?"))

Nice abuse of JSFuck logic!

JS (JSFuck), 37959 bytes
Here's a gist, since PPCG hates long codes.
Only uses special characters. :P
Heres the original code:
alert(prompt().includes("Plz send teh codez!")?"-1 flag comment":"+1")

You didn't capitalize the P. ;)

@darryleo It is supposed to be.

The P in Plz send teh codez!, I mean.

Oh wait now z is wrong. facepalm

C, 102 bytes
i;f(char*s){i=strstr(s,"Plz send teh codez!");printf("%+d%s",i?'a'-'b':'b'-'a',i?" flag comment":"");}

Doesn't use any digit or any of QWERTYUIOASDFGHJKLXVBN. Try it online!

Retina, 56 bytes
(?!.*Plz send teh codez).+

.+
-$#+ flag comment
^$
+$#+

Try it online!
Uses special characters, the two case insensitive letter sets and other lower-case letters.
First we remove the entire input if it doesn't contain Plz send teh codez. If there is any input left we replace it with -1 flag comment, avoiding the digit with $#+. $+ refers to the last capturing group which is $0 (the entire match) sind there are no capturing groups. $#+ then gives the number of captures, which is always 1.
Finally, if the string is still empty (i.e. we cleared it in the first stage), we replace it with +1 (again using $#+ for the 1).

Python 2/3, 81 76 68 bytes
lambda x:["+%s","-%s flag comment"]["Plz send teh codez!"in x]%+True

Uses:

All special characters (anything not a space, newline (0x0a), case-insensitive alphabet, or digit)
Any of pzcm (case-insensitive)
Any of hten (case-insensitive)
Any of qwryuioasdfgjklxvb

Doesn't use:

Any of QWRYUIOASDFGJKLXVB
Any digit (0-9)

-8 bytes thanks to math_junkie

Save 4 bytes with an array lookup: TIO

Save 4 more by using + instead of int: TIO

@math_junkie Great ideas!

Python 2, 95 94 87 Bytes
Uses special characters and all lowercase lowers (plus three char sets and except for "p", which is case insensitive) for a total of four characters sets used.
b=ord('b')-ord('a')
print["+"+`b`,`-b`+" flag comment"][input()=="Plz send teh codez!"]

Try it online! Thanks to @math_junkie for saving 8 bytes! Thanks to @officialaimm for saving two bytes!

a=ord

Let a be the ord() built-in function.
b=str(a('b')-a('a'))

This is really b=1.
print["+"+b, "-"+b+" flag comment"][input()=="Plz send teh codez!"]

If the statement in the second pair of brackets is true, print the second string in the first pair of brackets. Otherwise, print the first one.

You can save 5 bytes by avoiding str, and you by removing the space after print: repl

@math_junkie That creates the error of concatenating an integer with a string

See the link in my above comment

you can save 2 bytes by removing a=ord and actually using ord... seems like its saving, but its not... I had the same :D

You can save two more with a lambda: lambda n,b=ord('b')-ord('a'):["+"+`b`,`-b`+" flag comment"][n=="Plz send teh codez!"]

Also, I think you need to check whether the input string contains "Plz send teh codez!". "Plz send teh codez!"in n is a quick fix for one extra byte

Groovy, 78 bytes
{a="a".length();it.contains("Plz send teh codez!")?-a+" flag comment":"+"+a}

Doesn't use the numbers or the uppercase sets.
Just a straightforward use of the ternary operator. "a".length() is a workaround to get 1

Python 3, 115 bytes
if"p".upper()+"lz send teh codez!"in input():print("-"+str(len('a'))+" flag comment")
else:print("+"+str(len('a')))

It doesn't use numbers or upper case letters.
Try it online

You can remove several spaces, like between if "p", codez!" in, etc.

Assigning str(len('a')) to a variable can save you a few more. Splicing the number into the strings directly rather than calling str might also be advantageous.

C#, 77 bytes
x=>x.Contains("Plz send teh codes!")?$"{'x'-'y'} flag comment":$"+{'x'/'x'}";

Not being able to use digits is such a pain.

Pip, 48 bytes
s.a@?"Plz send teh codez!"?v." flag comment"'+.o

Tied with CJam.
I am very mad that I was unable to get this under 48 bytes.
The program uses Pip's predefined variables to get around the number sequence, and it doesn't have any characters from the Capitals sequence.
Try it online!

Swift (non-competitive) - 64 bytes
print(x.contains("Plz send teh codez!") ?"-1 flag comment":"+1")

Unfortunately used 5 charsets, couldn't make it without them... Suggestions are welcome!

Python 3.5 (137 102 98 87 85 94 Bytes)
Uses small-case letters(3 charsets) + special characters(1 charset) = 4 charsets
i was almost planning to avoid whitespaces as well but the indentation in python forced me to keep one newline so i left the whitespaces as they were.
i=str(ord('b')-ord('a'))
print(['+'+i,'-'+i+' flag comment']['Plz send teh codez!'in input()])

Try it online!

saved 35 bytes!!!!: apparently i had forgotten the existence of upper() function before(silly me!!)
saved 4 bytes: reduced i=input() to just input()
saved 11 bytes!!!: Thanks to Anthony-Pham (used 'P' since it is valid in charset)
saved 2 bytes: (removed a=ord; learnt that shortening a function is not always a good idea! :D)
added 9 bytes: Thanks to math-junkie for pointing out that I was not displaying +1 for strings with no 'Plz send teh codez!' before.

Well since you are already using p (and it's defined as case-insensitive), you don't need the .upper()

You need to output +1 for input that does not contain Plz send teh codez!

Thanks for pointing out that, I was unaware of that till now... :D

Common Lisp, 81 bytes
Special + lower case + 2 mixed-case = 4 charsets
(format t"~:[+~s~;-~s flag comment~]"(search"Plz send teh codez!"(read-line))(*))

Ungolfed
(format t "~:[+~s~;-~s flag comment~]"
        (search "Plz send teh codez!" (read-line))
        (*))

Explanation
(read-line)
Accepts a line of input from *standard-input* (STDIN, by default).
(search "Plz send teh codez!" ...)
Scans through the second argument (the read in line) for the index where the first argument starts. Returns either this index or nil (false) if it could not be found.
(*)
Multiplication in lisp is defined to take an arbitrary number of arguments, including none- in that case it always returns 1.
(format t "~:[+~s~;-~s flag comment~]" ...)
#'format is similar to fprintf or sprintf in C. It's first argument, t, designates the output as *standard-output* (STDOUT, by default). The next argument is the format string. "~" is used like "%" in printf- the character(s) following it designate a formatting operation.
"~:[~;~]" is the conditional formatting operation. It takes an argument and continues with  if the argument was nil (false). Any other value, like t (true) or a number (for example), has it continue with . The third argument to format (the first, after t and the format string) is the search, so  will be chosen if the search fails (and  otherwise).
In this case, the  (nil/false) branch prints "+~s". "~s" converts a format argument to a string and prints out its characters. The fourth argument to format (the second, after t and the format string) is (*) or 1, so we get "+1" printed.
The  branch is similar: "-~s flag comment". It also uses the fourth (second) argument to fill in its "~s", so it prints out "-1 flag comment".

sh + sed, 72 bytes
Uses character sets: 1, 3, 4, 5.
let ""
sed "s/.*Plz send teh codez!.*/-$? flag comment/
tz
s/.*/+$?/
:z"

At first, I wanted to go with pure sed, but I had no idea how to avoid using digits. So I used sh just for that. let "" has an exit status of 1, since it can't be evaluated as an arithmetic expression.
z is just a label and can be replaced with any other character.

Mathematica, 265 bytes
This was hard.
t[s_,n_]:=ToString@s~StringTake~{n};If[StringFreeQ[#,t[Head[a^b],i=-I I]<>"l"<>(s=t[RSolve[f[a+i]==f@a-i/Sqrt@a,f@a,a],(i+i+i+i)^(e=i+i+i)+i+e])<>" send teh "<>(k=t[i/Sin@x,e])<>"ode"<>s<>"!"],"+"<>t[i,i],"-"<>t[i,i]<>" flag "<>k<>"o"<>(n=Head[a b]~t~e)<>n<>"ent"]&

Readable version:
t[s_, n_] := ToString@s~StringTake~{n};
If[StringFreeQ[#,
   t[Head[a^b], i = -I I] <>
    "l" <> (s =
      t[RSolve[f[a + i] == f@a - i/Sqrt@a, f@a,
        a], (i + i + i + i)^(e = i + i + i) + i + e]) <>
    " send teh " <> (k = t[i/Sin@x, e]) <> "ode" <> s <> "!"],
  "+" <> t[i, i],
  "-" <> t[i, i] <> " flag " <> k <> "o" <> (n = Head[a b]~t~e) <> n <>
    "ent"] &

Uses special characters, hten, qwryuioasdfgjklxvb and QWRYUIOASDFGJKLXVB. Mathematica without special characters would be basically impossible, and almost all string-related functions include String in their name, so that really limits the choice here…
To get the other character sets, we need a few tricks. Firstly, to get 1 we take the negative of the square of the imaginary number I: i = -I I. Later we also define 3 by e = i+i+i.
The letter P was fairly straightforward: Mathematica treats a^b internally as Power[a,b], so all we need to do is take the head of this (Power), turn it into a string, and take the first (aka ith) letter. (We'll be turning things into strings and taking the nth letter a lot, so we define t[s_,n_]:=ToString@s~StringTake~{n}.) The letter m is similar: take the head of a b, which is Times, and get the third (aka eth) letter.
The letter c is slightly harder: we use the trigonometric identity 1/Sin[x] == Csc[x] (or rather i/Sin[x] since we can't use 1), and take the third letter of Csc[x].
The really hard part is the z. To make a z, we use the HurwitzZeta function (yes, really). We get that by solving the recurrence relation RSolve[f[a + i] == f@a - i/Sqrt@a, f@a, a], which yields the string
"                             1            1
 {{f[a] -> C[1] + HurwitzZeta[-, a] - Zeta[-]}}
                              2            2"

of which the 68th character is z. We get the number 68 as 4^3 + 4.
This could probably be golfed further: the Hurwitz zeta stuff is pretty much copied from the Mathematica documentation, and there's probably a shorter way of getting 68 — or we could use another method entirely for the z. Any suggestions?


text:
Draw me the (weird) unit circle!
Introduction
You may know and love your normal unit circle. But mathematicans are crazy and thus they have abstracted the concept to any point that satisfies x*x+y*y=1. Because Cryptographers1 are also weird, they love finite fields and sometimes finite rings (it is not like they have much choice though), so let's combine this!
The Challenge
Input
A positive integer larger than one in your favorite encoding. Let's call this number n.
Output
You will output the "picture" (which consists of n times n characters) of the unit circle modulo the input integer as ASCII-Art using "X" (upper-case latin X) and " " (a space). Trailing spaces and newlines are allowed.
More Details
You have to span a coordinate system from bottom-left to top-right. Whenever a point fulfills the circle equation, place an X at the position, otherwise place a space.
The condition for a point to be considered part of the circle border is:
mod(x*x+y*y,n)==1.
Here a quick illustration of the coordinate-system:
(0,4)(1,4)(2,4)(3,4)(4,4)
(0,3)(1,3)(2,3)(3,3)(4,3)
(0,2)(1,2)(2,2)(3,2)(4,2)
(0,1)(1,1)(2,1)(3,1)(4,1)
(0,0)(1,0)(2,0)(3,0)(4,0)

If it helps you, you may also invert the direction of any of the axes, but the examples assume this orientation.
Who wins?
This is code-golf so the shortest code in byte wins! Only the default I/O methods are allowed and all standard loopholes are banned.
Examples
Input: 2
X
 X

Input: 3
X
X
 XX

Input: 5
X

X
 X  X

Input: 7
X
  X  X

  X  X
X
 X    X

Input: 11
X

     XX

   X    X
   X    X

     XX

X
 X        X

Input: 42
X
         X                       X

            X                 X
       X                           X
      X                             X
                     X
  X             X         X             X

     X             X   X             X
X
               X           X
              X             X
         X                       X

            X                 X
                     X
        X           X X           X
                     X
            X                 X

         X                       X
              X             X
               X           X
X
     X             X   X             X

  X             X         X             X
                     X
      X                             X
       X                           X
            X                 X

         X                       X
X
 X           X               X           X

1 I suggest you take a look at my profile if you're wondering here.

Looks much better if you use the domain [0,n] in my opinion. Here is an example with input 42.

By "standard I/O" do you mean default I/O methods, or do you mean actual STDIN/STDOUT? I'm assuming the former, but I think someone below has interpreted it as the latter.

@ØrjanJohansen indeed the former.

Are preceding newlines allowed?

@fergusq as they would (drastically) alter the output figure in a visible way, no.

Bash + GNU Utilities, 59
x={0..$[$1-1]}d*
eval echo $x$x+$1%1-0r^56*32+P|dc|fold -$1

Input n given as a command-line parameter.  The y-axis is inverted.
Try it online.

Octave, 45 44 bytes
@(n)[(mod((x=(0:n-1).^2)+x',n)==1)*56+32,'']

Try it online!

This also works: @(n)[(mod((x=(0:n-1).^2)+x',n)==1)*88,'']. In certain systems Octave treats character 0 as a space

Mathematica, 56 48 bytes
Edit: Thanks to Greg Martin and Martin Ender for saving 8 bytes.
Grid@Array[If[Mod[#^2+#2^2,x]==1,X]&,{x=#,#},0]&

Original solution:
Grid@Table[If[Tr[{i-1,j-1}^2]~Mod~#==1,X,],{i,#},{j,#}]&

Amusing remark: you don't need the comma after X :)

I think you're better off with Array and Norm: Grid@Array[If[Mod[Norm@{##}^2,x]==1,X]&,{x=#,#},0]&

Still overthinking it... #^2+#2^2 is shortest.

@GregMartin So if the first argument to If is neither True or False, you need the fourth argument or it remains unevaluated, but If[False,_] returns Null. Weird.

@MartinEnder I initially tried Array but didn't think to set the argument to a variable.

Haskell, 68 bytes
f n|r<-[0..n-1]=unlines[[last$' ':['X'|mod(x*x+y*y)n==1]|y<-r]|x<-r]

Try it online! The y-axis is flipped. Usage: f 42 returns a newline delimited string.
This is a nested list comprehension where both x and y are drawn from the range [0..n-1]. last$' ':['X'|mod(x*x+y*y)n==1] is a shorter form of if mod(x*x+y*y)n==1 then 'X' else ' '. The list comprehension evaluates to a list of strings which is turned into a single newline separated string by unlines.

CJam, 23 bytes
ri:X,2f#_ff{+X%(S'X?}N*

Try it online!
ri:X    e# Read input, convert to integer, store in X.
,       e# Turn into range [0 1 ... X-1].
2f#     e# Square each value in the range.
_ff{    e# 2D map over all pairs from that list.
  +     e#   Add the two values in the current pair.
  X%    e#   Take the sum modulo X.
  (     e#   Decrement, so that x^2+y^2==1 becomes 0 (falsy) and everything
        e#   else becomes truthy.
  S'X?  e#   Select space of 'X' accordingly.
}
N*      e# Join rows with linefeeds.

JavaScript (ES6), 81 bytes

f=
n=>[...Array(n)].map((_,x,a)=>a.map((_,y)=>(x*x+y*y)%n-1?` `:`X`).join``).join`
`
<input type=number oninput=o.textContent=f(+this.value)><pre id=o>

The Y-axis is the reverse of the OP.

Röda, 74 bytes
f n{seq n-1,0|{|y|seq 0,n-1|{|x|["X"]if[(x^2+y^2)%n=1]else[" "]}_;["
"]}_}

Try it online!
Ungolfed:
function f(n) {
    seq(n-1, 0) | for y do
        seq(0, n-1) | for x do
            if [ (x^2 + y^2) % n = 1 ] do
                push("X")
            else
                push(" ")
            done
        done
        print("")
    done
}

Python 3, 87 83 bytes
lambda n:"\n".join("".join(" X"[(y*y+x*x)%n==1]for x in range(n))for y in range(n))

Try it online!
The y-axis is inverted

Jelly, 14 13 bytes
R²+þ`%=1ị⁾X Y

The x-axis is inverted.
Try it online!
How it works
R²+þ`%=1ị⁾X Y  Main link. Argument: n

R              Range; yield [1, ..., n].
 ²             Square; yield [1², ..., n²].
  +þ`          Self table addition; compute x+y for all x and y in [1², ..., n²],
               grouping by the values of y.
     %         Take all sums modulo n.
      =1       Compare them with 1, yielding 1 or 0.
        ị⁾X    Index into "X ".
            Y  Separate by linefeeds.

Lithp, 125 bytes
#N::((join(map(seq(- N 1)0)(scope #Y::((join(map(seq 0(- N 1))(scope #X::
((?(== 1(@(+(* X X)(* Y Y))N))"X" " "))))""))))"\n")

Linebreak for readability.
Try it online!
Not the shortest. I think I need some sort of shorthand module. See the Try it Online link for further explanation, ungolfed version, and some tests. For best results, expand the output window to see more.

Python 3, 82 bytes
f=lambda n,k=0:k<n>f(n,k+1)!=print(''.join(' X'[(k*k+j*j)%n==1]for j in range(n)))

Try it online!

GNU APL, 41 chars, 59 bytes
Reads an integer and displays the circle.
N←⎕◊⌽{(⍵+1)⊃' ' 'X'}¨{1=(N|(+/⍵*2))}¨⍳N N

Ungolfed
N←⎕
⌽                           ⍝ flip the X axis so 0,0 is bottom left
{
    (⍵+1) ⊃ ' ' 'X'         ⍝ substitute space for 0, X for 1
} ¨ {
    1=(N|(+/⍵*2))           ⍝ mod(x*x+y*y, 1)==1
} ¨ ⍳N N                    ⍝ generate an NxN grid of coordinates

dc, 79 bytes
?dsRsQ[88P]sl[32P]sH[0sM[lM2^lR2^+lQ%d1=l1!=HlM1+dsMlQ>c]dscx10PlR1-dsR0<S]dsSx

The y-axis is inverted whereas the x-axis is not.
Try it online!

Python 3, (102 98 95 bytes)
y-axis inverted
n=int(input());r=range(n);p=print
for i in r:
 for j in r:p(end=' 'if(i*i+j*j)%n-1else'X')
 p()

Try it online!

saved 4 bytes: omitted variable c in c=' 'if(ii+jj)%n-1else'X'
saved 3 bytes: Thanks to  ovs (modified print statement)

p(end=' 'if(i*i+j*j)%n-1else'X') for 95 bytes

MATL, 13 bytes
:qU&+G\1=88*c

Origin is at top left. So the output is flipped upside down compared with the examples in the challenge.
Try at MATL online!
Explanation
:      % Input n implicitly. Push [1 2 ... n]
q      % Subtract one (element-wise)
U      % Square (element-wise)
&+     % Matrix of pairwise sums
G      % Push n
\      % Modulo
1=     % Equal to 1? (element-wise)
88*    % Multiply by 88 (ASCII code of 'X')
c      % Convert to char. Char 0 will be displayed as a space
       % Display implicitly

Haskell, 115 bytes
n#(a,b)|mod(a*a+b*b)n==1='X'|1>0=' '
m n=map(n#)<$>zipWith(zipWith(,))(replicate n[0..n-1])(replicate n<$>[0..n-1])

The y axis is inverted.
Try it online!
All those parentheses are kind of annoying me...
Explanation
n#(a,b)|mod(a*a+b*b)n==1='X'|1>0=' '
n#(a,b)                                 --Operator #, takes a number n and a tuple (a,b)
       |mod(a*a+b*b)n==1                --Test if the mod equals 1
                        ='X'            --If so, return 'X'
                            |1>0=' '    --Otherwise, return ' '

m n=map(n#)<$>zipWith(zipWith(,))(replicate n[0..n-1])(replicate n<$>[0..n-1])
m n=                                                                           --Make a new function m with argument n
                                 (replicate n[0..n-1])                         --Make a list of [[0,1,2,3..n-1],[0,1,2,3..n-1],(n times)]
                                                      (replicate n<$>[0..n-1]) --Make a list of [[0,0,0(n times)],[1,1,1(n times)]..[n-1,n-1,n-1(n times)]
              zipWith(zipWith(,))                                              --Combine them into a list of list of tuples
    map(n#)<$>                                                                 --Apply the # operator to every tuple in the list with the argument n

You can replace the last map with a <$>, right?

Unless I'm misinterpreting the question rules, I don't think you need all that I/O - golfing I/O on PPCG has special defaults to allow as many languages as possible to participate. For example, your main function can take an integer argument and return a string.

@k_g yes thank you

@ØrjanJohansen duly noted :)

J, 20 bytes
' x'{~1=[|+/~@:*:@i.

Try it online!

GolfScript, 34 bytes
~:c,{.*}%:a{:b;a{b+c%1=' x'=}%}%n*

Try it online!
I really don't like using variables...

source: Stack Exchange

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

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

sort: votes


text:
I give you Nth permutation, you give me N
Input: a sequence of uppercase letters (ASCII [65;90]) which is the Nth* lexicographical permutation of the multiset of its characters
*permutations are numbered from 0 or 1 upwards
Output: base-10 integer N

Rulez

There might be duplicates (that's how this challenge differs from
this one)
The characters are ordered by their ASCII value
In case of an input of length less than or equal to 1, the input is the
first permutation and the result is 0 or 1 respectively
First permutation is that in which the leftmost character has the lowest
value, the rightmost character has the highest value, and the sequence
of characters between the first and the last character is the first
permutation of the multiset of its characters (recursive definition!)
Shortest entry wins

Example

Input AAB produces output 0
Input ABA produces output 1
Input BAA produces output 2

Input ZZZ produces output 0
Input DCBA produces output 23

EDIT
Extra kudos to the one who can come up with a solution which doesn't produce all permutations and then search for the input. That's some challenge.

Hello and welcome to the site.  This question is currently rather unclear.  I am not really sure how the permutations are ordered.  Are they lexicographically ordered? This should be defined in your question.

We also have a sandbox so you can get this kind of feedback before posting to our main site.  It is not mandatory to post there first, but a lot of times it is very helpful.

You said 'Uppercase', zzz and dcba is not uppercase.

@SIGSEGV corrected

Can the output index be 1-based instead of 0-based?

Well... let's see what you have.

Uhm, Is that a yes?

Yep. It's a yes.

if you decide to account for the case when the input is empty, the output has to be 0 I think this should be removed. Answers can always claim they don't support empty input. Same for You can support other characters than ASCII uppercase letters

I agree in case of empty input, but other characters than uppercase letters would still have well-defined expected output. What I mean is that you don't have to support it, but you don't have to make an effort to treat such input as an error. If they claim they don't support it, then they just don't support it. Rules don't disallow that.

But you say Input: a sequence of uppercase letters. So, considering what would happen for other characters is pointless

Right, I didn't realize that. Other letters than uppercase removed.

Jelly, 5 bytes
Œ!QṢi

Try it online!
1-indexed output.

@downvoter This post is perfectly valid.

Python, 302 287 bytes
Dead Possum has already posted a short Pythonic solution, so I decided to go for the extra kudos. This solution does not generate all of the permutations. It can rapidly calculate the permutation index of a rather large string; it also handles an empty string correctly.
from math import factorial as f
from itertools import groupby as g
def p(t,b=''):
 if len(t)<2:return 0
 z,b=0,b or sorted(t)
 for i,c in enumerate(b):
  w=b[:i]+b[i+1:]
  if c==t[0]:return z+p(t[1:],w)
  if i<1 or c!=b[i-1]:
   n=f(len(w))
   for _,v in g(w):n//=f(len(list(v)))
   z+=n

Testing code:
def lexico_permute_string(s):
    ''' Generate all permutations of `s` in lexicographic order '''
    a = sorted(s)
    n = len(a) - 1
    while True:
        yield ''.join(a)
        for j in range(n-1, -1, -1):
            if a[j] < a[j + 1]:
                break
        else:
            return
        v = a[j]
        for k in range(n, j, -1):
            if v < a[k]:
                break
        a[j], a[k] = a[k], a[j]
        a[j+1:] = a[j+1:][::-1]

def test_all(base):
    for i, s in enumerate(lexico_permute_string(base)):
        rank = p(s)
        assert rank == i, (i, s, rank)
        print('{:2} {} {:2}'.format(i, s, rank))
    print(repr(base), 'ok\n')

for base in ('AAB', 'abbbbc'):
    test_all(base)

def test(s):
    print('{!r}\n{}\n'.format(s, p(s)))

for s in ('ZZZ', 'DCBA', 'a quick brown fox jumps over the lazy dog'):
    test(s)

output
 0 AAB  0
 1 ABA  1
 2 BAA  2
'AAB' ok

 0 abbbbc  0
 1 abbbcb  1
 2 abbcbb  2
 3 abcbbb  3
 4 acbbbb  4
 5 babbbc  5
 6 babbcb  6
 7 babcbb  7
 8 bacbbb  8
 9 bbabbc  9
10 bbabcb 10
11 bbacbb 11
12 bbbabc 12
13 bbbacb 13
14 bbbbac 14
15 bbbbca 15
16 bbbcab 16
17 bbbcba 17
18 bbcabb 18
19 bbcbab 19
20 bbcbba 20
21 bcabbb 21
22 bcbabb 22
23 bcbbab 23
24 bcbbba 24
25 cabbbb 25
26 cbabbb 26
27 cbbabb 27
28 cbbbab 28
29 cbbbba 29
'abbbbc' ok

'ZZZ'
0

'DCBA'
23

'a quick brown fox jumps over the lazy dog'
436629906477779191275460617121351796379337

Non-golfed version:
''' Determine the rank (lexicographic index) of a permutation
    The permutation may contain repeated items

    Written by PM 2Ring 2017.04.03
'''

from math import factorial as fac
from itertools import groupby

def lexico_permute_string(s):
    ''' Generate all permutations of `s` in lexicographic order '''
    a = sorted(s)
    n = len(a) - 1
    while True:
        yield ''.join(a)
        for j in range(n-1, -1, -1):
            if a[j] < a[j + 1]:
                break
        else:
            return
        v = a[j]
        for k in range(n, j, -1):
            if v < a[k]:
                break
        a[j], a[k] = a[k], a[j]
        a[j+1:] = a[j+1:][::-1]

def perm_count(s):
    ''' Count the total number of permutations of sorted sequence `s` '''
    n = fac(len(s))
    for _, g in groupby(s):
        n //= fac(sum(1 for u in g))
    return n

def perm_rank(target, base):
    ''' Determine the permutation rank of string `target`
        given the rank zero permutation string `base`,
        i.e., the chars in `base` are in lexicographic order.
    '''
    if len(target) < 2:
        return 0
    total = 0
    head, newtarget = target[0], target[1:]
    for i, c in enumerate(base):
        newbase = base[:i] + base[i+1:]
        if c == head:
            return total + perm_rank(newtarget, newbase)
        elif i and c == base[i-1]:
            continue
        total += perm_count(newbase)

base = 'abcccdde'
print('total number', perm_count(base))

for i, s in enumerate(lexico_permute_string(base)):
    rank = perm_rank(s, base)
    assert rank == i, (i, s, rank)
    #print('{:2} {} {:2}'.format(i, s, rank))
print('ok')

About lexico_permute_string
This algorithm, due to Narayana Pandita, is from
https://en.wikipedia.org/wiki/Permutation#Generation_in_lexicographic_order
To produce the next permutation in lexicographic order of sequence a

Find the largest index j such that a[j] < a[j + 1]. If no such index exists,
the permutation is the last permutation.
Find the largest index k greater than j such that a[j] < a[k].
Swap the value of a[j] with that of a[k].
Reverse the sequence from a[j + 1] up to and including the final element a[n].

FWIW, you can see an annotated version of that function here.

FWIW, here's the inverse function.
def perm_unrank(rank, base, head=''):
    ''' Determine the permutation with given rank of the
        rank zero permutation string `base`.
    '''
    if len(base) < 2:
        return head + ''.join(base)

    total = 0
    for i, c in enumerate(base):
        if i < 1 or c != base[i-1]:
            newbase = base[:i] + base[i+1:]
            newtotal = total + perm_count(newbase)
            if newtotal > rank:
                return perm_unrank(rank - total, newbase, head + c)
            total = newtotal
# Test

target = 'a quick brown fox jumps over the lazy dog'
base = ''.join(sorted(target))
rank = perm_rank(target, base)
print(target)
print(base)
print(rank)
print(perm_unrank(rank, base))

output
a quick brown fox jumps over the lazy dog
        aabcdeefghijklmnoooopqrrstuuvwxyz
436629906477779191275460617121351796379337
a quick brown fox jumps over the lazy dog

And here's a function that I wrote while developing perm_unrank which shows the breakdown of the subcounts.
def counts(base):
    for i, c in enumerate(base):
        newbase = base[:i] + base[i+1:]
        if newbase and (i < 1 or c != base[i-1]):
            yield c, perm_count(newbase)
            for h, k in counts(newbase):
                yield c + h, k

def show_counts(base):
    TAB = ' ' * 4
    for s, t in counts(base):
        d = len(s) - 1
        print('{}{} {}'.format(TAB * d, s, t))

# Test
base = 'abccc'
print('total number', perm_count(base))
show_counts(base)

output
a 4
    ab 1
        abc 1
            abcc 1
    ac 3
        acb 1
            acbc 1
        acc 2
            accb 1
            accc 1
b 4
    ba 1
        bac 1
            bacc 1
    bc 3
        bca 1
            bcac 1
        bcc 2
            bcca 1
            bccc 1
c 12
    ca 3
        cab 1
            cabc 1
        cac 2
            cacb 1
            cacc 1
    cb 3
        cba 1
            cbac 1
        cbc 2
            cbca 1
            cbcc 1
    cc 6
        cca 2
            ccab 1
            ccac 1
        ccb 2
            ccba 1
            ccbc 1
        ccc 2
            ccca 1
            cccb 1

Wow! Amazing solution! There are some bits of Python here I'm not familiar with that I'm going to have to go look up now to fully understand it. Well done!

You can change it to z=0 and substitute in t[0] and t[1:] where they're used (currently h and t) to save 8 bytes.

Congratulations, you get the extra kudos as well! Even though Jörg Hülsermann was first, but your version is recursive so it's not the same as his.

Thanks, @kyrill Now I'm wondering how to do the reverse process efficiently: produce the permutation from its index. I guess it shouldn't be too hard to modify the usual factorial-base technique used for permutations without repeats...

@DavidConrad Thanks! And thanks for the suggestion; why didn't I see that. :)  I made a few more optimizations before I saw your 2nd comment, but I didn't have a chance to post them earlier.

@kyrill I've added code that produces the permutation from its rank. I suspect that this could be done a little more efficiently, but this code's fast enough for me. ;)

@DavidConrad You may be interested in my latest additions.

That's fantastic, I love it. Excellent work!

It should be shorter to define the factorial function yourself, instead of importing it :)

@ArBo I guess it is, if I define it recursively, but I just couldn't bring myself to do that. ;)

Here's the shortest I could come up with. It returns True for values of 1 or lower, but I think with your code that should be all right?
f=lambda n:n<2or n*f(n-1)

@ArBo Sure, that works.

@PM2Ring Could you make a function that takes permutation and base and return rank of permutation according to number of symbols that have used? For example I want rank of 3749832414 but only its rank in permutations that have used 8 symbols of 10 symbols of the base. I've asked a question about it https://math.stackexchange.com/questions/4346937/index-of-a-permutation-that-has-repetition?noredirect=1#comment9072818_4346937

@PM2Ring So perm_rank(perm_number ex:3749832414, base_symbols ex:[0,1,2,3,4,5,6,7,8,9], used_symbols ex:8)

Python 2, 69 bytes
Try it online
from itertools import*
lambda S:sorted(set(permutations(S))).index(S)

MATL, 13 12 11 bytes
1 byte saved thanks to G B!
tY@Xu=!Af1)

Output is 1-based.
Try it online! Or verify all test cases.
Explanation
t      % Input string implicitly. Duplicate
Y@     % All permutations, sorted; each in a different row
Xu     % Unique rows
=      % Compare for equality, with broadcast
!      % Transpose
A      % All: true for columns that contain all entries true
f      % Find: indices of nonzero elements
1)     % Get first of those indices. Implicitly display

Now you'll just remove the q right?

@kyrill Exactly :-)

And what about the S? Do you really need to sort it before the permutation?

@GB Good point, it's not needed! I forgot that the "all permutations" function sorts based on values, not on indices. Thanks!

Julia, 121 125 bytes
Noncompeting, as it does not deal with duplicate letters correctly. I ported this from another language, from part of a solution to a Project Euler problem I did several years ago, and the first, 121-byte version had a bug because I had transposed the use of the permuted string and the sorted, canonical reference string.
f(p)=(n=0;z=length(p)-1;s=join(sort(collect(p)));for c in p z-=(n+=factorial(z)*(search(s, c)-1);p=replace(s,c,"",1);1)end;n)

For large inputs, this version uses bignums at the cost of 8 extra bytes:
f(p)=(n=0;z=BigInt(length(p)-1);s=join(sort(collect(p)));for c in p z-=(n+=factorial(z)*(search(s, c)-1);p=replace(s,c,"",1);1)end;n)

Ungolfed:
function f(perm)
    nth = 0
    size = length(perm) - 1
    sorted = join(sort(collect(p)))
    for ch in sorted
        index = search(perm, ch) - 1
        nth += factorial(size) * index
        perm = replace(perm, ch, "" , 1) # replace at most one copy
        size -= 1
    end
    return nth
end

Uses a factoriadic number system, q.v. Thus, it does not produce all the permutations and for large inputs will run enormously faster than those that do.
For example, the alphabet can be permuted into the rather contrived sentence "Quartz glyph job vex'd cwm finks." That sentence is the 259,985,607,122,410,643,097,474,123rd lexicographic permutation of the letters of the alphabet. (Approximately 260 septillionth permutation.) This program finds that in about 65 µs on my machine.
julia> @time f("quartzglyphjobvexdcwmfinks")
  0.000065 seconds (570 allocations: 19.234 KB)
259985607122410643097474122

Note that the number ends in ...122 rather than ...123 because OP requested that the permutations be numbered from 0 rather than from 1.
Julia, 375 bytes
I've left the indentation in for readability, but the byte count is without it.
p(t,b="")=begin
    l=length
    if l(t)<2 return 0 end
    f=factorial
    g(w)=(a=[];
        while w!=""
            s=""
            for c in w if c==w[1] s="$s$c" end end
            w=replace(w,s,"")
            push!(a,s)
        end;a)
    b=b>""?b:join(sort(collect(t)))
    z=0
    for(i,c) in enumerate(b)
        w=b[1:i-1]*b[i+1:end]
        if c==t[1] return z+p(t[2:end],w)
        elseif i>1&&c==b[i-1] continue end
        n=f(l(w))
        for v in g(w) n=div(n,f(l(v))) end
        z+=n
    end
    z
end

This one is just a straight Julia port of PM 2Ring's brilliant Python solution. I got hungry, so I decided I wanted the cookie after all. It's interesting to see the similarities and the differences between the two languages. I implemented itertools.groupby (in a limited form) as g(w).
But the logic isn't mine, so go and upvote PM 2Ring's answer.
Replace f=factorial with f(x)=factorial(BigInt(x)) if you want to be able to handle large inputs like p("QUARTZGLYPHJOBVEXDCWMFINKS").

Excellent. You get the cookie! Just fix variable names in the ungolfed version.

Actually I want my cookie back. Your program returns wrong result for BAA ‒ expected 2, actual 3.

@kyrill Ah, it seems I misunderstood the duplicates. In that case, I'm not sure I can see a way to do it that would avoid producing all permutations.

FWIW, my answer does a similar thing, but for input strings with repeated chars.

05AB1E, 5 bytes
œêJ¹k

Uses the CP-1252 encoding. Try it online!

05AB1E, 5 bytes
œê¹Sk

Try it online!
Independently discovered from Adnan's answer.

He beat you by 42 seconds :D

@kyrill Although you still accepted the wrong answer, I beat him with my Jelly answer by 5 minutes.

But that Jelly produces 1-indexed output. Rules state the permutations are numbered from 0 upwards. I gave an exception to Luis Mendo who explicitly asked for it.

@kyrill You have agreed that 1-indexed output is acceptable though.

All right, I will change the task description.

Yeah, giving exceptions to certain users is frowned upon.

PHP, 124 Bytes
$a=str_split($argn);sort($a);for($i=$j=join($a);$i<=strrev($j);$i++)$i==$argn?print+$n:(($c=count_chars)($i)!=$c($j)?:$n++);

PHP, 136 Bytes
foreach($t=($c=count_chars)($argn)as$k=>$v)$i=$s.=str_repeat(chr($k),$v);for(;$i<=strrev($s);$i++)$i==$argn?print+$n:($c($i)!=$t?:$n++);

Online Version
Run with
echo '<string>' | php -nR ''

Calculate with factorial
Expanded Version
function f($i){return array_product(range(1,$i));} #factorial
function p($s){
return f(strlen($s))/array_product(array_map("f",count_chars($s,1)));
} # factorial / divide through product of factorials for each char
$a=$argn;
$b="";
$r=[];
for($d=0;$a;$d++) # loop range before used chars in string
{
    for($i=0;$i<strlen($a);$i++){ # loop for every char in the rest string
        if($a[$i]<$a[0]) # if char is before first char order by ascii
        $r[$d.$a[$i]]=p(substr_replace($a,"",$i,1)); # add range before
    }
    $a=substr($a,1); # remove first char
}
echo array_sum($r); # Output the range before the used permutation

Output for the string PPCG
Array
(
    [0C] => 3    # in first run C is before P startposition = 3
    [0G] => 3    # in first run G is before P startposition = 3+3
    [1C] => 2    # in second run PC is before PP startposition = 3+3+2
    [1G] => 2    # in second run PG is before PP startposition = 3+3+2+2=8
)

Online Version

What kind of magic is this? You have bonus points for original approach, but you still produce all permutations and then search for input.

@kyrill PHP can increment strings http://php.net/manual/en/language.operators.increment.php The logic does not search for input. It is more a comparision to the input

@kyrill for 5 byte more I could replace print+$n´ with ´die("$n")´ and the loop will stop after the permutation is found. And I must add $n=0` in the loop then the cast to integer works not in this change

That's not really worth it, you would still iterate over many combinations like AAQ etc.

@kyrill I have add a Version to calculate the sum of permutations before

Congratulations! The added version indeed does not generate permutations. You win the special prize ;-)

I don't read PHP, but I think your expanded algorithm is fairly similar to mine. FWIW, I didn't notice that until after I'd written my answer.

@PM2Ring It could been I could not read really your python version

JavaScript (ES6), 130 bytes
s=>(o=new Set,p=(s,q)=>s.map((t,i)=>p(t=[...s],q.concat(t.splice(i,1))))[0]||o.add(q.join``))([...s],[])&&[...o].sort().indexOf(s)

Less golfed
s=>{
  o = new Set; // use a set to avoid duplicates

  // recursive function to build all permutations (no cookie for me)
  p = (s, q) =>
  {
    y = s.map( (t,i) => // execute for each char at position i
          (
             t = [...s], // using t as local variable, store a copy of s
             x = t.splice(i,1), // remove char from t in position i, and store in array x
             p(t, q.concat(x)) // recursive call
          ));
    if (!y[0]) // if s was empty, I have a new permutation in q
      o.add( q.join('')) // convert to string and add to output set
  }
  // call p to enumerate all permutations
  p( [...s], [] ) // convert string s to array, q starts empty

  o = [...o].sort() // get elements of o and sort lexicographically
  return o.indexOf(s) // return the position of the input in o
}

Test

F=
s=>(o=new Set,p=(s,q)=>s.map((t,i)=>p(t=[...s],q.concat(t.splice(i,1))))[0]||o.add(q.join``))([...s],[])&&[...o].sort().indexOf(s)

function update() {
  O.textContent = F(I.value)
}

update()
<input id=I value='DCBA' oninput='update()'>

Well, you don't get a cookie, but you get extra credit for implementing your own function to generate permutations ;-)

Mathematica, 33 31 bytes
Changing the problem spec allowed for a 2-byte savings.
Permutations@Sort@#~Position~#&

Pure function taking a list as input and returning a nonnegative integer N in the form {{N}}.

You can drop the -1.

@MartinEnder Originally there was a requirement that the permutations be indexed from 0.

@kyrill Yes, but you removed it, so Greg can save those two bytes.

Scala, 40 bytes
s=>s.permutations.toSeq.sorted indexOf s

To use it, assign this function to a variable:
val f:(String=>Int)=s=>s.permutations.toSeq.sorted indexOf s
println(f("BAA"))

Try it online at ideone
Unfortunately, permutations returns an iterator, which doesn't have a sorted method, so it has to be converted to a Seq

CJam, 7 bytes
q_e!\a#

Try it online!

Pyth, 5 bytes
xS{.p

Online interpreter
Takes quoted input.

@LeakyNun It doesn't work.

@LeakyNun Input 'BAA' must return 2 since it's zero-indexed, but it returns 4 instead.

C++, 96 bytes
We can make full use of the standard library here.  The list of letters is passed as start/end iterators in standard C++ style.
#include<algorithm>
int f(char*a,char*z){int i=0;while(std::prev_permutation(a,z))++i;return i;}

We don't need to generate all permutations - since we have a transformation from one permutation to its predecessor, we simply count how many iterations it takes to reach the zeroth value.
Test program:
#include<cstring>
#include<iostream>
int main(int argc, char **argv)
{
    while (*++argv)
        std::cout << *argv << ": "
                  << f(*argv, *argv+std::strlen(*argv)) << std::endl;
}

Test results:
BAA: 0
BAA: 1
BAA: 2
ZZZ: 0
DCBA: 23
: 0

That's an original approach. Extra kudos to you too!

Ruby, 50 bytes
I expected this to be shorter. I wouldn't have added the sort if the docs didn't say "the implementation makes no guarantees about the order in which the permutations are yielded."
->x{x.chars.permutation.map{|v|v*""}.sort.index x}

Japt, 6 bytes
0-indexed
ñ á bU

Try it

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

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


text:
April Fools Day!
Your challenge is simple: write a program or function which appears to print the first ten numbers of any integer sequence (on OEIS, the answerer may choose which sequence), but instead prints the exact text:
Happy April Fool's Day!

if and only if it is run on April 1st of any year. Run on any other day should make it output its original output. (Unfortunately, I was a little late posting this challenge). Answers should be voted up for clever hiding of the April fools part.
This is a popularity-contest, so the answer with the most votes on May 8th wins!

I really liked this challenge until I got to this part if and only if it is run on April 1st of any year. Run on any other day should make it output its original output. Can I take an input for currentDate or something?

Hiding code within other code makes this an underhanded challenge, and these are no longer welcome on the site. Moreover, "most creative" popularity contests lack an objective winning criterion and have fallen out of favor.

This challenge is [tag:underhanded], and such challenges are no longer on-topic.

@EriktheOutgolfer Huh? It looks more like a [tag:decision-problem] to me.

@SIGSEGV Also a [tag:decision-problem], and not [tag:kolmogorov-complexity], but challenges that ask for answers which appear to do something else than what they really do are [tag:underhanded].

@EriktheOutgolfer No, It's just one answer which does things the 'underhanded' way.

Underhanded challenges are off-topic per community consensus.

Any ideas on how I can rewrite this question to be on-topic? Maybe make it a code-golf?

TI-Basic (TI-84 Plus CE)
{1001,10,1}→LA
{1010,1,1}→LA
{1011,11,1}→LB
{1020,2,1}→LC
{1021,12,1}→LD
{1030,3,1}→LE
{1040,4,1}→LF
{1050,5,1}→LG
{1060,6,1}→LH
{1070,7,1}→LI

getDate→L1

IF L1(2)=LA(2) and L1(3)=LA(3):Then
"Happy October First!"
End
IF L1(2)=LB(2) and L1(3)=LB(3):Then
"Happy New Year!"
End
IF L1(2)=LC(2) and L1(3)=LC(3):Then
"Happy November First!"
End
IF L1(2)=LD(2) and L1(3)=LD(3):Then
"Happy February First!"
End
IF L1(2)=LE(2) and L1(3)=LE(3):Then
"Happy December First!"
End
IF L1(2)=LF(2) and L1(3)=LF(3):Then
"Happy March First!"
End
IF L1(2)=LG(2) and L1(3)=LG(3):Then
Disp "Happy April Fool's Day!"
Return:End
IF L1(2)=LH(2) and L1(3)=LH(3):Then
"Happy May First!"
End
IF L1(2)=LI(2) and L1(3)=LI(3):Then
"Happy June First!"
End
IF L1(2)=LJ(2) and L1(3)=LJ(3):Then
"Happy July First!"
End

ClrHome
Output(1,1,toString(10000LA(1)+100LA(2)+LA(3)))
Output(2,1,toString(10000LB(1)+100LB(2)+LB(3)))
Output(3,1,toString(10000LC(1)+100LC(2)+LC(3)))
Output(4,1,toString(10000LD(1)+100LD(2)+LD(3)))
Output(5,1,toString(10000LE(1)+100LE(2)+LE(3)))
Output(6,1,toString(10000LF(1)+100LF(2)+LF(3)))
Output(7,1,toString(10000LG(1)+100LG(2)+LG(3)))
Output(8,1,toString(10000LH(1)+100LH(2)+LH(3)))
Output(9,1,toString(10000LI(1)+100LI(2)+LI(3)))
Output(10,1,toString(10000LJ(1)+100LJ(2)+LJ(3)))

Uses OEIS A210884.
Stores the numbers as dates and converts them on-the-fly to output. It even leaves you a message in Ans if today is one of the dates!

Nice one! You only display April fools and use other ones as a way to hide the sequence, right?

@SIGSEGV Yes, at first I was going to use Goto and have the label many many blank lines after the last Output to hide it, but that seemed a bit too obvious.

Well, I think I did corrupt too much on getting the month. See mine.

You can omit ) or } at the end of a line or before →, if TI didn't decide to scrap that feature from the TI-84+CE. You can also remove the small L from the variable being stored when assigning a value to a list.

C
I use some fun CLANG properties to do tricky math and print the text sneakishly. I am printing the sequence of even numbers 0,2,4,6 etc up to 42.
This is a nice solution because I don't use any letters or hard coded strings, just pure math trickery to end up outputting the desired text even though it appears to a human brain that this should just be outputting 0,2,4,6,etc
Try it online! (Just the sneaky April Fools Day version)
#define printNumber(x) printf("%c", x)

main() {

    SYSTEMTIME st;
    GetLocalTime(&st);
    BOOL isFunDay = (st.wDay == 4 && st.wDay == 1);

    if (isFunDay) {
        printEvenNumbersTheFunWay();//fun way for a fun day!
    } else {
        printSomeEvenNumbersTheBoringWay();
    }

}

printEvenNumbersTheFunWay() {

    //print sequence: 0,2,4,6,8,10,12,14...42

    //print 0
    #define zero 72-72
    printNumber(2*zero+0);

    //print 2
    #define zero 5-5
    printNumber(20*zero+2);

    //print 4
    #define zero 108-108
    printNumber(2*zero+4);

    //print 6
    #define zero 106-106
    printNumber(2*zero+6);

    //print 8
    #define zero 113-113
    printNumber(2*zero+8);

    //print 10
    #define zero 22-22
    printNumber(2*zero+10);

    //print 12
    #define zero 53-53
    printNumber(2*zero+12);

    //print 14
    #define zero 98-98
    printNumber(2*zero+14);

    //print 16
    #define zero 98-98
    printNumber(2*zero+16);

    //print 18
    #define zero 87-87
    printNumber(2*zero+18);

    //print 20
    #define zero 88-88
    printNumber(2*zero+20);

    //print 22
    #define zero 10-10
    printNumber(2*zero+22);

    //print 24
    #define zero 46-46
    printNumber(2*zero+24);

    //print 26
    #define zero 85-85
    printNumber(2*zero+26);

    //print 28
    #define zero 83-83
    printNumber(2*zero+28);

    //print 30
    #define zero 78-78
    printNumber(2*zero+30);

    //print 32
    #define zero 7-7
    printNumber(2*zero+32);

    //print 34
    #define zero 81-81
    printNumber(2*zero+34);

    //print 36
    #define zero 2-2
    printNumber(-1*zero+36);

    //print 38
    #define zero 30-30
    printNumber(2*zero+38);

    //print 40
    #define zero 57-57
    printNumber(2*zero+40);

    //print 42
    #define zero 79-79
    printNumber(2*zero+42);

    //print 44
    #define zero 1-1
    printNumber(-10*zero+44);

}

printSomeEvenNumbersTheBoringWay() {

    //print sequence: 0,2,4,6,8,10,12,14...42

    int i = 0;
    while (i <= 42) {
        printf("%i, ", i);
        i+=2;
    }

}

Isn't this just the same answer as your deleted one?

My deleted one used a BOOL for detecting date which was not valid for this competition so I posted this valid submission which actually checks system-time

JS, A000027

d=new Date();
if(d.getMonth()+("")[(![]+"")[+[]]+"ontcol"+(!![]+[]["fi"+(![]+"")[!+[]+!+[]]+"l"])[10]+"r"]()[11]+("")["fon"+(!![]+"")[0]+"color"]()[11]+!+[]+!+[]*!+[]+!+[]&&d.getDate()==+!+[])alert("Happy April Fool's Day!");
else{for(i=0;i<10;)alert(++i);}

Mmm, good mixture of JS and JSF*ck. (Fun fact: The majority of the code is used to represent ==.)
Good tip for corrupting code like mine: JS to JSFuck Conversion code/list

Python 2, A000027
import datetime as a
if(str(a.date.today())[5:]=='04-01'):print("Happy April Fool's Day!")
else:
 for i in range(10):print(i+1)

Try it online!


text:
Robbers - square times square root
Task: Crack the scrambled code for multiplying the square root of an integer n by the square of it!
You must post a comment in the cops' thread with a link to your working source, mentioning clearly that you have Cracked it. In your answer's title, you must include the link to the original answer.
Rules:

You may only change the order of the characters in the original source.
Safe answers cannot be cracked anymore.
The other rules mentioned in the cops' thread
Please edit the answer you crack

WINNER: Emigna - 10 submissons (had some trouble counting)
Honorable mentions: Notjagan, Plannapus, TEHTMI

NO, 41 bytes, This Guy
NOOOOOO?NOOOOOOOOOOO!nnOOOOO
NOOOOOOOO?no

Really? Well at least I got my language known.

@ThisGuy: You've made some fun languages :) Not terribly useful in general though ;)

Look at the 2nd paragraph

JavaScript (ES7), Neil
_26_=>_26_**6.25**.5

The hard part, of course, was figuring out what to do with all the extra characters.  (And also not posting this solution in the wrong thread, like I accidentally did at first.  Oopsie...)

@SethWhite: I had to use all the characters that Neil used in his scrambled code, otherwise this wouldn't have been a valid crack.

How does this work?

@Arjun _26_=> defines an anonymous function taking one parameter called _26_ (variables may start with an underscore but not a number). Then the remainder is just using ** as Math.pow() to raise the input to the power of 2.5 (6.25 power 0.5).

Ah! I was thinking that _26_ was something ES7 specific. Didn't know that variables can be in this form too! (I have never seen a variable without an alphabet). That was a very clever approach by @Neil. And you were very clever too in cracking it! Have your well-deserved +1! :)

Python, 15 bytes, Mr. Xcoder
lambda x:x**2.5

Pretty simple. Just takes x and raises it to the 2.5th power.

OCaml, 13 bytes, shooqie
fun f->f**2.5

Try it online!

I was posting it right now! Cannot believe it! Good job!

Python 3, 44  bytes, Kyle Gullion
Those *s were quite misleading. Very clever!
lambda i:i**(lambda o,r:o/r)(*map(ord,'i*'))

Due to the quite limited character set I would be very surprised if there were any other valid solutions beyond trivial renaming or reordering of arguments.

You got me, nicely done!

Inform 7, corvus_192
Cool, an Inform7 entry. :)  I just had to give this one a try.
I'm pretty sure this is the intended solution:
R is a room.

To f (n - number): say "[n * n * real square root of n]".

Note that this solution only works if compiled with the Glulx back-end, due to the use of the real square root of function.

BTW, the double quotes and square brackets are actually unnecessary; just say n * n * real square root of n would work just as well.  The periods at the end of the commands could be omitted, too; or we could keep the first period and get rid of the newlines instead.  Other parts of the code we could trim away include the article "a" before "room" and the spaces before the parentheses and after the colon.  Fortunately, since we've got a spare pair of brackets, we can always use them to comment out all these extra characters. ;) So this is a valid solution, too:
R is room.To f(n - number):say n * n * real square root of n[
" a . "
]

To test this solution interactively, it's convenient to append something like the following test harness to the code:
Effing is an action applying to one number.
Understand "f [number]" as effing.
Carry out effing: f the number understood.

After compiling and running the program, you can type e.g. f 4. f 6. f 9. f 25 at the > prompt and receive something like the following output:
Welcome
An Interactive Fiction
Release 1 / Serial number 170404 / Inform 7 build 6L38 (I6/v6.33 lib 6/12N) SD

R

>f 4. f 6. f 9. f 25
32.0
88.18164
243.0
3125.0
>

BTW, I just noticed that Inform (or presumably, rather, Glulx) rounds the last decimal place of f 6 wrong: the correct value is much closer to 88.18163 than to 88.18164.  Fortunately, I don't think this affects the correctness of the solution(s), especially since the challenge specified "any rounding mechanism of your choice". :)

I'm sure I found an Inform 7 fiddle a while ago, but I can't find it when I search. Do you know if there is an online interpreter anywhere?

@Flounderer: I don't really know of any. There are certainly online (even JS-based) players for the Glulx / Z-machine bytecode produced by the Inform 7 compiler, but I'm not aware of anything that would directly take plain Inform 7 source code and compile and run it online. The compiler / IDE is pretty easy to install, though; on Ubuntu Linux, it's as easy as apt-get install gnome-inform7.

Mathematica, Greg Martin
f[y_]:=With[{x=
    #&@@{#(#)#^(1/(1+1))&@y,#&@@@{1^(1),-1}}
},Print[#,".",IntegerString[Round@#2,10,3]]&@@QuotientRemainder[1000x,1000]]

Thanks for leaving the rounding stuff intact!
Explanation: #(#)#^(1/(1+1))&@y does the main work of multiplying y squared, aka y(y), and y's square root, y^(1/(1+1)). The #&@@@{1^(1),-1} bit is just junk to use up the other letters, and #&@@ picks out the useful bit from the junk.

C++ (gcc), 100 bytes, Mr. Xcoder
#include<math.h>
#include"iostream"
using namespace std;int main(){float n;cin>>n;cout<<pow(n,2.5);}

Try it online!

Well done! Please edit the answer you crack, because I cannot do it now!

An anonymous user suggested an edit to save 8 bytes by removing the using and just doing int main(){float n;std::cin>>n;std::cout<<pow(n,2.5);}

Save another byte #including  instead of math.h.:)

Haskell, Leo
x=exp.(2.5*).log

A pointfree function named x. Usage: x 4 -> 32.0

MATL, 12 bytes, Luis Mendo
10'U&+:'n/^P

Calculate 10/4 = 2.5 with 4 coming from string length. Use this as an exponent. P is a no-op here.

R, Steadybox
y<-function(p)(p^(1/2)*p^2);

seems to be an anagram of funny(p1)-tio(^*^)/pc(2)<p2;

Python 2, 60 bytes, Anthony Pham
print    (input()**(5.0/(2*5554448893999/5554448893840))-0)

Based on discarding characters through Python 2's float division (the default for / between integers).

C, 50 bytes, Dave
double b(float \ufa2d){return pow(\ufa2d,25e-1);%>

Try it online!
This requires -lm compiler flag, but I don't know how it would be possible to solve this without it.

correct, and almost exactly what I had (variable was named \uad2f on mine). Well done; I thought I'd left enough red-herrings in there to keep people busy a lot longer! Also the -lm flag wasn't needed for me using Clang (I'd have mentioned it!) but you're correct that strictly speaking it's required.

R, Flounderer
This is a crack of the 33 bytes solution of @Flounderer
scan()^(floor(pi)-1/2)-sin(7*0e1)

Usage:
> scan()^(floor(pi)-1/2)-sin(7*0e1)
1: 4
2:
Read 1 item
[1] 32
> scan()^(floor(pi)-1/2)-sin(7*0e1)
1: 6
2:
Read 1 item
[1] 88.18163
> scan()^(floor(pi)-1/2)-sin(7*0e1)
1: 9
2:
Read 1 item
[1] 243
> scan()^(floor(pi)-1/2)-sin(7*0e1)
1: 25
2:
Read 1 item
[1] 3125

Yes, this is not the intended solution which involved sin(pi), but unfortunately it does work! +1

It was scan()^(-floor(-sin(pi)*2e17)/10)

Python 3.6, 64 bytes, Mr. Xcoder
php38af4r2aoot2srm0itpfpmm0726991i=     (lambda x:x**2.5*1*1/1);

Maybe not what was intended, but works ;)
$ python3
Python 3.6.1 (default, Apr  4 2017, 09:36:47)
[GCC 4.2.1 Compatible Apple LLVM 7.0.2 (clang-700.1.81)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> php38af4r2aoot2srm0itpfpmm0726991i=     (lambda x:x**2.5*1*1/1);
>>> php38af4r2aoot2srm0itpfpmm0726991i(6)
88.18163074019441
>>> php38af4r2aoot2srm0itpfpmm0726991i(4)
32.0
>>> php38af4r2aoot2srm0itpfpmm0726991i(25)
3125.0

Not enough rep to comment on the cops' thread's answer yet, sorry... Would appreciate if someone could do it for me, thanks!

@Mr. Xcoder , as said above, can't comment on your post in the cops' thread, sorry about that :)

Came to post a similar solution from math import pi as pp0012223467899;f=lambda x:x**2.5*1*(1)/1 just to see I've been beaten to the punch. I've added a link to this post on the cops thread for you.

Röda, 28 bytes, fergusq
f(n){push n^0.5,n^2|product}

EXCEL, 26 Bytes pajonk
=SQRT(A1)*A1^2/1/ISNA(IP2)

A1 as input
IP2 contain a second input with a #N/A Error
in this case ISNA(IP2) belongs to 1
For an additional ()
we can do this
=SQRT(A1)*A1^2/ISNA(PI(1/2))

Is second input allowed in such challenge?

@pajonk The rules say "You can take input in any standard way" so I have assume that you make this trick with a second input

@pajonk I have improve my post it could been that you have make a little mistake

The standard way for taking one number is (I think) taking one input. In my opinion the second input would be unfair and against the rules. PS There's no mistake in number of brackets.

@pajonk I can not use combinations with SIN and PI cause there are not enough brackets. =SQRT(A1)*A1^2/SIN(PI()/2) If you set the #NA Error through formating or something else I would see it as additional second input. SQRT and ISNA are the only two functions that make a little sense. But please ask the man who had developed the question

RProgN 2, ATaco
]2^\š*

Apparently StackExchange needs extra characters, so here you go.

My solution was ]š\2^*, but they both work the same way.

HODOR, 198, This Guy
Walder
Hodor?!
hodor.
Hodor, Hodor Hodor Hodor Hodor Hodor Hodor Hodor, Hodor Hodor,
hodor,
Hodor, Hodor Hodor Hodor Hodor Hodor Hodor, Hodor Hodor,
Hodor, Hodor Hodor Hodor, hodor!,
HODOR!!
HODOR!!!

Explanation:
Start
read input into accumulator
copy accumulator to storage
Do math, option 7(nth root), n=2
swap storage and accumulator
Do math, option 6(nth power), n=2
Do math, option 3(times), storage
output accumulator as a number
end

note: I had to make some modifications to the get interpreter to run on my machine (the one you have posted doesn't seem to accept lowercase h, among some other things)
Also, I don't seem to have enough rep to comment, so if someone could let @This Guy know, I would be grateful
I think this fixed the error, the code now starts with Walder instead of Wylis, which adds the extra byte

Almost there. Had to change a mistake in my code so yours ins't quite right.

fixed the start command

Though that you had it but you went for a different method than me that uses the same number of bytes. Your answer would do what you wanted it to do but it isn't the same as mine. Also I had to change the name because of this so I made an edit to your posts.

for clarification, does this still count as a crack, or do I need to match up exactly?

I'm not exactly sure. I'm going to ask in the comments. +1 your solution is making me think really hard!

I'm just going to give you it given that they;re basically the same. Can I edit yours to add my original code?

@ThisGuy: The crack is valid as long as the exact same characters are used (it is an anagram of the original). Doesn't matter if it is the same as the original.

@Emigna Well I've still got NO!

C#, 172 bytes, raznagul
Hardest part was figuring out what to do with all the leftovers.
using System;using S=System.Console;class PMabddellorttuuv{static void Main(){S.Write(Math.Pow(double.Parse(S.ReadLine()),2.5));Func<double> o;int q=1,M=q*2,b,e;q*=(q*M);}}

Nice! I got stuck on the leftovers as well. Didn't think to add them to the class name, doh!. Good job!

+1 Not what I had intended, but very nice solution. ;)

Python 2.7, Koishore Roy
s=e=x=y=input()**0.5
print'%.3f'%(y**(5.0))

Or y=x=e=s, both work :)) Good job anyways!

Good job. :P
Now I need to work on a new code. Darn!

R, Flounderer
This is a crack of @Flounderer's 31-byte solution:
`[.`=function(`]`)`]`^`[`(lh,9)

Ok that was a tough one. It creates a function called `[.`. The argument to the function is called `]` which is elevated to power 2.5 by using the 9th element of the built-in time-serie lh ("a regular time series giving the luteinizing hormone in blood samples at 10 mins intervals from a human female, 48 samples." that is used as example in one of R's base packages). lh[9] is here on top of it replaced by its equivalent `[`(lh, 9). De-obfuscated by substituting f for the function name and n for the argument name, the function then becomes f=function(n)n^lh[9].
Usage:
> `[.`=function(`]`)`]`^`[`(lh,9)
> `[.`(4)
[1] 32
> `[.`(6)
[1] 88.18163
> `[.`(9)
[1] 243
> `[.`(25)
[1] 3125

C#, 112 bytes, Jan Ivan
using System;class P{static void Main(){var b=Math.Pow(double.Parse(Console.ReadLine()),2.5);Console.Write(b);}}

Fireball, 8 bytes, Okx
♥²♥1Z/^*

Explanation:
♥²♥1Z/^*
♥²       Push first input squared.
  ♥      Push first input again.
   1Z/   Push 1/2
      ^  First input to the 1/2th
       * Multiply square and root

Not sure if it works. I have currently no java on my laptop. :(

I don't think that will work. Easy fix though, so I'll give you the answer. You just need to swap the Z1 into 1Z.

I was sure I did a mistake there. Updated.

05AB1E, 47 bytes, Okx
).2555BFHIJJKKKPQRS``„cg…ghi…lsw…x}T…Áöž«‚¹n¹t*

Try it online!

Ah, I knew there would be a workaround the method I used to 'secure' the code. Well done!

@Okx: Yeah, 05AB1E is very tricky to pad with extra code without making it bypassable.

I'll see if I can make you a trickier one ;)

@Okx: Looking forward to it :) I have an idea as well that I may try to implement after work ;)

CJam, 8 bytes, Roman Gräf
My First ever CJam answer.
CnR are great for testing new languages :)
ldYYW#+#

Try it online!
Explanation
ld         % double(input)
       #   %              ^
  Y        %               (2
      +    %                 +
   Y       %                  2
     #     %                   ^
    W      %                    -1)

Haskell, 64 bytes, @nimi
product.(<$>(($(succ.cos$0))<$>[(flip<$>flip)id$id,recip])).(**)

Try it online! That was a fun one. I first found product.(<$>(($succ(cos$0))<$>[id,recip])).(**) which behaves correctly and than had to fit flip flip <$> () $ id . somewhere into it.

R, steadybox
a222=function(s)(s**0.5)*s**2**1

Usage:
> a222=function(s)(s**0.5)*s**2**1
> a222(4)
[1] 32
> a222(6)
[1] 88.18163
> a222(9)
[1] 243
> a222(25)
[1] 3125

Original: a=function(s)s**2*s**(0.125*2*2)

05AB1E, 22 bytes, P. Knops
n¹t*qA9¥="'?:@->%#[{!.

Try it online!
Explanation
n      # square of input
   *   # times
 ¹t    # square root of input
    q  # end program

The rest of the operations never get executed.
We could have done it without the q as well by having ? after the calculation and escaping the equality sign for example with '=.

Was just doing it for fun :D

@P.Knops: That's the best reason :)

Python 2, 44 bytes, Anthony Pham
print int(raw_input())**(0+000000000000.5*5)

Takes input from raw_input, converts to int and raises to power 2.5

JavaScript, fəˈnɛtɪk
n=>n**("ggggg".length*2**(-"g".length))// ""((((((()))))))***,-...;;=====>Seeeeegggghhhhhhhhhilllnnnnnnorrrsstttttttttttu{}

Gets 5/2 through 5 times 2 to the negative first power, where 5 and 1 were received from the length of strings. Took the easy way out in a sense by commenting out the extraneous characters.

C, 115 bytes, user4867444
New solution that works for 0.
o(double n){double l=1;;for(double o=0.;o<=8*8*2e3&&(long)o+n*((long)2*3>>1);o++)l=(l+n/l)/2;printf("%.3f",n*n*l);}

Old solution that doesn't work for 0:
o(double n){double l=n;;for(double o=1.0;o<=8*8*2e+3&&(long)o*((long)2*3>>1);o++)l=(l+n/l)/2;printf("%.3f",n*n*l);}

Applying Newton's method (for square root) a very large fixed number of times seems to give adequate precision for numbers in the required range. I did some character wasting in the first two for loop clauses.

Close, but not quite, as it returns nan for 0 (not sure we care about that case, asked the OP in a comment)

As specified by the OP, our programs must return 0 for 0, so I'm afraid your solution doesn't work.

@user4867444: Sorry, I didn't understand that it must work for 0. I've provided a modified solution that should work for 0.

the original solution was o(double n){long o=2.303e18+(*(long*)&n>>1);double l=*(double*)&o;for(o=2;o++<8;)l=(l+n/l)/2;printf("%.3f",l*n*n);}, which uses a nice magic constant to only do a few Newton iterations as opposed to thousands - but great job!

HODOR, 171 bytes, wwj
Walder
Hodor
Hodor
Hodor
Hodor
Hodor
Hodor, Hodor Hodor Hodor Hodor, Hodor Hodor,
hodor.
Hodor.
Hodor?!
Hodor, Hodor Hodor Hodor Hodor Hodor Hodor, hodor!,
HODOR!!
HODOR!!!

Explanation

Increment accumulator to 5
Divide accumulator by 2
Save a copy of accumulator value
Set accumulator to 0
Read input
Raise input to the value of the stored copy (2.5)
Output as number

back to the drawing board

JavaScript, 39 bytes, SLuck49
x=>(l=Math).cbrt(l.exp(l.log(x)*7.5))

or similarly
x=>(l=Math).exp(l.log(l.cbrt(x))*7.5)

Test:

alert((

x=>(l=Math).cbrt(l.exp(l.log(x)*7.5))

)(prompt()));

05AB1E, 22 bytes, Emigna
è›¹DDLÏ_zTnF©¹®/+;}¹DP

Most probably not what was intended, but works ;)
Everything before T is just byte wasting (but which leaves the stack empty), then it does a 100 Newton iterations, which yields a good enough approximation of the square root, then pushes the input twice and returns the product of the whole stack, thus giving the desired output.
Example runs:
$ echo 0 | ./05AB1E.py -e 'è›¹DDLÏ_zTnF©¹®/+;}¹DP'
0.0
$ echo 4 | ./05AB1E.py -e 'è›¹DDLÏ_zTnF©¹®/+;}¹DP'
32.0
$ echo 6 | ./05AB1E.py -e 'è›¹DDLÏ_zTnF©¹®/+;}¹DP'
88.18163074019441
$ echo 25 | ./05AB1E.py -e 'è›¹DDLÏ_zTnF©¹®/+;}¹DP'
3125.0
$ echo 7131 | ./05AB1E.py -e 'è›¹DDLÏ_zTnF©¹®/+;}¹DP'
4294138928.896773

Nice one! Didn't think of that :P

05AB1E, 15 bytes, user4867444
DMžDFD¹s/+;}01P

Try it online!
Explanation
D                 # duplicate input
 M                # push the largest value on the stack (the input)
  žDF             # 4096 times do:
     D            # current value
         +        # added to
      ¹s/         # input divided by current value
          ;       # divide sum by 2
           }      # end loop
            01    # push 1
              P   # product of the stack

05AB1E, 23 bytes, user4867444
$DDžHGD¹s/+;}0@rrzz2+\P

Try it online!
Explanation
$                        # push 1 and input
 DD                      # duplicate the input twice
   žHG                   # 65536 times do:
      D                  # duplicate current value
       ¹s/               # divide input by current value
          +              # add result of division to current value
           ;             # divide by 2
            }            # end loop
             0@          # get the bottom value of the stack (the 1)
               rr        # reverse the stack twice (no-op)
                 zz      # calculate 1/(1/1), a no-op
                   2+    # add 2
                     \   # discard top of stack (the 3)
                      P  # product of stack

JavaScript, SIGSEGV
x=>x**(25*10**-1)

Try it online!

You got it! Kudos for you ;)

R, Flounderer
scan()**mean(1:4.5)

Try it online!

Python 3.6, c..
f=lambda x:x**2.5or'1*77*8+8/5/(((aafothipie.xml)))'

Try it online!
Stuffs all the unneeded characters into a string after the or. Since x**2.5 is nonzero and so truthy, the part after the or isn't evaluated. Any syntactically valid expression would be OK here.
Python parses 2.5 and or as separate tokens in 2.5or, though the syntax highlighter for the code doesn't recognize this.

I think you meant x**2.5? Damn Python, I'm doing the next one without strings.

@c.. Yes, 2.5, thanks.

Ruby, G B
->a{eval''<<97<<42<<42<<50<<46<<53}

Nice, I was expecting that, maybe not so fast. :-)

Python - SparklePony
import math
f=lambda x:x*x*math.sqrt(x)

That was very fast!

Thanks @SparklePony. It was very similar to mine, done it right away

@SparklePony please accept the edit...

I think I have done it... first time accepting an edit!

Scala, corvus_192
d=>math.pow(d,5/2d)

Try it here!
Simple lambda expression

05AB1E - P. Knops
t¹n*

Was quite easy :)

C, Steadybox
float q(float b){return(b-b>0.*4*1/1)-sqrtf(b)*pow(b,2)*-1;}

Not sure what the original did; I had to discard a lot of random operators and numbers, but once the available words were clear it wasn't too hard to piece together the general idea.

Oops; noticed I'd accidentally included an extra space than the original; fixed.

Here's the original function: float q(float b){return-1*pow(b,(b>-12)/sqrt(4.0f))*b*b*-1;}

C#, 135 bytes, Jan Ivan
This was a lot of fun, I particularly liked the use of using static.
using System;using static System.Math;class P{static void Main(){Console.Write(Pow(long.Parse(Console.ReadLine()),1/Round(PI-E,1)));}}

JavaScript, SIGSEGV
x=>x**(3.5-+!+[]);

Try it online!

Well, not the same, but well, that works too. maybeIshouldn'tuseasterisks

@SIGSEGV: I'd be interested to see what the intended version was then :)

Vyxal, cracks emanresuA's answer
5|2/en[(`ĖĖ:

Try it Online!
Easy. I came up with the solution in the shower that's how easy it is.

So you have, thanks to an oversight of mine. On to round 2