[Question]
  [
It's become somewhat of a tradition in PPCG that some users temporarily change their names by an anagram (a new name formed by reordering the letters of the old).
Sometimes it gets difficult to find out who is who. I could use a program or function to tell if two phrases are anagrams of each other.
### The challenge
The program or function should take two strings and produce a truthy result if they are anagrams of each other, and falsy otherwise. 
### Rules
* Input will only contain letters (ASCII 65 to 90 and 97 to 122), digits (ASCII 48 to 57) or space (ASCII 32).
* The anagram relation is independendent of case. So "Arm" and "RAM" are anagrams.
* Spaces don't count either. So "keyboard" and "Barked Yo" are anagrams
* All builtins allowed
* Input format is flexible (two strings, an array of two strings, a string containing both phrases with a suitable separator ...)
Code golf. Fewest bytes wins.
### Test cases
Truthy:
```
Lynn, Nyl N
Digital Trauma, Tau Digital Arm
Sp3000, P S 3000
Manage Trash So, Those anagrams
```
Falsy
```
Calvins Hobbies, Helka Homba
Android, rains odd
In between days, bayed entwine
Code golf, cod elf got
```
  
[Answer]
# Retina, 25
```
i+`(\w)(.*,.*)\1
$2
^\W*$
```
[Try it Online!](http://retina.tryitonline.net/#code=aStgKFx3KSguKiwuKilcMQokMgpeXFcqJA&input=RGlnaXRhbCBUcmF1bWEsIFRhdSBEaWdpdGFsIEFybQ) Additionally, you can run a modified [multi-line version](http://retina.tryitonline.net/#code=aStgKFx3KSguKiwuKilcMQokMgptYF5bLCBdKiQKcGFzcwptYF5bXsK2LV0qLFtewrYtXSokCmZhaWw&input=THlubiwgTnlsIE4KRGlnaXRhbCBUcmF1bWEsIFRhdSBEaWdpdGFsIEFybQpTcDMwMDAsIFAgUyAzMDAwCk1hbmFnZSBUcmFzaCBTbywgVGhvc2UgYW5hZ3JhbXMKLS0tLS0KQ2FsdmlucyBIb2JiaWVzLCBIZWxrYSBIb21iYQpBbmRyb2lkLCByYWlucyBvZGQKSW4gYmV0d2VlbiBkYXlzLCBiYXllZCBlbnR3aW5lCkNvZGUgZ29sZiwgY29kIGVsZiBnb3Q).
Delete letters from before the comma along with their matches after the comma. If we have no letters left then it was an anagram.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~9~~ 8 bytes
Code:
```
lvyð-{}Q
```
Explanation:
```
l         # Lowercase the strings
 vy   }   # Map over the list, for each...
   ð-     #   remove spaces
     {    #   and sort
       Q  # Check equality
```
[Try it online!](http://05ab1e.tryitonline.net/#code=bHZ5w7Ate31R&input=WyJMdWlzIE1lbmRvIiwgIkRvbiBNdWVzbGkiXQ)
[Answer]
# Pyth, ~~11~~ 10 bytes
Thanks to @FryAmTheEggman for teaching me the power of `;`!
```
qFmSr-d;0Q
```
[Try it here!](http://pyth.herokuapp.com/?code=qFmSr-d%3B0Q&input=%5B%22Code+golf%22%2C%22cod+elf+got%22%5D&test_suite=1&test_suite_input=%5B%22Lynn%22%2C%22Nyl+N%22%5D%0A%5B%22Digital+Trauma%22%2C%22Tau+Digital+Arm%22%5D%0A%5B%22Sp3000%22%2C%22P+S+3000%22%5D%0A%5B%22Manage+Trash+So%22%2C%22Those+anagrams%22%5D%0A%5B%22Calvin%27s+Hobbies%22%2C%22Helka+Homba%22%5D%0A%5B%22Android%22%2C%22rains+odd%22%5D%0A%5B%22In+between+days%22%2C%22bayed+entwine%22%5D%0A%5B%22Code+golf%22%2C%22cod+elf+got%22%5D&debug=0)
Takes a list of two strings as input.
## Explanation
```
qFmSr-d;0Q    # Q = input
  m      Q    # map Q with d as lambda variable
     -d;      # filter spaces out of the string
    r   0     # convert to lowercase
   S          # sort all characters in string
qF            # Unfold resulting list and check for equality
```
[Answer]
# Python 2, ~~63~~ 61 bytes
```
lambda*l:len({`sorted(s.lower())`[2::5].strip()for s in l})<2
```
An anonymous function that, in fact, takes *n* arguments and determines if all *n* of them are mutual palindromes! `f("Lynn", "Nyl N")` returns `True`.
This set comprehension trick is by xnor. It saved two bytes, but the old approach looked very neat:
```
exec"a=`sorted(input().lower())`[2::5].strip();a"*2;print a==aa
```
[Answer]
# Jelly, 12 bytes
```
ḟ€⁶O&95Ṣ€QLḂ
```
[Try it online!](http://jelly.tryitonline.net/#code=4bif4oKs4oG2TyY5NeG5ouKCrFFM4biC&input=&args=Ik1hbmFnZSBUcmFzaCBTbyIsICJUaG9zZSBhbmFncmFtcyI)
### How it works
```
ḟ€⁶O&95Ṣ€QLḂ  Main link. Input: A (list of strings)
  ⁶           Yield ' '.
ḟ€            Filter it from each string.
   O          Apply ordinal to all characters.
    &95       Take bitwise AND with 95 to make the ordinals case-insensitive.
       Ṣ€     Sort each list of ordinals.
         Q    Deduplicate the list.
          L   Get the length.
           Ḃ  Compute the length's parity (1 -> 1, 2 -> 0).
```
## Alternate version (9 bytes)
Jelly's uppercase atom had a bug, and Jelly still had no built-in to test lists for equality...
```
ḟ⁶ŒuṢµ€⁼/
```
[Try it online!](http://jelly.tryitonline.net/#code=4bif4oG2xZJs4bmiwrXigqzigbwv&input=&args=Ik1hbmFnZSBUcmFzaCBTbyIsICJUaG9zZSBhbmFncmFtcyI)
### How it works
```
ḟ⁶ŒuṢµ€⁼/     Main link. Input: A (list of strings)
     µ€       Map the chain to the left over A.
 ⁶            Yield ' '.
ḟ             Filter it from the string.
  Œu          Cast to uppercase.
    Ṣ         Sort.
       ⁼/     Reduce by equality.
```
[Answer]
# CJam, 11 ~~12~~ ~~14~~ bytes
*3 ~~2~~ bytes removed thanks to @FryAmTheEggman*
```
{lelS-$}2*=
```
[**Try it online!**](http://cjam.tryitonline.net/#code=e2xlbFMtJH0yKj0&input=QW5kcm9pZApyYWlucyBvZGQ)
```
{      }2*       e# do this twice
 l               e# read line as a string
  el             e# make lowercase
    S-           e# remove spaces from string
      $          e# sort
          =      e# compare strings
```
[Answer]
# Javascript, ~~69~~ ~~61~~ ~~60~~ 59 bytes
1 byte off thanks [@ӍѲꝆΛҐӍΛПҒЦꝆ](https://codegolf.stackexchange.com/users/41247/%D3%8D%D1%B2%EA%9D%86%CE%9B%D2%90%D3%8D%CE%9B%D0%9F%D2%92%D0%A6%EA%9D%86). 1 byte off with currying ([pointed out](https://codegolf.meta.stackexchange.com/a/8427/48943) by [@apsillers](https://codegolf.stackexchange.com/users/7796/apsillers))
```
n=>m=>(G=s=>[]+s.toLowerCase().split(/ */).sort())(n)==G(m)
```
```
f=n=>m=>
    (G=s=>[]+s.toLowerCase()
        .split(/ */)
        .sort()
    )(n)==G(m)
F=(n,m)=>document.body.innerHTML+=`<pre>f('${n}')('${m}') -> ${f(n)(m)}</pre>`
F('Luis Mendo','Don Muesli')
F('Calvins Hobbies','Helka Homba')
F('Android','rains odd')
F('In between days','bayed entwine')
F('Code golf','cod elf got')
F('Lynn','Nyl N')
F('Digital Trauma','Tau Digital Arm')
F('Sp3000','P S 3000')
F('Manage Trash So','Those anagrams')
```
[Answer]
# [MATL](https://esolangs.org/wiki/MATL), 11 bytes
```
2:"jkXvS]X=
```
*EDIT (May 20, 2016) The code in the link uses `Xz` instead of `Xv`, owing to recent changes in the language.*
[**Try it online!**](http://matl.tryitonline.net/#code=MjoiamtYelNdWD0&input=TWFuYWdlIFRyYXNoIFNvClRob3NlIGFuYWdyYW1z)
```
2:"     ]       % do this twice
   j            % read input line as a string
    k           % convert to lowercase
     Xv         % remove spaces
       S        % sort
         X=     % are they equal?
```
[Answer]
## Seriously, ~~11~~ 9 bytes
```
2`,ùSô`n=
```
[Try It Online!](http://seriously.tryitonline.net/#code=MmAsw7lTw7Rgbj0&input=)
Everyone seems to be using the same algorithm. Here it is yet again.
```
2`    `n          Do it twice
  ,               Read a string
   ù              Make it lowercase
    S             Sort
     ô            Strip spaces.
        =         Check equality.
```
Edit: realized sorting does work correctly on strings, and sorts spaces to the front so strip() will work.
[Answer]
# C, 165 bytes
```
#define d(x) int x(char*a,char*b){
d(q)return*a&224-*b&224;}
#define n(x) for(qsort(x,strlen(x),1,(__compar_fn_t)q);*x<33;x++);
d(s)n(a)n(b)return strcasecmp(a,b);}
```
Readable and in working context,
```
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
// start of comparison
int q(char *a, char *b){
     return ((*a)&0xdf)-((*b)&0xdf); // case-insensitive
}
int s(char *a, char *b){
    for(qsort(a,strlen(a),1,(__compar_fn_t)q); *a<33; a++) /**/;
    for(qsort(b,strlen(b),1,(__compar_fn_t)q); *b<33; b++) /**/;
    return strcasecmp(a,b);
}
// end of comparison
int main(int i, char **v){
    printf("'%s' '%s'", v[1], v[2]);
    printf("=> %d\n", s(v[1], v[2])); // 0 if equalish
    return 0;
}
```
[Answer]
## zsh, 85 bytes
```
[ $(for x in $@;{tr -d \ <<<$x|tr A-Z a-z|fold -1|sort|paste -sd x}|uniq|wc -l) = 1 ]
```
Input as command line arguments, output as return code.
The `for` syntax makes this Bash-incompatible.
```
[               # test...
$(for x in $@;  # map over arguments
{tr -d \ <<<$x  # remove spaces
|tr A-Z a-z     # lowercase
|fold -1        # put each character on its own line
|sort           # sort lines
|paste -sd x    # remove all newlines except last
}|uniq          # take only unique lines
|wc -l          # how many lines remain?
) = 1 ]         # if only 1 line left, it must have been an anagram
```
[Answer]
# Japt, 12 bytes
```
N®v ¬n ¬xÃä¥
```
[Test it online!](http://ethproductions.github.io/japt?v=master&code=Tq52IKxuIKx4w+Sl&input=Ik1hbmFnZSBUcmFzaCBTbyIgIlRob3NlIEFuYWdyYW1zIg==)
### How it works
```
        // Implicit: N = array of input strings
