anagram program help

i need to write a program that takes two strings of at most a length of 500, and outputs whether or not they are anagrams

Example of an anagram :
Tom Marvolo Riddle
I am Lord Voldemort


i'm not sure how i would go about doing this. do i need to see if both strings equal each other as far as letters go? how would i even accomplish that?

Quote:

---

i'm not sure how i would go about doing this.

---

well there's your problem. you haven't identified what you need to do!

what makes an anagram?

the same quantity of the same letters...

You need to keep a count every character (except blanks) and ignore case.

Each letter in the first string (except spaces) should have exactly one counterpart in the second string (keeping in mind that a letter can be repeated in a word).

So, you could loop through each letter in the first string, then loop through each letter in the second string until you get a match, making sure you don't count the same letter twice from the second string.

To satisfy case insensitivity, you can just make both strings all lowercase.

Write an http client that feeds an anagram web server and parses the results.

Just kidding. The others have given you a good start. Post your first attempt at code when you are ready.

Sort both strings, then check if they are equal.

Quote:

---

Originally Posted by brewbuck

Sort both strings, then check if they are equal.

---

Clever, but don't forget to remove all spaces first.

I just wrote one to add up the non-blank, lowercase value of each ascii character in each string. Works great. 20 lines of code.

;)

Todd

I did something simmilar way back, hope it helps:

Quote:

---

INPUT FILES - space counts as character

input.txt - Anagrams
3
ant
4
t an


input1.txt - Anagrams
3
ant
3
tan


input2.txt - NOT Anagrams
3
ast
3
tan


input3.txt - Empty File - Recive Error Message


input4.txt - Anagrams
14
do your own
13
word on you


input5.txt - NOT Anagrams
14
do your own
13
word on yyu


input6.txt - NOT Anagrams
14
do your own


input7.txt - NOT Anagrams
40
The quick brown fox jumps over a lazy do
41
The quick brown fox jumps over a lay dog.


input8.txt - NOT Anagrams
4
clasp
5
scalp


input9.txt - NOT Anagrams
3
3
tan

---

Code:

---

#include <fstream>
#include <iostream>
#include <stdlib.h>
#include <string>
#include <vector>
#include <sstream>
#include <algorithm>



using namespace std;


//functions prototypes
void make_upcase (string input_string[] , int size , int count) ; // converts letters to upper case
int count_words ( int string_number , string input_string[]) ; // counts words on a line
bool are_anagrams (string input_string[] , int string_lenght[] , int position);
void swap (char &first_char , char &next_char);

////////////////////////////////////////////////////////////////////////////////

