Finding if two strings are anagrams in O(n) - solution using XOR - c++

Question

I'm working on a problem from hackerearth
The goal is to find if the input strings are anagrams in O(n) time.
Input format:
First line, contains an intger 'T' denoting no. of test cases.
Each test consists of a single line, containing two space separated
strings S1 and S2 of equal length.
My code:
#include <iostream>
#include <string>
int main()
{
int T;
std::cin >> T;
std::cin.ignore();
for(int i = 0; i < T; ++i)
{
std::string testString;
std::getline(std::cin, testString);
char test = ' ';
for (auto& token : testString)
{
if(token != ' ')
test ^= token;
}
if (test == ' ')
std::cout << "YES\n";
else
std::cout << "NO\n";
}
}
The code above fails 5/6 hackerearth tests.
Where is my mistake? Is this a good approach to the problem?

Answer 1

Note: Your question title says that the second word must be an anagram of the first. But, the linked to problem on hackerearth uses the term rearranged, which is more restrictive than an anagram and also says:
Two strings S1 and S2 are said to be identical, if any of the permutation of string S1 is equal to the string S2
One algorithm is to maintain a histogram of the incoming chars.
This is done with two loops, one for the first word and another for the second word.
For the first word, proceed char-by-char and increment the histogram value. Calculate the length of the first word by maintaining a running count.
When the space is reached, do the other loop which decrements the histogram. Maintain a count of the number of histogram cells that reach zero. In the end, this must match the length of the first word (i.e. success).
In the second loop, if a histogram cell goes negative, this is a mismatch because either the second word has a char not in the first word or has too many of a char in the first word.
Caveat: I apologize for this being a C-like solution, but it can easily be adapted to use more STL components
Also, char-at-a-time input may be faster than reading in the entire line into a buffer string
Edit: I've added annotation/comments to the code example to try to make things more clear
#include <stdio.h>
#include <stdlib.h>
char buf[(200 * 1024) + 100];
void
dotest(FILE *xf)
{
int histo[26] = { 0 };
int len = 0;
int chr;
int match = 0;
int fail = 0;
int cnt;
// scan first word
while (1) {
chr = fgetc(xf);
// stop on delimiter between first and second words
if (chr == ' ')
break;
// convert char to histogram index
chr -= 'a';
// increment the histogram cell
cnt = ++histo[chr];
// calculate number of non-zero histogram cells
if (cnt == 1)
++len;
}
// scan second word
while (1) {
chr = fgetc(xf);
// stop on end-of-line or EOF
if (chr == '\n')
break;
if (chr == EOF)
break;
// convert char to histogram index
chr -= 'a';
// decrement the histogram cell
cnt = --histo[chr];
// if the cell reaches zero, we [seemingly] have a match (i.e. the
// number of instances of this char in the second word match the
// number of instances in the first word)
if (cnt == 0)
match += 1;
// however, if we go negative, the second word has too many instances
// of this char to match the first word
if (cnt < 0)
fail = 1;
}
do {
// too many letters in second word that are _not_ in the first word
if (fail)
break;
// the number of times the second word had an exact histogram count
// against the first word must match the number of chars in the first
// [and second] word (i.e. all scrambled chars in the second word had
// a place in the first word)
fail = (match != len);
} while (0);
if (fail)
printf("NO\n");
else
printf("YES\n");
}
// main -- main program
int
main(int argc,char **argv)
{
char *file;
FILE *xf;
--argc;
++argv;
file = *argv;
if (file != NULL)
xf = fopen(file,"r");
else
xf = stdin;
fgets(buf,sizeof(buf),xf);
int tstcnt = atoi(buf);
for (int tstno = 1; tstno <= tstcnt; ++tstno)
dotest(xf);
if (file != NULL)
fclose(xf);
return 0;
}
UPDATE:
I've only had a glance at the code but it seems that len goes up for every char found (string lenght). and match goes up only when a unique char (histogram element) is exausted, so the check match == len will not be good?
len is only incremented in the first loop. (i.e.) It is the length of the first word only (as mentioned in the algorithm description above).
In the first loop, there is a check for the char being a space [which is guaranteed by the problem definition of the input to delimit the end of the first word] and the loop is broken out of at that point [before len is incremented], so len is correct.
The use of len, match, and fail speed things up. Otherwise, at the end, we'd have to scan the entire histogram and ensure all elements are zero to determine success/failure (i.e. any non-zero element means mismatch/failure).
Note: When doing such timed coding challenges before, I've noted that they can be pretty strict on elapsed time/speed and space. It's best to try to optimize as much as possible because, even if the algorithm is technically correct, it can fail the test for using too much memory or taking too much time.
That's why I suggested not using a string buffer because the maximum size as defined by the problem can be 100,000 bytes. Also, doing the [unnecessary] scan of the histogram at the end would also add time.
UPDATE #2:
It may be faster to read a full line at a time and then use a char pointer to traverse the buffer. Here's a version that does that. Which method is faster would need to be tried/benchmarked to see.
#include <stdio.h>
#include <stdlib.h>
char buf[(200 * 1024) + 100];
void
dotest(FILE *xf)
{
char *cp;
int histo[26] = { 0 };
int len = 0;
int chr;
int match = 0;
int fail = 0;
int cnt;
cp = buf;
fgets(cp,sizeof(buf),xf);
// scan first word
for (chr = *cp++; chr != 0; chr = *cp++) {
// stop on delimiter between first and second words
if (chr == ' ')
break;
// convert char to histogram index
chr -= 'a';
// increment the histogram cell
cnt = ++histo[chr];
// calculate number of non-zero histogram cells
if (cnt == 1)
++len;
}
// scan second word
for (chr = *cp++; chr != 0; chr = *cp++) {
// stop on end-of-line
if (chr == '\n')
break;
// convert char to histogram index
chr -= 'a';
// decrement the histogram cell
cnt = --histo[chr];
// if the cell reaches zero, we [seemingly] have a match (i.e. the
// number of instances of this char in the second word match the
// number of instances in the first word)
if (cnt == 0)
match += 1;
// however, if we go negative, the second word has too many instances
// of this char to match the first word
if (cnt < 0) {
fail = 1;
break;
}
}
do {
// too many letters in second word that are _not_ in the first word
if (fail)
break;
// the number of times the second word had an exact histogram count
// against the first word must match the number of chars in the first
// [and second] word (i.e. all scrambled chars in the second word had
// a place in the first word)
fail = (match != len);
} while (0);
if (fail)
printf("NO\n");
else
printf("YES\n");
}
// main -- main program
int
main(int argc,char **argv)
{
char *file;
FILE *xf;
--argc;
++argv;
file = *argv;
if (file != NULL)
xf = fopen(file,"r");
else
xf = stdin;
fgets(buf,sizeof(buf),xf);
int tstcnt = atoi(buf);
for (int tstno = 1; tstno <= tstcnt; ++tstno)
dotest(xf);
if (file != NULL)
fclose(xf);
return 0;
}
UPDATE #3:
The above two examples had a slight bug. It would report a false negative on an input line of (e.g.) aaa aaa.
The increment of len was always done in the first loop. This was incorrect. I've edited the above two examples to do the increment of len conditionally (i.e. only if the histogram cell was zero before the increment). Now, len is "the number of non-zero histogram cells in the first string". This takes into account duplicates in the string (e.g. aa).
As I mentioned, the use of len, match, and fail was to obviate the need to scan all histogram cells at the end, looking for a non-zero cell which means mismatch/failure.
This would [possibly] run faster for short input lines, where the post scan of the histogram took longer than the input line loops.
However, given that input lines can be 200k in length, the probability is that [almost] all of the histogram cells will be incremented/decremented. Also, the post scan of the histogram (e.g. check 26 integer array values for non-zero) is now a negligible part of the overall time.
Thus, the simple implementation [below] that eliminates len/match calculations inside the first two loops may be the fastest/best choice. This is because the two loops are slightly faster.
#include <stdio.h>
#include <stdlib.h>
char buf[(200 * 1024) + 100];
void
dotest(FILE *xf)
{
char *cp;
char buf[(200 * 1024) + 100];
int histo[26] = { 0 };
int chr;
int fail = 0;
cp = buf;
fgets(cp,sizeof(buf),xf);
// scan first word
for (chr = *cp++; chr != 0; chr = *cp++) {
// stop on delimiter between first and second words
if (chr == ' ')
break;
// convert char to histogram index
chr -= 'a';
// increment the histogram cell
++histo[chr];
}
// scan second word
for (chr = *cp++; chr != 0; chr = *cp++) {
// stop on end-of-line
if (chr == '\n')
break;
// convert char to histogram index
chr -= 'a';
// decrement the histogram cell
--histo[chr];
}
// scan histogram
for (int idx = 0; idx < 26; ++idx) {
if (histo[idx]) {
fail = 1;
break;
}
}
if (fail)
printf("NO\n");
else
printf("YES\n");
}
// main -- main program
int
main(int argc,char **argv)
{
char *file;
FILE *xf;
--argc;
++argv;
file = *argv;
if (file != NULL)
xf = fopen(file,"r");
else
xf = stdin;
fgets(buf,sizeof(buf),xf);
int tstcnt = atoi(buf);
for (int tstno = 1; tstno <= tstcnt; ++tstno)
dotest(xf);
if (file != NULL)
fclose(xf);
return 0;
}
The downside is that there is no "early escape" from the second loop. We would have to finish the scan of the second string even though we might be able to tell early that the second string can't match (e.g.):
aaaaaaaaaa baaaaaaaaa
baaaaaaaaa bbaaaaaaaa
With the simple version we couldn't terminate the second loop early even though we know the second string can never match when we see the b (i.e. the histogram cell goes negative) and skip over the scan of the multiple a in the second word.
So, here's a version that has a simple first loop as above. It adds back the on-the-fly check for a cell going negative in the second loop.
Once again, which version [of the four I've presented] is the best needs some experimentation/benchmarking.
#include <stdio.h>
#include <stdlib.h>
char buf[(200 * 1024) + 100];
void
dotest(FILE *xf)
{
char *cp;
int histo[26] = { 0 };
int chr;
int fail = 0;
int cnt;
cp = buf;
fgets(cp,sizeof(buf),xf);
// scan first word
for (chr = *cp++; chr != 0; chr = *cp++) {
// stop on delimiter between first and second words
if (chr == ' ')
break;
// convert char to histogram index
chr -= 'a';
// increment the histogram cell
++histo[chr];
}
// scan second word
for (chr = *cp++; chr != 0; chr = *cp++) {
// stop on end-of-line
if (chr == '\n')
break;
// convert char to histogram index
chr -= 'a';
// decrement the histogram cell
cnt = --histo[chr];
// however, if we go negative, the second word has too many instances
// of this char to match the first word
if (cnt < 0) {
fail = 1;
break;
}
}
do {
// too many letters in second word that are _not_ in the first word
if (fail)
break;
// scan histogram
for (int idx = 0; idx < 26; ++idx) {
if (histo[idx]) {
fail = 1;
break;
}
}
} while (0);
if (fail)
printf("NO\n");
else
printf("YES\n");
}
// main -- main program
int
main(int argc,char **argv)
{
char *file;
FILE *xf;
char buf[100];
--argc;
++argv;
file = *argv;
if (file != NULL)
xf = fopen(file,"r");
else
xf = stdin;
fgets(buf,sizeof(buf),xf);
int tstcnt = atoi(buf);
for (int tstno = 1; tstno <= tstcnt; ++tstno)
dotest(xf);
if (file != NULL)
fclose(xf);
return 0;
}

Answer 2

public static final int ASC = 97;
static boolean isAnagram(String a, String b) {
boolean res = false;
int len = a.length();
if (len != b.length()) {
return res;
}
a = a.toLowerCase();
b = b.toLowerCase();
int[] a_ascii = new int[26];
int aval = 0;
for (int i = 0; i < 2 * len; i++) {
if (i < len) {
aval = a.charAt(i) - ASC;
a_ascii[aval] = (a_ascii[aval] == 0) ? (aval * len + 1) : (a_ascii[aval] + 1);
} else {
aval = b.charAt(i - len) - ASC;
if (a_ascii[aval] == 0) {
return false;
}
a_ascii[aval] = a_ascii[aval] - 1;
res = (a_ascii[aval] == aval * len) ? true : false;
}
}
return res;
}