N®    Ã // Take N, and map each item Z to:
v ¬n    //  Take Z.toLowerCase(), split into chars, and sort.
¬x      //  Join and trim off whitespace.
ä¥      // Reduce each pair of items (that's exactly one pair) X and Y to X == Y.
```
[Answer]
# Bash + GNU utilities, 51
```
f()(fold -1<<<${@^^}|sort)
f $1|diff -qBw - <(f $2)
```
* Define a function `f()` which:
	+ `${@^^}` converts all parameters to upper case
	+ `fold -1` splits chars - one per line
	+ `sort`s lines
* call `diff` with `-q` to suppress full diff output and `-Bw` to ignore whitespace changes
[Answer]
# GNU Sed, 33
Score includes +2 for `-rn` options to sed.
This is almost a direct port of @FryAmTheEggman's [Retina answer](https://codegolf.stackexchange.com/a/74183/11259):
```
:
s/(\w)(.*,.*)\1/\2/i
t
/\w/Q1
```
[Ideone.](https://ideone.com/ANy32v)
[Answer]
## Perl, ~~34~~ 33 + 1 = 34 bytes
```
s/(.)(.*,.*)\1/$2/i?redo:say!/\w/
```
Requires the `-n` flag and the free `-M5.010`|`-E`:
```
$ perl -M5.010 -ne's/(.)(.*,.*)\1/$2/i?redo:say!/\w/' <<< 'hello, lloeh'
1
```
How it works:
```
                                   # '-n' make a implicit while loop around the code
 s/(.)(.*,.*)\1/$2/i               # Remove a letter that occurs on both sides of the comma.
                    ?
                     redo:         # Redo is a glorified goto statement that goes to the top of the while loop
                          say!/\w/ # Check to see if any letter is left