int main()
{
    ifstream input_data;
    input_data.open ("input.txt");
    if (! input_data) // File was no found
    {
          cout << "File \"input.txt\" not found" << endl << endl;
          system ("pause");
          exit(1);
    }
    else // File was found
    {
          cout << "File \"input.txt\" found" <<  endl;
          int temp_num;  // temporary int for storing number of chars
          int size = temp_num; // size of input string
          int count = 0; // counter for loop

          // read data from file and move it to the input_string dynamic array
          string * input_string = new string [size] ; // dynamic allocated array
         
          cout << "This file looks like:"  << endl;
         
          while (!input_data.eof())
          {
              getline(input_data, input_string [count] ) ; 
              cout << input_string[count] << endl;  // show original input file
              count ++;
          } // end while loop
         
        input_data.close(); // close ifstream

        if (count == 1)  //File is empty
        {
              cout << "File \"input.txt\" is empty" << endl << endl;
              system ("pause");
              exit(1);
        }  // end if
 
        // splitt array --- take numbers and put it into new array 
        int * string_lenght = new int[size];
        int convert;
        for ( int i = 0 , j = 0; i < count ; i+=2)
        {       
            convert = atoi(input_string[i].c_str()); // c_str() converts
                                                          // string into char[]
                                                          // atoi converts
                                                          // char[] into int
            string_lenght[j] = convert; // moves numbers form input_num array
                                        // to string_lenght array
            j++;
            convert++;
        } // end for loop
 
        cout << endl << endl;
 
        // function calls
 
        // function to convert letters to upper case
        make_upcase (input_string , size , count) ;
        // precondition: input_string ia s array of strings from input.txt file,
        //              where each element is a single word. Size is the size
        //              of array. Count is the number of lines in file 
        // postcondition: letters are converted to upper case

        // ****************************************************************** //

        // function to count number of words in each sentence function is called
        // only for odd elements of input_string since the even represent count
        for ( int string_number = 1  ; string_number < count ; string_number+=2)
        {
            int num =  count_words (  string_number , input_string) ;
            // precondition: string_number is number of string (only odd)
            //              input_string is a array of strings from file 
            // postcondition: returns number of words in each sentence
            cout << "String " << input_string[string_number]<< endl <<
            "  has: " << num << " word(s), " << input_string[string_number-1]
            << " characters"<< endl;
        } // end for loop

        // ****************************************************************** //

        // function to check is 2 sentences are anagrams of each other
      int position = 0;
      bool anagrams = are_anagrams ( input_string ,  string_lenght , position);
      // precondition: string_number is number of string (only odd)
      //              string_lenght is the number of characters in each line
      //              after they were converted into intigers from a string
      //              position coresponds to the index of an array
      // postcondition: returns true if two strings are anagrams and false if
      //                they are not anagrams   
      if (anagrams != false)
      {
            cout << endl << "They are anagrams." << endl << endl;
            system ("pause");
            exit(1);
        }   
      else
      {
            cout << endl << "They are not anagrams." << endl << endl;
            system ("pause");
            exit(1);
        }
               
}  // end if/else

  system ("pause");
  return 0;
}


// FUNCTIONS

// converts all letters into upper case
void make_upcase (string input_string[] , int size , int count)
{
    string * words = new string[size]; // new array to hold uppercase words
    for ( int i = 1 , j = 0 ; i < count ; i+=2)
    {                     
          strupr((char *) input_string[i].c_str()); // Function converts to upper case
          words[j] = input_string[i]; // move words from input_string array to words array
          j++;
    }  // end for loop
} // end function

////////////////////////////////////////////////////////////////////////////////

// counts words on a line
int count_words (int string_number , string input_string[])
{
    int word_count = 0;
    string temp_string = input_string[string_number];
    string buffer; // Create a buffer string
    stringstream string_stream (temp_string); // Insert temp_string into a stream
 
    while (string_stream >> buffer)
          word_count++; 

    return word_count;
} // end function

////////////////////////////////////////////////////////////////////////////////

// checks if 2 sentences are anagrams
bool are_anagrams (string input_string[] , int string_lenght[] , int position )
{
    // each element will hold one char from input_string
    vector <char> text;
    vector <char> text1;

    // convert each string (element in array) into array of chars
    const char *char_text = input_string[1].c_str();
    const char *char_text1 = input_string[3].c_str();   

    // puts each char as seperate element into vector
    for (int i = 0 ;i < string_lenght[0] ; i++)
          text.push_back (char_text[i]);

    // puts each char as seperate element into vector
    for (int i = 0 ;i < string_lenght[1] ; i++)
          text1.push_back (char_text1[i]);

    // Sort vector holding first set of chars alphabeticly
    for (int i = 0; i < string_lenght[position]; i++)         
    {                                                             
          for (int j = i; j < string_lenght[position]; j++)
              if (text [i] > text [j])
                    swap (text[i], text[j]); 
    } // end for loop
   
    // Sort vector holding next set of chars alphabeticly
    for (int i = 0; i < string_lenght[1]; i++)         
    {                                                             
          for (int j = i; j < string_lenght[1]; j++)
              if (text1 [i] > text1 [j])
                    swap (text1[i], text1[j]); 
    } // end for loop

    int x = text.size();
    int x1 = text1.size();

    // removes empty elements from vector
    for (int i = 0; i < text.size() ; i++)
    {
          if (text[i] == ' ')
          {
              for (int erase = i; erase < text.size()-1; erase++)
                    text[erase ] = text[ erase+1 ] ;
              text.pop_back() ;
          } // end if
      } // end for loop
   
    // removes empty elements from vector
    for (int i = 0; i < text1.size() ; i++)
    {
          if (text1[i] == ' ')
          {
              for (int erase = i; erase < text1.size()-1; erase++)
                    text1[erase ] = text1[ erase+1 ] ;
              text1.pop_back() ;
          } // end if
      } // end for loop

    // compare each element of the 2 vectors, if they are equal return true
    // since the strings are anagrams of each other, else return false 
      if (text == text1)
          return true;                                   
      else
          return false;
         
} // end function

