Ruby (40)

a.unpack('c*').sort==b.unpack('c*').sort 

Another Ruby (46)

(a.size==b.size)&&(a<<b.count(a,b)==a<<b.size) 

APL - 13 chars

{(⍺[⍋⍺])≡⍵[⍋⍵]} 

Call like this:

 'boat' {(⍺[⍋⍺])≡⍵[⍋⍵]} 'baot' 1 'baot' {(⍺[⍋⍺])≡⍵[⍋⍵]} 'boat' 1 (,'a') {(⍺[⍋⍺])≡⍵[⍋⍵]} 'aa' 0 

In the last example, 'a' represents a single character, and the prefix , will convert it into a string.

Java (134 bytes)

int[][]c=new int[2][26]; for(int i=0;i<2;i++)for(byte a:args[i].getBytes())c[i][a-97]++; System.out.print(Arrays.equals(c[0],c[1]));` 

This makes an array to count the number of times each letter appears, and then compares the arrays to check if they are equal.

Perl, 77 75 chars

The I/O of the problem aren't well specified; this reads two lines from stdin and outputs true or false to stdout.

sub p{join'',sort split'',$a}$a=<>;$x=p;$a=<>;print$x eq p()?"true":"false" 

(Thanks to Tim for 77 -> 75)

Brain-Flak, 170 bytes

{({}[(()()()()()){}]<>)<>}<>([]){{}(<>())<>{({}[(((((()()()()()){}){}){})){}])({({})({}[()])()}{}{}())({<({}[()])><>({})<>}{}<><{}>)<>}{}([])}<>({}[{}])((){[()](<{}>)}{}) 

Try it online!

Takes input on two lines.

This program makes a Gödel encoding of letter frequencies in each string. This means I need to map each letter to a unique prime number. For that, I use the polynomial n^2 + n + 41, which is known to give prime results for 0 <= n <= 40. I subtract 90 from the ascii code for each letter before passing it to the polynomial, to get a number in the proper range. When the primes are multiplied together, the results should be equal only when the strings are permutations of each other.

Husk, 2 bytes

€P 

Try it online!

Returns index of the permutation found, or 0.

Haskell, 31 bytes

import Data.List s%t=s\\t==t\\s 

Try it online!

The \\ operator from Data.List is multiset difference. If s and t and anagrams, then s\\t is empty, as is t\\s. However, if any character appears in s more times than in t, then s\\t will contain it whereas t\\s won't, making them unequal, and vice versa is the character appears in t more than s.

36 bytes

(.q).(==).q q=sum.map((9^).fromEnum) 

Try it online!

A shot at an import-less solution. Each string is converted to a base-9 representation of its character counts, and these are checked for equality. The i'th digit base 9 is the number of appearances of the character with fromEnum ASCII value i. This takes advantage of the spec guaranteeing each string is no longer than 9 characters, so there's no rollover in base 9.

39 bytes

s%t=and[q s==q t|q<-filter.(==)<$>s++t] 

Try it online!

A more general solution following the principles of avoiding sorting. Checks that each character in s++t appears as many times in s as it does in t.

Knight, 92 68 bytes

Saved 21 bytes (and indirectly 3 more) thanks to Bubbler

O?C=sB;=wP;=j~9;W=j+1j;=i 8Wi=wI>=bGw i 1=aGw=i-i 1 1wSw i 2+b a wCs 

Try it online!

Explanation

Sorts both strings using a bubble-sort algorithm and checks if they are equal. The sorting algorithm takes advantage of the "input will be ... no longer than 8 chars" rule.

Ungolfed:

;= sort_input BLOCK ;= word PROMPT ;= j ~9 ;WHILE = j (+ 1 j) ;= i 8 :WHILE i := word ;= char2 GET word i 1 ;= char1 GET word (= i (- i 1)) 1 :IF > char2 char1 :word :SUB word i 2 (+ char2 char1) :word :OUTPUT ? (CALL sort_input) (CALL sort_input) 

Knight, 59 52 bytes

O?C=bB;=aP;=x*"0"128;Wa;=xSxAa 1+1GxAa 1=aGa 1La xCb 

Try it online!

For both inputs, it creates a 128-character string of 0s, then iterates through the input and increases the value in the index associated with the ASCII code of the given character. Finally, it compares these strings.

This only works because the input strings are less than 8 characters, meaning there can be at most 8 of a single character (less than the 9 that can be stored in a single index by this encoding).

Expanded code:

;=b BLOCK ;=a PROMPT ;=x *"0" 128 WHILE a ;= x (SET x (ASCII a) 1 (+1 (GET x (ASCII a) 1)) = a (GET a 1 (LENGTH a)) ;CALL b ;=y x ;CALL b OUTPUT (? x y) 

-7 bytes from @Bubbler

Knight, 51 bytes

O?C=cB;=iP;=x*'0'256;Wi;=xSx=aAiT+1Gx aT=iSiF1""xCc 

Try it online!

This challenge was made a lot easier because inputs were length 8 maximum. That way, we could have a string of length 256, where each index is the amount of times that byte appeared in a word. Then, we can just compare them.

Ungolfed and reorganized slightly, with copious comments:

# Create a new block (ie a niladic function) named `char_counts`. ; = char_counts BLOCK # Set `i` to the input from stdin. ; = input PROMPT # Set `x` to a string of 256 `0`s. The number at each # index keeps track of how many times that ascii code # has been seen. ; = counts * '0' 256 # while `input` isn't empty ; WHILE input # Set the variable `ascii_code` to the ascii codepoint # of the first character. If `ASCII` is given a string # that's more than one character long, it uses the first. ; = ascii_code ASCII input # Set the variable `new_count` to one more than the # previous value at `ascii_code` within `counts`. This # will coerce the `GET` result to an integer, which is # a nice added bonus. ; = new_count + 1 (GET counts ascii_code 1) # Update `counts` by replacing the character at `ascii_code` # (or, more precisely, the range `ascii_code..ascii_code+1`) # with the new, updated count. : = counts SET counts ascii_code 1 new_count # The last value of a `BLOCK` is its return value. Here, # we return the occurances of each byte. : counts # Finally, print out whether calling `char_counts` twice # in a row yields the same count of characters. : OUTPUT ? (CALL char_counts) (CALL char_counts) 

JavaScript (67)

function(a,b){return ""+a.split("").sort()==""+b.split("").sort()} 

C function (147 chars), using brute-force

int c(char*x,char*y){int i=0,l=0;for(;y[l]&&x[l];l++);if(y[l]||x[l])return 0; while(*x&&i!=l){for(i=0;i<l&&y[i]!=*x;i++);y[i]=0,x++;}return(i!=l);} 

Ruby (39)

Accepts the input as given in the question. Run with ruby -n.

$ cat t.rb $_=~/, /;p $'.chars.sort==$`.chars.sort $ echo -n "word, wrdo" | ruby -n t.rb true 

