Determine whether strings are anagrams

Question

Challenge

Given two strings, work out if they both have exactly the same characters in them.

Example

Input

word, wrdo

This returns true because they are the same but just scrambled.

Input

word, wwro

This returns false.

Input

boat, toba

This returns true

Rules

Here are the rules!

• Assume input will be at least 1 char long, and no longer than 8 chars.
• No special characters, only a–z
• All inputs can be assumed to be lowercase

Test Cases

boat, boat = true
toab, boat = true
oabt, toab = true
a, aa = false
zzz, zzzzzzzz = false
zyyyzzzz, yyzzzzzy = true
sleepy, pyels = false
p,p = true

Answer 1

Python, 32 bytes

f=lambda a,b,S=sorted:S(a)==S(b)

Answer 2

Golfscript, 3 chars?

$$=

usage:

'boat'$'baot'$=
1

'toab'$'boat'$=
1

'oabt'$'toab'$=
1

'a'$'aa'$=
0

'zzz'$'zzzzzzzz'$=
0

'zyyyzzzz'$'yyzzzzzy'$=
1

'sleepy'$'pyels'$=
0

'p'$'p'$=
1

Answer 3

J, 8

-:&(/:~)

Literaly, match (-:) on (&) sort up (/:~)

Sample use:

   'boat' -:&(/:~) 'boat'
1
   'toab' -:&(/:~) 'boat'
1
   'oabt' -:&(/:~) 'toab'
1
   'a' -:&(/:~) 'aa'
0
   'zzz' -:&(/:~) 'zzzzzzzz'
0
   'zyyyzzzz' -:&(/:~) 'yyzzzzzy'
1
   'sleepy' -:&(/:~) 'pyels'
0
   'p' -:&(/:~) 'p'
1

Where do the 64-bit integers come into play?

Answer 4

Javascript, 192 157 152 147 125 bytes

Ok some of these languages are a lot more flexibile than I thought! Anyway this is the longer way I guess, but a different technique at least.

Compressed

Thanks to Peter and David for squeezing more chars out!

for(a=[j=p=2];j<123;)a[j]?p%a[++j]<1&&p++&&(j=0):(a[j]=p,j=0);function b(c,i){return c[i=i||0]?a[c.charCodeAt(i)]*b(c,++i):1}

Then do:

alert(b("hello")==b("elloh"));

Expanded Code

The compressed has had lots of changes, but this is the basic theory:

// Define dictionary of primes
a = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101];

// Returns the unique ID of the word (order irrelevant)
function b(c) {
    r = 1;
    for (i = 0; i < c.length; i++)
        r *= a[c[i].charCodeAt(0) - 97];
    return r
}

alert(b("hello") == b("hlleo"));

Answer 5

Golfscript, 8 bytes

This defines a function called A

{$\$=}:A

Test cases

;
'boat' 'boat' A
'toab' 'boat' A
'oabt' 'toab' A
'a' 'aa' A
'zzz' 'zzzzzzzz' A
'zyyyzzzz' 'yyzzzzzy' A
'sleepy' 'pyels' A
'p' 'p' A

Answer 6

Haskell, 31 bytes

function - 31

import List
f=(.sort).(==).sort

program - 81 58 55

import List
g=sort`fmap`getLine
main=(`fmap`g).(==)=<<g

Usage:

$ runghc anagram.hs
boat
boat
True
$ runghc anagram.hs
toab
boat
True
$ runghc anagram.hs
a
aa
False

Kudos to lambdabot and its pointfree refactoring.

Answer 7

C#, 129 chars

namespace System.Linq{class X{static void Main(string[]a){Console.Write(a[0].OrderBy(_=>_).SequenceEqual(a[1].OrderBy(_=>_)));}}}

Readable:

namespace System.Linq
{
    class X
    {
        static void Main(string[] a)
        {
            Console.Write(a[0].OrderBy(_ => _)
                  .SequenceEqual(a[1].OrderBy(_ => _)));
        }
    }
}