////////////////////////////////////////////////////////////////////////////////

// swaps characters for sorting chars alphabeticly
void swap (char &first_char , char &next_char)
{
  char temp = first_char;
  first_char = next_char;
  next_char = temp;   
} // end function

---

Quote:

---

Code:

---

input8.txt - NOT Anagrams
4
clasp
5
scalp

---

---

Interesting test case. ;)

yeah, they both contain same letters but since only 4 are read from the first string and 5 from next, these words are not anagrams

Ah. I understand your test cases now.

Here's my solution.

Code:

---

#include <stdio.h>

int count( char * s ) {
        int i = 0 ;
        int length = 0 ;
        while(*s != 0) {
                if (*s != ' ') {
                        i += tolower(*s) ;
                        length++ ;
                }
                s++ ;
        }
        return i+length ;
}

int main() {
        char s1[] = "Tom Marvolo Riddle" ;
        char s2[] = "I am Lord Voldemort" ;
        printf("The strings &#37;s Anagrams\n", (count(s1)==count(s2) ? "are" : "are not" ) ) ;
        return 0 ;
}

---

Quote:

---

Originally Posted by Todd Burch

Ah. I understand your test cases now.

Here's my solution.

---

Your solution is nowhere near correct. According to that, "Tom Marvolo Riddle" is an anagram of "zxhcheiughfkhzya"

Fix:

Code:

---

#include <stdio.h>
#include <string.h>

size_t count(const char * s ) {
    size_t length = 0;

    do {
        if(!isspace(*s))
            ++length;
    } while(*++s);

    return length;
}

int strcpy_nospaces(char *dst, const char *src)
{
    for(;*src;++src)
        if(!isspace(*src))
          *dst++ = toupper(*src);
    *dst = '\0';
}

/*
  * s1: The first string
  *
  * s2: The second string
  *
  * Returns: This will return 1 if the strings evaluate as an anagram, or zero if they do not.
  *
  * If an error occurs -1 is returned.
  */
int anagram(const char *s1, const char *s2)
{
    size_t length[2];
    char *s[2];
    int comparison;

    if(!s1 || !s2)
        return -1;

    length[0] = count(s1);
    length[1] = count(s2);

    s[0] = malloc(length[0]+1);
    if(!s[0])
        return -1;

    s[1] = malloc(length[1]+1);
    if(!s[1])
    {
        free(s[0]);
        return -1;
    }

    strcpy_nospaces(s[0], s1);
    strcpy_nospaces(s[1], s2);

    qsort(s[0], length[0], sizeof(char), strcmp);
    qsort(s[1], length[1], sizeof(char), strcmp);

    comparison = strcmp(s[0], s[1]);

    free(s[0]);
    free(s[1]);

    return (comparison == 0)?1:0;
}

int main() {
        char *booleans[] = {"are not","are"};
        char s1[] = "Tom Marvolo Riddle" ;
        char s2[] = "I am Lord Voldemort" ;
        printf("The strings &#37;s Anagrams\n", booleans[anagram(s1, s2)]) ;
        return 0 ;
}