Perl - 78 characters[1]

@x=map{join("",sort(split("")))}split(",",<>);print$x[0]eq$x[1]?"true":"false"; 

[1] Unlike some other Perl code above, this actually reads the input in "foo,bar" format and prints "true" or "false". Could be shorter otherwise.

Ruby 1.9 - 32

x=->{gets.chars.sort} p x[]==x[] 

Python 3 (64)

This is not a particularly good golf given how short some of the earlier Python solutions that use sorted() are, but here's a version that uses collections.Counter (an unlovable module from a golfing perspective, but with some neat stuff). It reads two lines from input and outputs True or False. Going with Python 3 versus 2.7 saved 4 chars with input() instead of raw_input(), but lost 1 for the parens for print since it is now a function.

from collections import *;c,i=Counter,input;print(c(i())==c(i())) 

R, 77

f=function(x,y)identical(sort(strsplit(x,"")[[1]]),sort(strsplit(y,"")[[1]])) 

Sample output:

f("boat","boat") [1] TRUE f("toab","boat") [1] TRUE f("oabt","toab") [1] TRUE f("a","aa") [1] FALSE f("zzz","zzzzzzzz") [1] FALSE f("zyyyzzzz","yyzzzzzy") [1] TRUE f("sleepy","pyels") [1] FALSE f("p","p") [1] TRUE 

Matlab: 10 characters without using sort

a*a'==b*b' 

Haskell, 48

Not counting imports, Haskell can do it in 10 chars:

import Data.List import Data.Function on(==)sort 