```
Thanks to [msh210](https://codegolf.stackexchange.com/users/1976/msh210) for suggesting using ternary operators to save one byte
[Answer]
# [Zsh](https://zsh.sourceforge.io/), 51 bytes
[Try it Online!](https://tio.run/##NY3NTsMwEITveYpVyME@oCSABIoCqIJDkaBCah@gm9j5AcdGcUoUqjy72fz04vHON7P7ZytXMH52JeNpmgZn9pUknMRY0jhRYxjC6M0oYCUEMQ9nveGjGz3USGUPQOaVIUg@DfgYsD6H65xqx2Kxj5zAcuGKB4zhU/x8HyUPd5yP3rwI/PdBax/83aBg5y/Wa13WHSo4tHhqkOABT3AxN22zxvY/t1EUEf6EPczfxf@gt5RT21awN1O/MlbCZLfY2DX2guq31ha2JstqaSm2leobaW4yXDMbLVpTC2ItTlkjxEreNGSy66XUIHCY2hkOUoDUXV9reblhhITSqIJ4boiqgsbOd879Aw)
```
g()<<<${(j::)${(os::)1:l}// }
<<<${$(g $1)/$(g $2)}
```
Similar to [my other anagram solution](https://codegolf.stackexchange.com/a/254780/15940), again using Zsh's gnarly [parameter expansion](https://zsh.sourceforge.io/Doc/Release/Expansion.html#Parameter-Expansion). Added a few bits to lowercase everything and parse out spaces.
[Answer]
# [Arturo](https://arturo-lang.io), 33 bytes
```
$=>[=do map&=>[tally--lower&` `]]
```
[Try it!](http://arturo-lang.io/playground?RiBHsL)
Takes input as a list of two strings.
```
$=>[               ; a function where input is assigned to &
    map&=>[        ; map over input, assign current elt to &
        lower&     ; lowercase current elt
        -- _ ` `   ; remove spaces
        tally      ; create dictionary of occurrences
    ]              ; end map
    do             ; put the pair on the stack
    =              ; are they equal?
]                  ; end function
```
[Answer]
# [Cyborg Hal](https://github.com/JCumin/Brachylog), ~~9~~ 8 bytes
```
{ṇ₁cḷo}ᵛ
```
[Try it online!](https://tio.run/##NYwxTsQwEEWvMnK9QhGcYAXFIsEKKdtFKcbxJLFwbGQ7RNGyBSmAO9DR0NIg4AycIrlIsLOim//f@8MtFnWvTHU676enj2kYppd35m1L7OQhniUqR@zw@9bN@/HneRoei/H7yxzGz9d5zjJ21WvNVmzbK9iyfJWxC1lJjwp2FtsGA9phC//l2jaLlN6dJUkS4A2ksJyxvUaNFcWlqyE1cVsbRxBri41bpHNU91I72BjOJbkgbUjdYsgNx8VYa2GNFIFYjKYRYukvNXDyHZEGgX1ccuxJAGnfSU3H70YQVEaVgRYmMFWG6Fme/wE "Brachylog – Try It Online")
Truthy/falsy output is achieved through predicate success/failure, this being Brachylog.
Previously saved a byte using `cṇ₁cḷḍ` instead of `{ṇ₁cḷ}ᵐ` under the assumption that the two input strings would be the same length minus whitespace, but I realized that it would succeed where it should fail on `Ah Hass, haha`.
```
{     }ᵛ    For both strings in the input,
 ṇ₁         split on spaces,
   c        concatenate,
    ḷ       lowercase,
     o      and sort.
       ᵛ    Are the results the same?
```
[Answer]
# PHP, ~~109~~ 94 bytes
```
function f($x){return str_split((trim($x));}function g($x,$y){return array_diff(f($x),f($y));}
```
Blech, the two `function/return`s are killing me here.
Returns the difference between two `string` inputs as an `array` of characters. PHP considers `[]` falsy, satisfying the `return` requirements.
[Answer]
## [Pyke](https://github.com/muddyfish/PYKE) (commit 30, noncompetitive), 9 bytes
```
Fl1dk:S)q
```
Explanation:
```
F      )  -  for _ in eval_or_not(input())
 l1       -     ^.lower()
   dk:    -    ^.replace(" ", "")
      S   -   sorted(^)
        q - ^==^