---

Quote:

---

Originally Posted by brewbuck

Your solution is nowhere near correct. According to that, "Tom Marvolo Riddle" is an anagram of "zxhcheiughfkhzya"

---

Son of a gun.

Redemption?

Code:

---

#include <stdio.h>
#include <string.h>

struct characters {
        int letters[256] ;
} ;

void map(char * s, struct characters * c) {
        int i ;
        for (i = 0 ; i < sizeof(c->letters) / sizeof(c->letters[0]) ; i++) c->letters[i] = 0 ; 
        while(*s != 0) {
                if (*s != ' ') {
                        c->letters[(int) tolower(*s)]++ ;
                }
                s++ ;
        }
}

int compare( struct characters * c1, struct characters * c2  ) {
        return !memcmp( c1, c2, sizeof(struct characters)) ;
}

int main() {
        struct characters c1 , c2 ;
        printf("struct is &#37;d\n", sizeof(c1) ) ;
        char s1[] = "Tom Marvolo Riddle" ;
        char s2[] = "I am Lord Voldemort" ;
        map(s1, &c1) ;
        map(s2, &c2) ;
        printf("The strings %s Anagrams\n", (compare( &c1, &c2 ) ? "are" : "are not" ) ) ;
        return 0 ;
}

---

Psh... mine was so elegant in its ability not to damage two strings... but alas, I will concede that yours is more streamlined.

Though...

Code:

---

for (i = 0 ; i < sizeof(c->letters) / sizeof(c->letters[0]) ; i++) c->letters[i] = 0 ;
// could become (btw, cheater...)
memset(c->letters, 0, sizeof(c->letters));
// Now you aren't a cheater :)


// And
if (!isspace(*s))

---

Or better yet

Code:

---

memset(c, 0, sizeof(struct characters));

---

And yes, isspace() is better.

Quote:

---

Redemption?

---

Not quite, due to lack of const-correctness... also is there any particular need to make the code compatible with C, and thus avoid passing by reference and prefixing struct names with struct?

I'm fairly certain his works. (And for longer cases than you might imagine.)

Soma

Code:

---

#include <iostream>
#include <string>

static const unsigned long values[] = {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};

unsigned long mugprime
(
  const std::string & f
)
{
  unsigned long return_value(0);
  for(std::string::const_iterator cursor(f.begin()), stop(f.end()); stop > cursor; ++cursor)
  {
    std::string::value_type character(*cursor);
    if(isalpha(character))
    {
      return_value += values[static_cast<unsigned long>(toupper(character))];
    }
  }
  return(return_value);
}

int main()
{
  const char s1[] = "To be or not to be: that is the question; whether 'tis nobler in the mind to suffer the slings and arrows of outrageous fortune, or to take arms against a sea of troubles and by opposing, end them?";
  const char s2[] = "Is a befitting quote from one of Shakespeare's greatest tragedies. But why won't Hamlet's inspiring motto toss our stubborn hero's tortuous battle for life, on one hand, and death, on another?";
  unsigned long vs1(mugprime(s1));
  unsigned long vs2(mugprime(s2));
  std::cout << "The string are " << ((vs1 == vs2) ? "anagrams" : "not anagrams") << "!\n";
  return(0);
}

---

Quote:

---

Originally Posted by phantomotap

I'm fairly certain his works. (And for longer cases than you might imagine.)

---

Taking advantage of prime numbers is clever but I don't think that's correct either. The products of combinations of prime numbers are unique. Their sums need not be. If you used multiplication instead of addition, this would be correct. Of course the values would grow extremely large very quickly.

You could add the logarithms of the primes instead, for an equivalent solution, but then you'd be using doubles in an anagram program :)

Quote:

---

Taking advantage of prime numbers is clever but I don't think that's correct either. The products of combinations of prime numbers are unique. Their sums need not be. If you used multiplication instead of addition, this would be correct. Of course the values would grow extremely large very quickly.