Called like this:

λ> on(==)sort "balaclava" "aabllcav" False λ> on(==)sort "balaclava" "aabllcava" True 

Julia - 36

f=s->==(map(sort,map(collect,s))...) 

Used as f(["foo", "bar"])

Using a list for calling it kind of feels like cheating though.

43 characters

f=(a,b)->sort(collect(a))==sort(collect(b)) 

Used as f("foo", "bar")

Both solutions just sort the words and compare the result

Woohoo, my first real CodeGolf submission ^_^

Mathcad, 38 chars including non-character keys

s(a):sort(str2vec(a)) f(a,b):s(a)©=s(b) 

© stands for the Ctrl key.

Displayed by Mathcad formatted as:

s(a):=sort(str2vec(a)) f(a,b):=s(a)=s(b) 

Converts the strings to vectors (one-dimensional arrays) of symbols' ASCII values, sorts them, then compares the vectors. Input is supplied to function f. Returns 1 on success and 0 on failure.

Example: f("toab","boat") returns 1

PHP, 44 Bytes

<?=($c=count_chars)($argv[1])==$c($argv[2]); 

Perl, 41 bytes

40 bytes code + 1 for -p.

Since this uses a slightly different trick to the other Perl answers I thought I'd share it. Input is separated by newlines.

@{$.}=sort/./g}{$_="@1"eq"@2"?true:false 

Uses the magic variable $. which tracks the line number to store the words, as character lists, in @1 and @2 which are then compared.

Usage

perl -pe '@{$.}=sort/./g}{$_="@1"eq"@2"?true:false' <<< 'wrdo word' true perl -pe '@{$.}=sort/./g}{$_="@1"eq"@2"?true:false' <<< 'word wwro' false perl -pe '@{$.}=sort/./g}{$_="@1"eq"@2"?true:false' <<< 'boat toba' true 

Try it online.

Python, 151, 89 bytes

Handles arbitrarily many inputs from stdin. Comma separated, one pair per line.

import sys f=sorted for l in sys.stdin:a,b=l.split(',');print f(a.strip())==f(b.strip()) 

Brachylog, 2 bytes

pᵈ 

Try it online!

The p predicate is essentially a declaration that the variables on either side of it are permutations of each other. The ᵈ meta-predicate modifies the predicate to which it is attached to interpret the input variable as a list of two items, which are effectively placed on either side of the predicate (with the output variable being unified with the second element of the input). So, given a pair of strings as input, the predicate pᵈ will succeed if they are anagrams, and fail if they are not.

If anyone's suspicious of the header on TIO, it just goes through the list of test cases and prints a list of "true"/"false" values based on whether the predicate succeeded or failed for each case. The predicate can be run as a standalone program that prints "true." if it succeeds for the single test case it is given and "false." if it fails.

05AB1E, 3 bytes

Aargh! I can't beat GolfScript!

œså 

Try it online!

Explanation

œ All permutations of the first input så Do the permutations contain the second input? 

œQà

œ All permutations Q Equality with input à Maximum 

€{Ë

€{ Map sort over the input list Ë Are all items equal? 

Java 16, 85 bytes

a->b->a.chars().sorted().boxed().toList().equals(b.chars().sorted().boxed().toList()) 

Java 16 added the Stream#toList method.

Java 8, 88 bytes

a->b->java.util.Arrays.equals(a.chars().sorted().toArray(),b.chars().sorted().toArray()) 

Try it online!

Curry, 49 bytes

Tested in PAKCS

e#x=e:x e#(x:y)=x:e#y p(x:y)=x#p y p[]=[] (=:=).p 

Try it online!

Try it on Smap!

This returns True if inputs are anagrams and nothing otherwise.

Explanation

This is a really fun Curry solution. First we define a function p which gives a non-deterministic permutation of the input.

Then our submission is just (=:=).p. Written more normally this is:

f x y = p x =:= y 

Meaning it tries to bind y to a permutation of x. If they are anagrams this succeeds and gives True, if they are not there is no binding and we get nothing.

Pyth 10 7

qFSMczd 

Takes input as two space-separated words.

Try it here.

Essentially, it splits the elements into an array, sorts each element, and checks if the elements are unique.

My first attempt at Code Golf. Any advice appreciated :o)