Jelly, 3 bytes (probably non-competing)

Ṣ€E 

Try it online!

Similar to X88B88's solution, but this takes a list of strings instead of two arguments, like ["String1", "String2"].

Explanation:

Ṣ€ Sort each input E Check equality 

Wolfram Language 26 bytes ( Mathematica )

ContainsAll@@Characters@#& 

Usage:

%@{"BOAT","TOAB"} 

Output:

True

J, 8 bytes

-:&(/:~) 

Match -: after sorting /:~ both args &.

Try it online!

Axiom, 45 bytes

f(a:String,b:String):Boolean==sort(a)=sort(b) 

Perl 5, 27 + 3 (-lF) = 30 bytes

@{$.}=sort@F}{say"@1"eq"@2" 

Try it online!

Pyth, 4 bytes

_ISM 

Try it Online

Explanation

_ISM SMQ Sort both (implicit) inputs. _I Check if the result is invariant under reversing. 

Lua, 140 chars

t={io.read():match"(%w+), (%w+)"}T=table for k=1,2 do w={t[k]:byte(1,-1)}T.sort(w)t[k]=T.concat{string.char(unpack(w))}end print(t[1]==t[2]) 

... like driving a screw with a light weight hammer, at least for code-golfing

Python 2, 79 bytes

I thought I would add a different Python approach:

import sys for l in sys.stdin: not reduce(cmp,map(sorted,l.strip().split(','))) 

Or as a function:

def f(*v): return not reduce(cmp,map(sorted,v)) 

Scala, 84 characters

object A{def main(a: Array[String]){println(a(0).sortWith(_<_)==a(1).sortWith(_<_))}} 

This one's slightly longer, but doesn't use sorting (92 characters):

object A{def main(a:Array[String]){print((a(0)diff a(1)).isEmpty&&(a(1)diff a(0)).isEmpty)}} 

Common Lisp, 50 bytes

(lambda(a b)(string=(sort a'char<)(sort b'char<))) 

Try it online!

Japt, 10 9 5 4 bytes

á øV 

Try it

á øV :Implicit input of strings U & V á :Permutations of U øV :Contains V? 

SmileBASIC, 49 bytes

INPUT A$,B$WHILE""<A$B$[INSTR(B$,POP(A$))]=" WEND 

Throws an error when the strings aren't anagrams.

Symja, 26 bytes

f(x_,y_):=Sort(x)==Sort(y) 

Try It Online!

Try With Changeable Tests

Assumes strings are given as a list of characters.

PHP7.4 (45 chars)

The function $f will return the answer using count_chars :

$f=fn($a,$b)=>($x='count_chars')($a)==$x($b); 

Try it Online - in PHP4 the XOR cipher passes all tests using 48 chars :

function f($a,$b){return$a==chop($a.$b^$b^$b);}; 

C gcc (69 chars)

The function f compute the product of both string and implicitly return the comparison :

i;j;f(char*a,char*b){i=j=1;for(;*a;i*=*a++);for(;*b;j*=*b++);a=i==j;} 

Try it Online

C version isn't shaved up to 65 chars by XOR cipher due to some ae == bf misses :

i;f(char*a,char*b){i=1;for(;*a;i^=*a++);for(;*b;i^=*b++);a=i==1;} 

Julia, 26 bytes

!a=sort([a...]) a\b=!a==!b 

Try it online!

C - 115 Bytes

a[127],b[127],i,o=1;f(char*s,char*z){for(;*s;a[*s++]++);for(;*z;b[*z++]++);for(;i++<128&&o;o=a[i]==b[i]);return o;} 

Ungolfed

a[127], b[127], i, o = 1; f(char* s, char* z) { for(; *s; a[*s++]++); for(; *z; b[*z++]++); for(; i++ < 128 && o; o = a[i] == b[i]); return o; } 

Alternative way (By @ceilingcat)

*a,*b,i,o;f(char*s,char*z){for(a=calloc(i=128,8);*s;a[*s++]++);for(b=a+i;*z;b[*z++]++);for(;i--&&(o=a[i]==b[i]););return o;} 

Explanation

A function that receives two ASCII character strings with arbitrary length and checks if one is an anagram of the other.

To accomplish this, both entire strings are iterated over and the number of matches for each character is stored in a list for each string; later it is checked if both lists have the same number of matches, if so, then the strings are anagrams and true (1) is returned, otherwise false (0) is returned.

TI-Basic, 83 bytes

Prompt Str1,Str2 "seq(inString(Str1+Str2,sub(Ans,I,1)),I,1,length(Ans→u Str1 u→A SortA(ʟA Str2 u→B SortA(ʟB 0 If dim(ʟA)=dim(ʟB min(ʟA=ʟB Ans 

Output is stored in Ans and displayed. Outputs 1 if the inputs are anagrams, otherwise 0.

Alice, 11 bytes

/@Mn/ \MOX\ 

Try it online!

Prints Jabberwocky if the two words are anagrams

Flattened

MM Reads the two arguments X Compute their symmetric difference n Empty string becomes Jabberwocky, anything else becomes empty string O Print it out @ Bye 

R, 47 bytes

\(x,y)all(table(strsplit(paste0(x,y),""))%%2==0) 

BQN, 3 bytes

≡○∧ 

Anonymous tacit function that takes two strings; returns 1 if they are anagrams, 0 otherwise. Try it at BQN online!

Explanation

≡ Are the strings identical ○ when both of them ∧ are sorted? 

Nekomata + -e, 2 bytes

↕= 

Attempt This Online!

↕ Check if any permutation of the first string = is equal to the second string 

Labyrinth, 23 bytes

1 ,:# * 0 1;/----+}=-!@ 

Try it online!

Takes two words separated by a newline. For each word, computes the product of c * 10 + 1 for each char c, and compares the two values. Prints 0 for true and a nonzero integer for false.

Such product is unique for lowercase words up to permutation, since the counts of 25 out of 26 letters can be recovered from the exponents of 25 unique prime factors:

971 is prime 981 = 109 * 3 * 3 991 is prime 1001 = 7 * 11 * 13 (no unique prime factor) 1011 = 337 * 3 1021 is prime 1031 is prime 1041 = 347 * 3 1051 is prime 1061 is prime 1071 = 17 * 7 * 3 * 3 1081 = 47 * 23 1091 is prime 1101 = 367 * 3 1111 = 101 * 11 1121 = 59 * 19 1131 = 29 * 13 * 3 1141 = 163 * 7 1151 is prime 1161 = 43 * 3 * 3 * 3 1171 is prime 1181 is prime 1191 = 397 * 3 1201 is prime 1211 = 173 * 7 1221 = 37 * 11 * 3 

Therefore this approach works for arbitrary length inputs.

Since a lowercase letter has value of 97 or higher, the newline has value 10, and -1 is pushed on EOF, a three-way branch is possible via dividing the input value by any number between 11 and 97 inclusive.

By a little bit of planetary alignment, letting the IP reflect on newline (instead of creating a 4-way junction) magically sets up the stack for the second word. This part works because the words are guaranteed to be nonempty.

1 push 1 on empty stack ,:# loop: compute the value of word1 until newline * 0 ,: getchar, dup [word1 c c] 1;/ #0/ divide by 30 [word1 c c/30] if positive: ;1* drop, multiply 10c+1 [word1'] if zero: reflect 1 [word1 10 0] ,:# 0#: push some garbage [word1 10 0 3 3] 0 , getchar (1st char of word2) 1 times 10 plus 1 [word1 10 0 3 3 word2] enter the loop again to compute the value of word2 same flow as first loop, except that # gives 8 and IP turns left on EOF [word1 10 0 3 3 word2 -1 -1] ----+}=-!@ clean up the stack and compare word1 and word2 ----+ [word1 10 word2] }= [word1 word2 | 10] -!@ print the difference and halt 

JavaScript (Node.js), 37 ³⁸ bytes

-1 byte thanks to emanresu A

Here is a more up-to-date JS answer.

a=>b=>(g=x=>[...x].sort()+0)(a)==g(b) 

Try it online!

TinyAPL, 3 bytes

≡⍥⊵ 

Try it: TinyAPL repl

Explanation: Match ≡ over ⍥ sort ⊵

Regex (.NET), 74 73 bytes

^(.)* ((.)(?<=(?=\3(?<-4>.*?(?<1>\4))*)(?<-1>\1.*(?=(.)?))* .*))*$(?(1)^) 

Try it online! - test cases
Try it on regex101 - try it on your own

This uses a completely different algorithm than my other answer which includes a 70 66 byte .NET version. Like it, this takes the input strings delimited by newline, and works even with zero-length words.

Simply put, it pushes each letter of the first word onto a stack, then goes through each letter of the second word, removing a matching letter from the stack. Iff that completes successfully, and the stack ends up empty, then the two words are anagrams of each other.

What complicates this is that it's a stack, not a random-access array, so to find a matching letter in it, the letters above it need to be moved to a temporary stack, then moved back after the matching letter has been removed.

When interpreting the explanation below, remember that lookbehinds in .NET are evaluated from right to left – so read those from bottom to top, one quantified token at a time. When entering a lookahead inside a lookbehind, go back to reading from top to bottom.

^ # Go to beginning of first word (.)* # Push each letter of first word onto \1 stack ¶ # Go to beginning of second word ( # Begin main loop (.) # \3 = next letter from second word (?<= # Lookbehind (?= # Lookahead \3 # Assert that the last letter popped from the \1 # stack matches \3 (which may make the (?<-1>...) # loop backtrack), and skip it # Transfer \4 stack back onto \1 stack in original order (?<-4> # Pop a letter from the \4 stack as many times as # can be done, each time doing the following: .*? # Skip letters that have already been removed from # the stack in this pass or previous passes (?<1>\4) # Push the letter from \4 back onto the \1 stack )* ) (?<-1> # Pop a letter from the \1 stack as many times as # can be done, each time doing the following: \1 # Match and consume the letter from the \1 stack .* # Skip letters that have already been removed from # the stack in previous passes (?=(.)?) # Push the last letter removed from the \1 stack # onto the \4 stack )* ¶.* # Skip back to the end of the first word ) )* # End main loop $ # Assert end of second word has been reached (?(1)^) # Assert \1 stack has been emptied 

J-uby, 17 14 bytes

(A|:sort)**:== 

Attempt This Online! (Uses the working ** operator from an older version of J-uby.)

Vyxal 3 -l, 2 (literate) bytes

permutations contains 

Vyxal It Online!

Performs literally what it says

C# 118 chars

using System.Linq;namespace A{class P{static void Main(string[] a){System.Console.Write(!a[0].Except(a[1]).Any());}}} 

Readable:

using System.Linq; namespace A { class P { static void Main(string[] a) { System.Console.Write(!a[0].Except(a[1]).Any()); } } } 

C#

bool IsJumbledPair(string a, string b) { if(a.Length!=b.Length) return false; foreach(char c in a.ToCharArray()) { int i = b.IndexOf(c); if(i<0) return false; b = b.Remove(i,1) } return (b.Length==0); } 

Readable, and does not require sorting.

Another method:

bool IsJumbledPair(string a, string b) { string c; while { if(a.Length!=b.Length) return false; if(a.Length==0) return true; c = a.Chars(0).ToString(); b = b.Replace(c, ""); a = a.Replace(c, ""); } } 

The above version works better when the strings contain a number of duplicated characters, as each distinct character is only compared once using the relatively fast Replace() method.

VB.NET

Same as the first C# example, slightly simpler using Replace() method, but doesn't short-cut like the C# version:

Function IsJumbledPair(a As String, b As String) As Boolean If a.Length <> b.Length Then Return false For Each(c As Char In a.ToCharArray()) b = Replace(b, c.ToString(), "", 1, 1) Next Return (b.Length=0) } 

F# (59 chars)

let f a b=(Seq.sort>>Seq.toArray)a=(Seq.sort>>Seq.toArray)b 

Very annyoying that sequences can' be directly compared.