---

^_^

You're right. That was a mistake on my part, but as far that goes, it may not even compile.

And of course, the primes shouldn't be sequential, in order, nor as small, but I was in a hurry. I'm playing Mario Kart! (Without intentionally manipulation integer wraparound will be less likely to eventually cause a collision with the "right" primes.)

Soma

Quote:

---

Originally Posted by laserlight

Not quite, due to lack of const-correctness... also is there any particular need to make the code compatible with C, and thus avoid passing by reference and prefixing struct names with struct?

---

Man, tough crowd!!

When I did my first sample, I wasn't paying attention to which forum I was responding, so C it was.

How's this?

Code:

---

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

struct characters {
        int letters[256] ;
} ;

void map(const char * s, struct characters * c) {
        memset( c, 0, sizeof(struct characters) ) ;       
        while(*s) {
                if (*s != ' ') {
                        c->letters[(int) tolower(*s)]++ ;
                }
                s++ ;
        }
}

int compare( const struct characters * c1, const struct characters * c2  ) {
        return !memcmp( c1, c2, sizeof(struct characters)) ;
}

int main() {
        struct characters c1 , c2 ;
        const char s1[] = "Tom Marvolo Riddle" ;
        const char s2[] = "I am Lord Voldemort" ;
        map(s1, &c1) ;
        map(s2, &c2) ;
        printf("The strings %s Anagrams\n", (compare( &c1, &c2 ) ? "are" : "are not" ) ) ;
        return 0 ;
}

---

my humble submission

Code:

---

#include <math.h>
__int64 genPhraseVal(const char *phrase)
{     
        __int64 value=0;
        unsigned int i=strlen(phrase);
        while(i)
        {
                --i;
                unsigned int cv = tolower(phrase[i])-97;
                if(cv<26)
                {
                        value+=pow(2,cv);
                }
        }
        return value;
}

bool anagram(const char *phrase1,const char *phrase2)
{
        if(genPhraseVal(phrase1)==genPhraseVal(phrase2))
        {
                return true;
        }
        else
        {
                return false;
        }
}

---

m37h0d, why not use int64_t instead of __int64? The former is C99.

http://en.wikipedia.org/wiki/Stdint.h

my compiler doesn't recognize that as a datatype. it is from 2002, so that may have something to do with it.

Quote:

---

Originally Posted by m37h0d

my compiler doesn't recognize that as a datatype. it is from 2002, so that may have something to do with it.

---

So use:

Code:

---

typedef __int64 int64_t;

---

That way you only have to remove one line when you get a better compiler.

--
Mats

i'll consider that, thanks.

so can anyone find a flaw here? i think the alg is rock solid and should work for strings of, for all intents and purposes, unlimited length.

Code:

---

                unsigned int cv = tolower(phrase[i])-97;

---

Why not 'a'?

Code:

---

                if(cv<26)
                {
                        value+=pow(2,cv);
                }

---

could be written as:

Code:

---

                        value+=1LL << cv;

---

And of course, your anagram will think that:
aaaa
and
bb
are anagrams, because both will add up to 4.

Edit: the last flaw is probably the biggest one.

--
Mats

awww crap you're right.

Why not just do it right:

Code:

---

bool not_letter(char ch_p) { return !isalpha(ch_p); }
char to_lower(char ch_p) { return tolower(ch_p); }

std::string normalize(const std::string &str_p)
{
    std::string s(str_p);
    std::remove_copy_if(s.begin(), s.end(), s.begin(), not_letter);
    std::transform(s.begin(), s.end(), s.begin(), to_lower);
    std::sort(s.begin(), s.end());
    return s;
}

bool is_anagram_of(const std::string &a_p, const std::string &b_p)
{
    return normalize(a_p) == normalize(b_p);
}

---

Quote:

---

Why not just do it right:

---

Well, if your not bothered by the cost... indeed:

