如何知道两个字符串是否有相同的字母？

Question

Using strstr , we can check if two strings are absolutely same each other or not. But I want to know if the components of two strings are exactly same. For example, "DOG" consists 'D' , 'O' , 'G' and "GOD" consists 'G' , 'O' , 'D' . The components of the two strings are 'D' , 'O' , 'G' , which are exactly same. How can I write a program that compares the components of two strings?

Answer 1

As mentioned in the comments, your problem can be solved by computing a histogram of the characters occurring in each string. Then you can compare if both have the same histogram. If so, both strings contain the same characters with the same number of repetitions, but with arbitrary order.

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

#define HIST_SIZE (UCHAR_MAX + 1)

void create_histogram(const char *s, int histogram[HIST_SIZE]) {
  for (size_t i = 0; s[i] != '\0'; i++) {
    unsigned char c = s[i];
    histogram[c]++;
  }
}

int same_histograms(const int histogram1[HIST_SIZE],
                    const int histogram2[HIST_SIZE]) {
  for (size_t i = 0; i < HIST_SIZE; i++) {
    if (histogram1[i] != histogram2[i]) {
      return 0;
    }
  }
  return 1;
}

int same_chars(const char *a, const char *b) {
  int histogram1[HIST_SIZE] = {0};
  int histogram2[HIST_SIZE] = {0};

  create_histogram(a, histogram1);
  create_histogram(b, histogram2);

  return same_histograms(histogram1, histogram2);
}

int main() {
  printf("Result: %d\n", same_chars("dog", "god"));

  return EXIT_SUCCESS;
}

Answer 2

Another method would be to sort the two strings, and then compare them.

If the sorted string match, they have to contain exactly the same letters:

#define _XOPEN_SOURCE 700

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

int compareChars( const void *a, const void *b )
{
    char aa = *( ( char * ) a );
    char bb = *( ( char * ) b );
    return( aa - bb );
}

// use qsort to sort the string
char *sortStr( const char *str )
{
    char *sortedStr = strdup( str );
    qsort( sortedStr, strlen( sortedStr ), 1, compareChars );
    return( sortedStr );
}

int sameLetters( const char *a, const char *b )
{
    char *sortedA = sortStr( a );
    char *sortedB = sortStr( b );

    int result = strcmp( sortedA, sortedB );

    free( sortedA );
    free( sortedB );

    return( !result );
}

And main() (separated to eliminate scroll bars):

int main( int argc, char **argv )
{
    if ( argc < 3 )
    {
        return( -1 );
    }

    // compare consecutive argument strings
    for ( int ii = 1; ii < ( argc - 1 ); ii++ )
    {
        if ( sameLetters( argv[ ii ], argv[ ii + 1 ] ) )
        {
            printf( "'%s' has the same letters as '%s'\n",
                argv[ ii ], argv[ ii + 1 ] );
        }
    }

    return( 0 );
}

Sorting is probably more efficient for short strings, but suffers from either having to either copy the string or modify the original. As the string size grows, I strongly suspect the histogram method would be much more efficient - it can take a long time to copy and then sort each string, and it could take a lot of memory to make a copy.

Answer 3

You could sort both strings then compare them

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

static int compareFunction(const void* a, const void* b) 
{ 
    return *(const char*)a- *(const char*)b; 
} 
int compareComponents(const char* a, const char* b) 
{ 
    int lenA = strlen(a);
    int lenB = strlen(b);
    int returnVal;

    char *tempA = malloc(sizeof(char)*(lenA+1));
    char *tempB = malloc(sizeof(char)*(lenB+1));
    strcpy(tempA,a);
    strcpy(tempB,b);
    qsort(tempA, lenA, sizeof(char), compareFunction); 
    qsort(tempB, lenB, sizeof(char), compareFunction); 
    returnVal=strcmp(tempA,tempB); 
    free(tempA);
    free(tempB);
    return returnVal;
} 

For the previous solution, the return value is the return of strcmp ing the two sorted strings. That is, zero iff both strings are equal.

Answer 4

A variation on @f9c69e9781fa194211448473495534 good answer.

Perform a census of the characters in strings a and b . Increase the population for characters in a and decrease for b . When done, if any of the census counts are not 0, strings differ.

#include <limits.h>
#include <stdbool.h>
#include <stdlib.h>

bool same_chars(const char *a, const char *b) {
  const unsigned char *ua = (const unsigned char *) a;
  const unsigned char *ub = (const unsigned char *) b;

  size_t population[UCHAR_MAX + 1] = {0};  // Only 1 table needed.
  while (*ua && *ub) {
    population[*ua++]++;
    population[*ub++]--;
  }
  if (*ua || *ub) {
    return false; // One longer than the other
  }
  for (unsigned i = 0; i <= UCHAR_MAX; i++) {
    if (population[i]) {
      return false; // mis-match
    }
  }
  return true; // match;
}

---

Performing the operation as unsigned char avoids the case of negative char as an array index. For the pedantic: On long lost non 2's complement machines with signed char , this handles -0 correctly.