#Stax , (削除) 26 (削除ここまで)(削除) 24 (削除ここまで) 18 bytes
Stax , (削除) 26 (削除ここまで)(削除) 24 (削除ここまで) 18 bytes
:u{m*_{y#m:u_hy#h*
(削除) Shortest solution so far that only uses printable ASCIIs (削除ここまで) Beaten by MATL.
Guess I was approaching the problem the wrong way. Repeating a working block is neither golfy nor interesting. Now at least it looks better ...
Explanation
:u{m* produces some garbage that does not affect the output.
_{y#m:u_hy#h*
_{y#m map each character to its number of occurences in the string
:u all counts are equal (result 1)
_hy# get the count of appearance for the first character
h halve it and take the floor, so that 1 becomes 0(result 2)
* multiply the two results
#Stax , (削除) 26 (削除ここまで)(削除) 24 (削除ここまで) 18 bytes
:u{m*_{y#m:u_hy#h*
(削除) Shortest solution so far that only uses printable ASCIIs (削除ここまで) Beaten by MATL.
Guess I was approaching the problem the wrong way. Repeating a working block is neither golfy nor interesting. Now at least it looks better ...
Explanation
:u{m* produces some garbage that does not affect the output.
_{y#m:u_hy#h*
_{y#m map each character to its number of occurences in the string
:u all counts are equal (result 1)
_hy# get the count of appearance for the first character
h halve it and take the floor, so that 1 becomes 0(result 2)
* multiply the two results
Stax , (削除) 26 (削除ここまで)(削除) 24 (削除ここまで) 18 bytes
:u{m*_{y#m:u_hy#h*
(削除) Shortest solution so far that only uses printable ASCIIs (削除ここまで) Beaten by MATL.
Guess I was approaching the problem the wrong way. Repeating a working block is neither golfy nor interesting. Now at least it looks better ...
Explanation
:u{m* produces some garbage that does not affect the output.
_{y#m:u_hy#h*
_{y#m map each character to its number of occurences in the string
:u all counts are equal (result 1)
_hy# get the count of appearance for the first character
h halve it and take the floor, so that 1 becomes 0(result 2)
* multiply the two results
#Stax, (削除) 26 (削除ここまで) (削除) 24 (削除ここまで) 18 bytes
:u{m*_{y#m:u_hy#h*
Shortest solution so far that only uses printable ASCIIs (or not?)(削除) Shortest solution so far that only uses printable ASCIIs (削除ここまで) Beaten by MATL.
Guess I was approaching the problem the wrong way. Repeating a working block is neither golfy nor interesting. Now at least it looks better ...
Explanation
:u{m* produces some garbage that does not affect the output.
_{y#m:u_hy#h*
_{y#m map each character to its number of occurences in the string
:u all counts are equal (result 1)
_hy# get the count of appearance for the first character
h halve it and take the floor, so that 1 becomes 0(result 2)
* multiply the two results
#Stax, (削除) 26 (削除ここまで) (削除) 24 (削除ここまで) 18 bytes
:u{m*_{y#m:u_hy#h*
Shortest solution so far that only uses printable ASCIIs (or not?)
Guess I was approaching the problem the wrong way. Repeating a working block is neither golfy nor interesting. Now at least it looks better ...
Explanation
:u{m* produces some garbage that does not affect the output.
_{y#m:u_hy#h*
_{y#m map each character to its number of occurences in the string
:u all counts are equal (result 1)
_hy# get the count of appearance for the first character
h halve it and take the floor, so that 1 becomes 0(result 2)
* multiply the two results
#Stax, (削除) 26 (削除ここまで) (削除) 24 (削除ここまで) 18 bytes
:u{m*_{y#m:u_hy#h*
(削除) Shortest solution so far that only uses printable ASCIIs (削除ここまで) Beaten by MATL.
Guess I was approaching the problem the wrong way. Repeating a working block is neither golfy nor interesting. Now at least it looks better ...
Explanation
:u{m* produces some garbage that does not affect the output.
_{y#m:u_hy#h*
_{y#m map each character to its number of occurences in the string
:u all counts are equal (result 1)
_hy# get the count of appearance for the first character
h halve it and take the floor, so that 1 becomes 0(result 2)
* multiply the two results
#Stax, (削除) 26 (削除ここまで) (削除) 24 (削除ここまで) 18 bytes
:u{m*_{y#m:u_hy#h*
Shortest solution so far that only uses printable ASCIIs (or not?)
Guess I was approaching the problem the wrong way. Repeating a working block is neither golfy nor interesting. Now at least it looks better ...
Explanation
:u{m* produces some garbage that does not affect the output.
_{y#m:u_hy#h*
_{y#m map each character to its number of occurences in the string
:u all counts are equal (result 1)
_hy# get the count of appearance for the first character
h halfhalve it and take the floor, so that 1 becomes 0(result 2)
* multiply the two results
#Stax, (削除) 26 (削除ここまで) (削除) 24 (削除ここまで) 18 bytes
:u{m*_{y#m:u_hy#h*
Shortest solution so far that only uses printable ASCIIs (or not?)
Guess I was approaching the problem the wrong way. Repeating a working block is neither golfy nor interesting. Now at least it looks better ...
Explanation
:u{m* produces some garbage that does not affect the output.
_{y#m:u_hy#h*
_{y#m map each character to its number of occurences in the string
:u all counts are equal (result 1)
_hy# get the count of appearance for the first character
h half it and take the floor, so that 1 becomes 0(result 2)
* multiply the two results
#Stax, (削除) 26 (削除ここまで) (削除) 24 (削除ここまで) 18 bytes
:u{m*_{y#m:u_hy#h*
Shortest solution so far that only uses printable ASCIIs (or not?)
Guess I was approaching the problem the wrong way. Repeating a working block is neither golfy nor interesting. Now at least it looks better ...
Explanation
:u{m* produces some garbage that does not affect the output.
_{y#m:u_hy#h*
_{y#m map each character to its number of occurences in the string
:u all counts are equal (result 1)
_hy# get the count of appearance for the first character
h halve it and take the floor, so that 1 becomes 0(result 2)
* multiply the two results