Code:

---

bool not_letter(char ch_p) { return !isalpha(ch_p); }
char to_lower(char ch_p) { return tolower(ch_p); }

std::string normalize(std::string s)
{
    s.erase(std::remove_if(s.begin(), s.end(), not_letter), s.end());
    std::transform(s.begin(), s.end(), s.begin(), to_lower);
    std::sort(s.begin(), s.end());
    return s;
}

bool is_anagram_of(const std::string &a_p, const std::string &b_p)
{
    return normalize(a_p) == normalize(b_p);
}

---

Soma

Code:

---

char * genPhraseVal(const char *phrase,char charmap[26])
{
        unsigned int i=strlen(phrase);
        while(i)
        {
                --i;
                unsigned int cv = tolower(phrase[i])-'a';
                if(cv<26)
                {
                        ++charmap[cv];
                }
        }
        return charmap;
}

bool anagram(const char *phrase1,const char *phrase2)
{
        unsigned char result1[26]="00000000000000000000000000";
        unsigned char result2[26]="00000000000000000000000000";
        genPhraseVal(phrase1,result1);
        genPhraseVal(phrase2,result2);
        bool result=true;
        unsigned int i=0;
        while(i<26 && result)
        {
                result = result1[i]==result2[i];
                ++i;
        }
        return result;
}

---

well, this is a rather brute force method, but in light of my utter failure at devising a more elegant method, simplicity is better, at least for those of us who are only moderately clever at best.

Quote:

---

Originally Posted by phantomotap

Well, if your not bothered by the cost... indeed:

---

Yikes. Yes, there was a bug there :)

Quote:

---

Yikes. Yes, there was a bug there

---