```
[Answer]
# Mathematica, ~~77~~ 76 bytes
```
StringMatchQ[##,IgnoreCase->1>0]&@@(""<>Sort[Characters@#/." "->""]&/@{##})&
```
The first part is actually one of my answers to another question!
[Answer]
# Pike, ~~54~~ ~~112~~ ~~109~~ ~~109~~ 96 bytes
```
#define a(x) sort((array)replace(lower_case(x)," ",""))
int s(mixed i){return a(i[0])==a(i[1]);}
```
`mixed` happens to be shorter than `array(string)`.
`s` returns `1` if its arguments are anagrams.
[Answer]
## APL, 31 chars
```
{≡/{x[⍋x←('.'⎕R'\u0')⍵~' ']}¨⍵}
```
To be used so:
```
    {≡/{x[⍋x←('.'⎕R'\u0')⍵~' ']}¨⍵}'Sp3000' 'P S 3000' 
1
```
In English: 
* `{ ... }¨⍵`: for each of the two elements of the argument
* `x←('.'⎕R'\u0')⍵~' '`: transform to uppercase (using a regex...) the string without the spaces and assign the temporary result to `x`
* `x[⍋x]`: sort x
* `≡/`: compare the two results of the sorting: if they match, return 1.
[Answer]
# Java, 218 Bytes
*First time I've ever written Java...*
Golfed:
```
import java.util.Arrays;boolean M(String a,String b){char[]A=a.toUpperCase().replace(" ","").toCharArray();char[]B=b.toUpperCase().replace(" ","").toCharArray();Arrays.sort(A);Arrays.sort(B);return Arrays.equals(A,B);}
```
Ungolfed:
```
import java.util.Arrays;
public class ManageTrashSo {
    public boolean M(String a, String b) {
    char[] A = a.toUpperCase().replace(" ", "").toCharArray();
    char[] B = b.toUpperCase().replace(" ", "").toCharArray();
    Arrays.sort(A);
    Arrays.sort(B);
    return Arrays.equals(A, B);
   }
}
```
Testing:
```
    ManageTrashSo manageTrashSo = new ManageTrashSo();
    //True
    System.out.println(manageTrashSo.M("Lynn", "Nyl N"));
    System.out.println(manageTrashSo.M("Digital Trauma", "Tau Digital Arm"));
    
    //False
    System.out.println(manageTrashSo.M("Android", "rains odd"));
    System.out.println(manageTrashSo.M("In between days", "bayed entwine"));
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt/), 10 bytes
```
v á øVrS v
```
[Try it](https://ethproductions.github.io/japt/?v=1.4.5&code=diDhIPhWclMgdg==&input=Ikx5bm4iLCJOeWwgTiI=)
[Answer]
# [lyxaV](https://github.com/Vyxal/Vyxal), 5 bytes
```
ɽȧvs≈
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCLJvcindnPiiYgiLCIiLCJbXCJWeXhhbFwiLCBcImx5eGFWXCJdIl0=)
Or [try a testsuite](https://vyxal.pythonanywhere.com/#WyJBIiwiXCIiLCLJvcindnPiiYgiLCIiLCJMeW5uLCBOeWwgTlxuRGlnaXRhbCBUcmF1bWEsIFRhdSBEaWdpdGFsIEFybVxuU3AzMDAwLCBQIFMgMzAwMFxuTWFuYWdlIFRyYXNoIFNvLCBUaG9zZSBhbmFncmFtc1xua2V5Ym9hcmQsIEJhcmtlZCBZb1xuYXJtLCBSQU1cbkNhbHZpbnMgSG9iYmllcywgSGVsa2EgSG9tYmFcbkFuZHJvaWQsIHJhaW5zIG9kZFxuSW4gYmV0d2VlbiBkYXlzLCBiYXllZCBlbnR3aW5lXG5Db2RlIGdvbGYsIGNvZCBlbGYgZ290Il0=) to verify the test cases.
Takes inputs as a list of strings.
## Explained
```
ɽȧvs≈
ɽ     # Convert each string to lowercase
 ȧ    # Remove whitespace from each string
  vs  # Sort each string
    ≈ # Are they equal?
```
[Answer]
# [Thunno 2](https://github.com/Thunno/Thunno2), 5 [bytes](https://github.com/Thunno/Thunno2/blob/main/docs/codepage.md)
```
Rw€Ṡạ
```
[Try it online!](https://Not-Thonnu.github.io/run#aGVhZGVyPSZjb2RlPVJ3JUUyJTgyJUFDJUUxJUI5JUEwJUUxJUJBJUExJmZvb3Rlcj0maW5wdXQ9JTVCJTIyTHlubiUyMiUyQyUyMCUyMk55bCUyME4lMjIlNUQlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAtJTNFJTIwMSUwQSU1QiUyMkRpZ2l0YWwlMjBUcmF1bWElMjIlMkMlMjAlMjJUYXUlMjBEaWdpdGFsJTIwQXJtJTIyJTVEJTIwJTIwLSUzRSUyMDElMEElNUIlMjJTcDMwMDAlMjIlMkMlMjAlMjJQJTIwUyUyMDMwMDAlMjIlNUQlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAtJTNFJTIwMSUwQSU1QiUyMk1hbmFnZSUyMFRyYXNoJTIwU28lMjIlMkMlMjAlMjJUaG9zZSUyMGFuYWdyYW1zJTIyJTVEJTIwJTIwLSUzRSUyMDElMEElNUIlMjJDYWx2aW5zJTIwSG9iYmllcyUyMiUyQyUyMCUyMkhlbGthJTIwSG9tYmElMjIlNUQlMjAlMjAlMjAlMjAlMjAtJTNFJTIwMCUwQSU1QiUyMkFuZHJvaWQlMjIlMkMlMjAlMjJyYWlucyUyMG9kZCUyMiU1RCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMC0lM0UlMjAwJTBBJTVCJTIySW4lMjBiZXR3ZWVuJTIwZGF5cyUyMiUyQyUyMCUyMmJheWVkJTIwZW50d2luZSUyMiU1RCUyMCUyMCUyMC0lM0UlMjAwJTBBJTVCJTIyQ29kZSUyMGdvbGYlMjIlMkMlMjAlMjJjb2QlMjBlbGYlMjBnb3QlMjIlNUQlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAtJTNFJTIwMCZmbGFncz1DZQ==)
Input as a list of both strings.
#### Explanation
```
Rw€Ṡạ  # Implicit input
R      # Uppercase the input
 w     # Remove all whitespace
  €Ṡ   # Sort each string
    ạ  # All equal?
       # Implicit output
```
[Answer]
# Ruby, 50 bytes
```
def f;gets.upcase.chars.sort.join.strip;end
p f==f
```
Writing `f=->{...}` and `f[]==f[]` is just as long. :(
[Answer]
## PowerShell, 81 bytes
```
param([char[]]$a,[char[]]$b)-join($a-replace' '|sort)-eq-join($b-replace' '|sort)
```
A slight rewrite of [my answer](https://codegolf.stackexchange.com/a/54496/42963) on the linked Anagram challenge.
Takes input as char-arrays, performs a `-replace` operation to remove spaces, `sort`s them (which sorts alphabetically, not by ASCII value), then `-join`s them back into a string. The `-eq` in PowerShell is by default case-insensitive, but here it must be performed on strings, as `[char]'a'` is not equal to `[char]'A'`, hence the reason for `-join`.
[Answer]
# Perl, 35 bytes
Include +1 for `-p`
Somewhat abusive since it depends on the program being given on the commandline.
```
perl -pe'<>=~s%\S%*_=s/$&//i?_:0%reg;$_=!//'
```
Then give the strings as 2 consecutive lines on STDIN
A very abusive solution is 30 bytes:
```
perl -ne'<>=~s%\w%1/!s/$&//i%reg;1/!//'
```
This crashes if the strings are not anagrams and therefore gives a false exit code from the point of view of the shell. It also gives garbage on STDERR for that case. If the strings are anagrams the program is silent and gives a "true" exit code
]