Answer 8

Ruby, 34 bytes

Using the IO scheme of Peter Taylors Perl solution:

p gets.chars.sort==gets.chars.sort

Answer 9

C program, 118

t[52],i;main(c){for(;i<52;)(c=getchar())<11?i+=26:t[i+c-97]++;
for(i=27;--i&&t[i-1]==t[i+25];);puts(i?"false":"true");}

Answer 10

JavaScript

Based on @zzzzBov's solution.

Comparison, 65 chars (40 without function)

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

Comparator, 43 chars

function f(a){return a.split('').sort()+""}

Answer 11

Perl, 58 bytes

(complete program, unlike the other Perl answer which is only a function)

($c,$d)=map{[sort split//]}<>;print"@$c"eq"@$d"?true:false

49 as a function

sub f{($c,$d)=map{[sort split//]}<>;"@$c"eq"@$d"}

Answer 12

R, 54 bytes

function(x,y,`~`=sort,`+`=utf8ToInt)identical(~+x,~+y)

Try it online!

Answer 13

Clojure - 23 chars

As an anonymous function:

#(apply = (map sort %))

Test case example:

(#(apply = (map sort %)) ["boat" "boat"])
=> true

Answer 14

C++ (104 non-ws chars)

Based on counting sort. Note: Assumes strings of the same length, which seems to be implied (though not stated) by the question.

int u[123], i;

int a(char **c) {
    for(; c[0][i]; ) {
        u[c[0][i]]++;
        u[c[1][i++]]--;
    }

    i=123;
    while(i && !u[--i]);
    return !i;
}

Answer 15

APL, 2 chars

≡⍦

This is the Multiset Match function from Nars2000, one of the leading-edge APL implementations. When applied to strings, it computes exactly the function required:

      'elvis' ≡⍦ 'lives'
1
      'alec guinness' ≡⍦ 'genuine class'
1

Answer 16

05AB1E, 6 4 bytes

{I{Q

Try it online!

This took a while because of input difficulties. Golfed down due to pop.

Explanation:

{I{Q    Original code

{       Takes first input e.g. word and sorts -> 'dorw'
 I      Takes second input e.g. 'wrdo'
  {     Sorts second input -> 'dorw'
   Q    Compare if sorted 1 = sorted 2, then print result. 'dorw' = 'dorw', so prints 1.

Answer 17

Perl, 62 bytes

This function takes the strings as arguments and returns true or false.

sub f{my@a;for$.(1,-1){$a[ord]+=$.for split//,pop}!grep{$_}@a}

Stores the ASCII values in an array and checks if it evens out. Increments for the first word and decrements for the second word.

Answer 18

Knight, 112 bytes

;=dF;C=mB;=a 123W<96=a-a 1Id=d!E+"a"aE++"=a"a" 0";=w"+1a";C=lB;=bP:Wb;E++"=a"Ab+wAb=bGb 1Lb;=w"+~1a";Cl;=dT;CmOd

Try it online!

Knight doesn't have arrays. It does have strings, but it only allows a subset of valid ASCII character codes. So I emulated an array by constructing strings that looks like "=a{charcode} 0" and evaling it.

Knight also has blocks. A block works like a niladic function, which can change its behavior depending on global variables. This code uses two blocks: m loops over all 26 variables a97 - a122 initializing or testing something, and l handles the part of taking input and iterating over its chars to count occurrences.

; = d F                  d = False
; C = m B                define and run block m:
  ; = a 123                a = 123
  : W < 96 = a - a 1       while 96 < (a = a - 1):
    I d                      if d:
      = d ! E + "a" a          d = ! eval("a" + a)
      E + + "=a" a " 0"      else: eval("=a" + a + " 0") (aNN = 0)
                         i.e. d is false on start, so initialize all of a97..a122 to 0
; = w "+1a"              w = "+1a" (which is necessary to run l)
; C = l B                define and run block l:
  ; = b P                  b = one line of input
  : W b                    while b is not empty:
    ; E +                    eval(concatenation of
          + "=a" A b           "=aNN"
          + w A b              w+"NN") (aNN = 1 + aNN)
                             (w = "+~1a" changes this to aNN = -1 + aNN)
    : = b G b 1 L b          b = b[1:length(b)]
                         i.e. count occurrences of chars in the first line
; = w "+~1a"             w = "+~1a"
; C l                    run block l i.e. count negative occurrences in the second line
; = d T                  d = True
; C m                    run block m
                         for each of a122..a97, check if aNN is zero
                         if true, keep checking; otherwise do useless thing
: O d                    print d

Answer 19

PHP (command line, 87 characters)

function d($s){
    return array_count_values(str_split($s));
}

echo d($argv[1]) == d($argv[2]);

Answer 20

Javascript

A (very) slightly shorter version of @zzzzBov's solution, that uses .join() instead of String boxing:

function a(b,c){return b.split('').sort().join()==c.split('').sort().join()}
alert(a('abc','bca')); //true

Similarly:

function a(b){return b.split('').sort().join()}
alert(a('abc')==a('bca')); //true

Answer 21

Clojure REPL 41 chars

(= (sort (read-line)) (sort (read-line)))

Answer 22

Java

(everyone's favorite language apparently!)

173 chars:

import java.util.*;class g{public static void main(String[]p){String[]a=p[0].split(""),b=p[1].split("");Arrays.sort(a);Arrays.sort(b);System.out.print(Arrays.equals(a,b));}}

(Doesn't print newline char to save 2 chars from println)

Compile and run:

javac g.java
java -cp . g abcdef fedcba
true

Love to see a shorter one...

Answer 23

Scala in REPL (32)

readLine.sorted==readLine.sorted

Scala function (43)

def f(a:String,b:String)=a.sorted==b.sorted

Scala program (61)

object A extends App{println(args(0).sorted==args(1).sorted)}

These leverage a neat feature of Scala whereby a String can also be treated as a sequence of characters (Seq), with all the operations on Seq being available.

Answer 24

sed, 45 chars

It's even possible in my favourite - sed! Just one regular expression to solve the anagram! Just keep removing the corresponding letters:

:
s/(.)(.*,.*)\1/\2/
t
/\w/{i\false
d}
i\true

(to be invoked with -nE)

Perl, 48

1while s/(.)(.*,.*)\1/\2/;$_=/\w/?"false":"true"

To be invoked with -p.

Perl function, 39

sub f{$,while s/(.)(.*,.*)\1/\2/;!/\w/}

Answer 25

Python 3, 107 97 76 64

s=sorted;a,b=input().split(', ')
print(str(s(a)==s(b)).lower())

Obviously this can be shortened if we don't take the OP's wording literally and lowercase "true" and "false"...

Answer 26

JavaScript, 41

Comparison function (41):

a=b=>''+[...b].sort()
b=(c,d)=>a(c)==a(d)

alert(b('abc', 'cba')) // true

Comparator function (21):

a=b=>''+[...b].sort()

alert(a('abc') == a('bca')); //true

Comparator function (48):

function a(b){return String(b.split('').sort())}

alert(a('abc')==a('bca')); //true

Comparison function (78):

function a(b,c){return String(b.split('').sort())==String(c.split('').sort())}

alert(a('abc','bca')); //true

Assumes String has split and Array has sort.

Answer 27

Python, 32 bytes

p=sorted
f=lambda a,b:p(a)==p(b)

Answer 28

Bash, 88 characters

diff <(grep -o .<<<$1|sort) <(grep -o .<<<$2|sort)>/dev/null && echo true || echo false

Answer 29

Regex (PCRE), 65 bytes

^((?=(.))(?!(.*?\2(?=.*
(\4?+.*?\2)))*+.*\2)(?=.*
(\5?+.)).)*
\5$

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

Takes the input strings delimited by newline.

This asserts that both:

• For each character in the first string, the second string contains that character at least as many times as it occurs in the first string
• The second string is equal in length to the first

^              # Assert that we're starting at the beginning of the first word.
(
    (?=(.))    # Match and capture a character in \2, without consuming it.
    # Assert that the second has at least as many occurrences of \2 as there
    # are subsequent occurrences of it in the first word (including the one we
    # just captured above).
    (?! # Negative lookahead - assert the following can't match, and also
        # conveniently erase whatever capture groups it creates when finished.
        (
            .*?\2     # Match up to the next occurrence of \2 in the first word
                      # (which will be the first one when this loop starts)
            (?=
                .*¶           # Skip to the second word.
                (             # \4 = the following:
                    \4?+      # previous value of \4, if any
                    .*?\2     # Match up to the first subsequent occurrence of
                              # \2 in the second word (which will be the first
                              # occurrence when this loop starts)
                )
            )
        )*+           # Loop the above possessively, locking in each iteration
                      # atomically as it matches.
        .*\2          # Assert \2 occurs again in the first word.
    )
    # Append one more character from the second word onto \5, building up \5
    # to have the same number of characters of the second word as characters
    # we have finished processing in the first word.
    (?=
        .*¶           # Skip to the second word.
        (             # \5 = the following:
            \5?+      # Previous value of \5, if any
            .         # One additional character
        )
    )
    .          # Skip over the \2 just processed in the first word.
)*             # Iterate the above as many times as possible.
¶              # Assert we've reached a newline, meaning we've processed the
               # entire first word, and advance to the second word.
\5$            # Assert that the second word is of equal length to the first.

It only takes +1 byte (66 bytes) to add support for zero-length words:

^((?=(.))(?!(.*?\2(?=.*
(\4?+.*?\2)))*+.*\2)(?=.*
(\5?+.)).)*
\5?$

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

Regex (.NET), 70 66 62 bytes

^(((.))(?=(?>(?<2>\2)|.)*
((?<-2>\2)|.)*$(?(2)^)))*
(?<-3>.)*$

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

This asserts that both:

• For each character in the first string, the second string contains that character at least as many times as it occurs in the first string
• The second string is not longer than the first

Although it is not required, this works even with zero-length words (for free; there is no golf sacrifice in doing so).

^              # Assert that we're starting at the beginning of the first word.
(
    ((.))      # Consume a character and capture it in both \2 and \3.
    
    # Assert that the second word has at least as many occurrences of \2 as
    # there are subsequent occurrences of it in the first word (including the
    # occurrence we just consumed). This only needs to be asserted for the first
    # occurrence of each character in the first word (because on each subsequent
    # occurrence, the count of subsequent occurrences will be one fewer than
    # before) but for golf reasons, it's harmless to do it for every occurrence.
    
    (?=               # Atomic lookahead
        # Step 1: Push every subsequent occurrence of \2 onto the \2 stack.
        (?>           # Atomic group - prevent backtracking from changing what's
                      # done inside it once it's been done.
                      # For each subsequent character in the first word:
            (?<2>\2)  # If it matches \2, push another copy of it onto the
                      # \2 stack, and consume the character.
        |        # or
            .         # Consume the character.
        )*            # Iterate the above as many times as possible.
        ¶             # Consume the newline to begin reading the second word,
                      # preventing the number of loop iterations in the above
                      # loop from being backtracked.
    
        # Step 2: Assert that the second word has at least as many occurrences
        # of \2 as were counted above.
        (             # For each character in the second word:
            (?<-2>\2) # If it matches \2, pop it off the \2 stack, and consume
                      # the character.
        |        # or
            .         # Consume the character.
        )*$           # Iterate the above until reaching end of string.
        (?(2)^)       # Assert that the \2 stack is empty.
    )
)*             # Iterate the above as many times as possible.
¶              # Assert we've reached a newline; advance to the second word.
(?<-3>.)*$     # Assert that this word is not longer than the first word, by
               # popping every capture from the \3 stack and matching one
               # character of the second word (it doesn't have to match \3)
               # for each.

Regex (Perl _{^{/ PCRE}}), 71 bytes

^((?=(.))(?4)(?=.*
(\3?+.)).)*
\3$((?!(.*?\2(?=.*
(\6?+.*?\2)))*+.*\2))

Try it online! - Perl
Try it online! - PCRE2

Perl doesn't erase capture groups upon exiting from a negative lookahead. For compatibility with it, this version uses a subroutine call (?4) instead of a negative lookahead to erase the necessary capture group. The subroutine is then executed again, harmlessly, after the regex finishes and reaches the end of the string (for golf reasons, it is not hidden in a (?(DEFINE)...) block or similar construct).

Regex (_{^{PCRE / .NET}}), 74 bytes

^((?=(.))(?!(?>(.*?\2(?=.*
((?>\4?).*?\2)))*).*\2)(?=.*
((?>\5?).)).)*
\5$

Try it online! - PCRE2
Try it online! - .NET

This is the PCRE version ported to be compatible with .NET, replacing possessive quantifiers with atomic groups.

Regex (_{^{PCRE /}} Ruby), 87 bytes

^((?=(.))(?!(.*?\2(?=.*
(\5?+.*?\2))(?=.*
(\4)))*+.*\2)(?=.*
(\7?+.))(?=.*
(\6)).)*
\6?$

Try it online! - PCRE
Try it online! - Ruby

This is a port of the 65 byte PCRE version, using back-and-forth copying of \4↔\5 and \6↔\7 to avoid use of nested backreferences, which aren't supported by Ruby.

For a reason I have yet to determine, this doesn't work on Python^regex, even its latest version.

Regex (_{^{Perl / PCRE / Ruby / .NET}}), 147 bytes

^((?=(.))(?!(?>(.*?\2(?=((?!.*\2)|.))(?=.*
((?!.*$\4)(?>\6?).*?\2|(?=.*$\4)(?=(?>\6?).*?\2)))(?=.*
(\5)))*).*\2)(?=.*
((?>\8?).))(?=.*
(\7)).)*
\7$

Try it online! - Perl
Try it online! - PCRE2
Try it online! - Ruby
Try it online! - .NET

This is a rather interesting challenge for writing a regex polyglot.

Supporting both Perl and Ruby/.NET is rather difficult. The problem is finding a way to erase the capture group that is created inside a negative lookahead in the PCRE version. Erasing capture groups in situations like this can be a challenge, and to support this combination of regex engines, we can't use negative lookahead (Perl doesn't erase it), a subroutine call (because Ruby's syntax is incompatible with Perl, and .NET doesn't have them), a branch reset group (neither Ruby nor .NET support them), or capture group aliasing or explicit erasure (only .NET has those).

So we must signal to the place where the capture is normally made, to erase it when it needs to be erased. The method I settled upon here is rather convoluted, but it works. (It would be shorter with a lookaround conditional, but we can't use one, as Ruby doesn't have them, and .NET's syntax for them is different.) This post is already pretty long, so here's a link to the commented version.

Answer 30

VBScript

172 characters

wscript.echo "boat, boat         = " & s("boat, boat")
wscript.echo "toab, boat         = " & s("toab, boat")
wscript.echo "oabt, toab         = " & s("oabt, toab")
wscript.echo "a, aa              = " & s("a, aa")
wscript.echo "zzz, zzzzzzzz      = " & s("zzz, zzzzzzzz")
wscript.echo "zyyyzzzz, yyzzzzzy = " & s("zyyyzzzz, yyzzzzzy")
wscript.echo "sleepy, pyels      = " & s("sleepy, pyels")
wscript.echo "p,p                = " & s("p,p")

function s(a):b=split(replace(a," ",""),","):c=0:for x=1 to len(b(0)):if instr(b(1),mid(b(0),x,1)) then c=c+1 
next:if len(b(1))-c=0 then s=true else s=false
end function

I was kinda suprised I could get it under 200.