Don't feel bad; my prime example (^_^) exhibits undefined behavior, is ill-formed, and in all probability the source as posted doesn't even compile. (I used addition rather than multiplication as you suggested, forgot to subtract 'A' in the index arithmetic, and didn't account for '0' appearing during calculation.) I would fix it, but I don't see a good reason to do so.

Soma

Quote:

---

Originally Posted by phantomotap

Well, if your not bothered by the cost... indeed:

Code:

---

bool not_letter(char ch_p) { return !isalpha(ch_p); }
char to_lower(char ch_p) { return tolower(ch_p); }

std::string normalize(std::string s)
{
    s.erase(std::remove_if(s.begin(), s.end(), not_letter), s.end());
    std::transform(s.begin(), s.end(), s.begin(), to_lower);
    std::sort(s.begin(), s.end());
    return s;
}

bool is_anagram_of(const std::string &a_p, const std::string &b_p)
{
    return normalize(a_p) == normalize(b_p);
}

---

Soma

---

And of course, cost would be big if you are doing lots and lots of anagrams, but most of these programs are used to perform analysis on hand-entered inputs, or perhaps a few lines of text in a file - I bet you can't come up with ONE anagram that takes 1 second on a 486 processor with that code (or more than about 0.1 second on a modern processor).

Sure, if you feed it a long list of lots of anagrams and non-anagrams, then efficiency may be important.

I did a quick search on the web and found a 623-long Shakespearean one, and another that was 1108 characters. In both cases, blanks are included.

Ok, I take that back:
http://www.anagrammy.com/long/emergencies
may actually be long enough to take 1s or so on a 486 with it's 13 990 letters [I think not counting spaces].

The biggest factor is quicksort (sort()), which has a worst case of O(n**2) -> 13990 * 13990 -> 196000k operations. At 100MHz, with about 20 cycles per operation, we're looking at 2 seconds or so.

--
Mats

Quote:

---

Originally Posted by matsp

And of course, cost would be big if you are doing lots and lots of anagrams, but most of these programs are used to perform analysis on hand-entered inputs, or perhaps a few lines of text in a file - I bet you can't come up with ONE anagram that takes 1 second on a 486 processor with that code (or more than about 0.1 second on a modern processor).

---

Actually, this method is part of a very fast anagram finding algorithm. The target phrase, as well as all the dictionary words, are pre-normalized into this form. Then, there is a (somewhat) clever method of quickly recursing down through words to find complete anagrams.

In the final count, the time spent in this normalize() function is completely invisible.

I might post the whole program later.

Quote:

---

I bet you can't come up with ONE anagram that takes 1 second on a 486 processor with that code

---

O_o

I can't "come up" with any, but I can create arbitrarily many. I have a program around here somewhere.

Anyway, I wasn't thinking about speed of generation but comparison.

Soma

i just executed my and brewbuck's algs 100 times on the 13990 character anagrams

results are:
me 78ms
brewbuck 672ms

perhaps it's not so unclever afterall :)

Quote:

---

Originally Posted by m37h0d

does anyone know a reliable method for clocking speed of execution for something like this?

for the 13390 character anagrams, my alg consistently executes in <1 ms, and brewbuck's usually comes up as 15 or 16 ms, but occasionally returns in <1 ms also.

---

Time a bunch of identical runs and take the smallest time. It's not like the measurement is in error, there's just system noise being added in. The smallest time is how fast it ran when everything else on the system happened "just right."

Anyway, my method is not really meant for determining if two strings are anagrams of each other. It's part of a larger algorithm for finding complete, multi-word anagrams.

A better method for one-shot use is to tally how many of each character occurred:

Code:

---

std::vector<int> count_letters(const std::string &str_p)
{
    std::vector<int> count(26);
    for(int i = 0; i < 26; i++) count[i] = 0;
    for(std::string::const_iterator si = str_p.begin(), end = str_p.end(); si != end; ++si)
    {
        char ch = *si;
        if(isalpha(ch)) ++count[tolower(ch) - 'a'];
    }
    return count;
}

bool is_anagram_of(const std::string &a_p, const std::string &b_p)
{
    return (a_p.size() == b_p.size() && count_letters(a_p) == count_letters(b_p));
}

---

heh yeah i posted before thinking. see edit...

Quote:

---

Originally Posted by brewbuck

Anyway, my method is not really meant for determining if two strings are anagrams of each other. It's part of a larger algorithm for finding complete, multi-word anagrams.

---

that's exactly what mine does.

Quote:

---

Originally Posted by brewbuck

Anyway, my method is not really meant for determining if two strings are anagrams of each other. It's part of a larger algorithm for finding complete, multi-word anagrams.

---

i'm intrigued, you mean for generating possible anagrams from words? that could be a lot of fun :)

Quote:

---

Originally Posted by m37h0d

i'm intrigued, you mean for generating possible anagrams from words? that could be a lot of fun :)

---

Yes, something like the Internet Anagram Server.

I'll post the code tonight. It's on a box I can't access right now.

Quote:

---

Originally Posted by matsp

Ok, I take that back:
http://www.anagrammy.com/long/emergencies
may actually be long enough to take 1s or so on a 486 with it's 13 990 letters [I think not counting spaces].

---

I don't find such long anagrams to be interesting, because there are so many letters available it is very easy to arrange them into an order than makes sense. After all, the distribution of letter frequencies in English (and most languages) is basically constant when averaged over large amounts of text.

wow .. i haven't checked this in a few days .. thanks for all these replies .. but i was about to submit my own code and see where to go from there ..

this is what i have right now.. and what this does is take an input like sldkfjLLKJLKJ8(&9879 and only output letters, so the output would be sldkfjLLKJLKJ. Now this is where i'm stuck i need to count how many times each letter comes up in each string and then determine if they match.. how can i start do to that?

heres my code:

Code:

---


#include <iostream>
#include <cctype>
#include <cstring>

using namespace std;

int main (){


        char mystring[500];
        char myalpha[500];
        cout << "enter some shiz" << endl;
        cin.getline(mystring, 500, '\n');
 int a=0;
        for (int i=0; mystring[i] !='\0'; i++){
                if (isalpha(mystring[i])){

                        myalpha[a]=mystring[i];
                        a++;
                }
        }
myalpha[a]='\0';
        cout << myalpha << endl;


        return 0;

}

---

This post shows how to count all characters: http://cboard.cprogramming.com/showp...7&postcount=23

Todd

that one works todd, except that anagrams don't count things like whitespace and punctuation

Quote:

---

Originally Posted by m37h0d

that one works todd, except that anagrams don't count things like whitespace and punctuation

---

anagrams are word plays - they don't ever count anything!

Oh, you mean the program. Yes, well, unfortunately, it counts everything. Therefore, use what you want and ignore the rest.

edit: i got it to work using this code .. now does anyone know if i should just count the letter .. or can an anagram use numbers as well?

Code:

---



#include <iostream>
#include <cctype>
#include <cstring>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

using namespace std;


struct characters {
        int letters[256] ;
} ;

void map(const char * s, struct characters * c) {
        memset( c, 0, sizeof(struct characters) ) ;       
        while(*s) {
                if (*s != ' ') {
                        c->letters[(int) tolower(*s)]++ ;
                }
                s++ ;
        }
}

int compare( const struct characters * c1, const struct characters * c2  ) {
        return !memcmp( c1, c2, sizeof(struct characters)) ;
}


int main() {
        struct characters c1 , c2 ;

        char s1[500];
        char s2[500];
        char mystring1[500];
        char mystring2[500];

        cout << "enter first string" << endl;
        cin.getline(mystring1, 500, '\n');
 int a=0;
        for (int i=0; mystring1[i] !='\0'; i++){
                if (isalpha(mystring1[i])){

                        s1[a]=mystring1[i];
                        a++;
                }
        }
s1[a]='\0';
        cout << s1 << endl;



        cout << "enter second string" << endl;
        cin.getline(mystring2, 500, '\n');

        int b=0;
        for (int i=0; mystring2[i] !='\0'; i++){
                if (isalpha(mystring2[i])){

                        s2[b]=mystring2[i];
                        b++;
                }
        }
s2[b]='\0';
        cout << s2 << endl;


       
        map(s1, &c1) ;
        map(s2, &c2) ;
        printf("The strings &#37;s Anagrams\n", (compare( &c1, &c2 ) ? "are" : "are not" ) ) ;

        return 0 ;




}

---

Well, since you need to be writing in C++, the only thing you should be taking out of my sample is the concept of how to do it.

Todd

well i don't fully understand how your function works .. for instance .. i do not know what struct or memset are

if you were able to explain the function a little more i would understand it .. but like i said what i have now works

Code:

---

mem.h, string.h

Category

Memory and String Manipulation Routines, Inline Routines

Prototype

void *memset(void *s, int c, size_t n);

void *_wmemset(void *s, int c, size_t n);

Description

Sets n bytes of a block of memory to byte c.

memset sets the first n bytes of the array s to the character c.

Return Value

memset returns s.

---

Code:

---


Category

Type specifiers

Syntax

struct [<struct type name>] {

  [<type> <variable-name[, variable-name, ...]>] ;
    .
    .
    .

} [<structure variables>] ;

Description

Use a struct to group variables into a single record.

<struct type name>        An optional tag name that refers to the structure type.
<structure variables>        The data definitions, also optional.

Though both <struct type name> and <structure variables> are optional, one of the two must appear.

You define elements in the record by naming a <type>, followed by one or more <variable-name> (separated by commas).

Separate different variable types by a semicolon.

To access elements in a structure, use a record selector (.) or ->.

To declare additional variables of the same type, use the keyword struct followed by the <struct type name>, followed by the variable names. In C++ the keyword struct can be omitted.

Note: C++Builder allows the use of anonymous struct embedded within another structure.

---

learning to read manual-ese is by far the most valuable skill you will ever learn in programming.