12-28 Exercise 3: Anagrams function

Question

15.8k views

Write a function that tests whether two words or phrases are anagrams (permutations of the same letters):

寫一個判斷兩個單詞或詞組是不是符合易位構詞的函數。

#include <stdio.h>
#include <string.h>
#include <ctype.h>
int is_anagrams(char A[],char B[])
{
   /*INSERT YOUR CODE HERE*/


   /*END OF YOUR CODE*/
   //The function should return 1 if two words or phrases are anagrams, 0 if two words or phrases are not anagrams.
}

int main(void)
{
   char A[100],B[100];
   /*INSERT YOUR CODE HERE*/


   /*END OF YOUR CODE*/
   if (is_anagrams(A,B)) printf("Two words or phrases are anagrams");
   else printf("Two words or phrases are not anagrams");

   return 0;
}

Example input:

smartest
mattress

Example output:

Two words or phrases are anagrams

Example input:

dumbest
stumble

Example output:

Two words or phrases are not anagrams

Remember: You may correct the cases, but your code always be revised!

[Exercise] Coding (C) - asked Dec 28, 2017 in Chapter 9: Functions
ID: 39986 - Available when: Unlimited - Due to: Unlimited | 15.8k views

79 Answers

Page:

« prev
1
2
3
4
5
6
...
8
next »

Sabrina Lin · Answer 1 · 2018-01-14 19:43:51

Hidden content!
** * *  * *** ******   * 
      *  ***     * ** * 
 ** * * * *  ** ** * 
int **  *** *  *** * B[])
{
 * **     ** *   int   * = {0};

*  **   *  * int  *  = {0};

  * *  *  ***      int *   =  *  *** 

* * ** ** * ** int *   =   ** *** 

**** * *  **    **  i = 0; i     * *  *  *  i++)
* *   *  * *** {
**  * ** *     ** *****   *    A[i] =    * ***

* **  *   **  *     * * *  ***    *  * - ** ** *
   *  * * **   }

* *  *   ** *  **** i = 0; i * **  **  i++)
******  *   *   {
 **       * ** ** *** *  *    B[i] =   **  * 

*   * **      *  * ***     * * ** *   -  ** *
*  * *  *   ** **  }

*   *   *  **        i = 0; i *** *   26; i++)
*    *   **  ** {
  * * *   *   * ** *    *    *    ** !=    *
 ****  * *  ***  * * *** **  *  {
 **    ***    ** * *  *** *   *  ** * * * *  **   0;
***  **   * *  ** * *   ** * }
 *  **  *   * * ***   ** * else
* * *  ** * **** * ** * * {
  *    *****   *******    * * *    ***   ** * ** ** * 1;
** * **  **  ** * ****  * **   }
** **   ** *   }
* * *****  ** **** * **   *********  *    *   * *  1 if two   * or   *   are  **    
*   ** *    *   //0 if two words or   ***  are not  * ***
}

int  **  *
{
  * *  *** ** ***  ***  **** ****   ** **   
 * *   **  * ** *** *** *
 *  **   **      ***  100,  **  

 ****  *     *** ***** 100,  *  **

**** **   *  *    * *    **   ****  ** *** **  ****   *  * or ** * are ***      * 
***** *** *  *** ***  *** **   ****  ** *  or   *** are not * ** ******* * *

  *  ***  ***** *** *      0;
}

answered Jan 14, 2018 by Sabrina Lin (-285 points)

Sabrina Lin · Answer 2 · 2018-01-14 19:42:09

Hidden content!
  *      * **  *** **
 *     * ** * **** *  
** *  **      ***    *  *
int *   * *      ** *  B[])
{
** **** * ***** int    * = {0};

 ** **  ** *  int ** * = {0};

** **    * ** * int  *   = ***** *

*** ***  ** ** * *   i = 0; i ***    *  i++)
    * * * * * ** **  {
***  *** *  ** **  **** * * *******  A[i] =  *****  **

* *** *  *   *    **  *   ****   ***  - **** *
* * *      ***  }

*      * * **  *  ** *  i = 0; i  * *       * i++)
** **   * ** {
    *  ** ** **    *   **  B[i] =  *   *    

*  *** *       *   **  ** * *** *     * * -  ** 
** *   *    **** }

 ** ****  **** * *     i = 0; i **   26; i++)
  * ***  *****   {
* *** ******* ** ** *  * **   ****  != ****
   ** *  *    * ***  *    * {
*** ****  **     *** **  * ****    * ** * * **** 0;
*** * *         ***      * *  *** }
 *  *   *  **    *   * * * else
*  ** ** * ** ***         {
* ** *      *    **  *  *        *** *  **     * *** 1;
*** *  ***** ***  **   * *  * }
 **    *   *  * }
 *    ***** * *   ** ** ** ** ** ***     *    1 if two words or *  * ** are ***   * 
 *  * * *     //0 if two **  or  ** are not * * *
}

int     *    
{
* **    * * **  ***  *  **  *  *** **
  *  **** **  ** 
* **** **  **  **  100, ***

*  **   * ***    ** 100,  **  

 * * *  **  *** * ** **  * *   *  *    ** *   * **    ** or **   are   *** *      
* * * *    *     * **   **  **  * words or **** are not     **** * *** *

 ** **** * * *** *** *  0;
}

answered Jan 14, 2018 by Sabrina Lin (-285 points)

benson2 · Answer 3 · 2018-01-14 16:31:13

Hidden content!
#include <stdio.h>
#include <string.h>
#include <ctype.h>
int is_anagrams(char A[],char B[])
{
* * ** **   *    * ***   * YOUR CODE HERE*/
** ** *  **   * ** **   *** i=0,j=0,c[26]={},d[26]={};
   ** *   **     *  **  *******  ***  **     ** ** * *  ****   **    * **  * ***  ****** *** *** **    *  **   
** **** *     * **       *   ***  * * *  ** *   *  ** *  *****  * **    *  *  * ** * *  ***** * * **   *  **
 *    *       *   ** **   ** ***   ** **   **
 **   *** * **  **    * ****  * * * ********* * * * *  **** *  *  **   * ** **
* *    * *     ***    *** *   *** **   ** * **  ** *   ** * *** ***  ** *** ***   * *** *
* * ******    *** **  ** ** ***    ** ****  ** ** **** ** *** ***  **  * **** ** ****  * *   * *****    * 
* * *******     *   **  ** ** *   * *    *       * *  * ******** ***  **  * *
* *    * * *    ****    **        *      * ** *   *** ** *** * * ***  **** ***** **   * *     ** 
 **  *  ** *  ***   ***** ******   * * **     *   * * *** *     **  * ****  * * *  ** * *  ****   ***** 
****  * **** * ** ****      **  * **  *   *** *   *  **** *** * ******* * ** *  
*   * *** *   * *  *** *   * *** *   **     * * *    
   *  **   *  ***   ***  ** 
* * *  *** *   **     **    *   * *     ** ** 
** *****  * **  *  * **   * **  * *** ** **       ***  **  ***
* ** *  *** ***    * *         *  *  ** **   ***   *     ** *  *   * *  * *  ****** 0;
 *        *** **** **  **  * * *  *******   *****  **    
* *     *        *    * * * *
   * ** *    * * ****     **        1;

 **  ****  ****   * *** ** * OF YOUR CODE*/
**  *  *  ***** ** * ** function should return 1 if two words or phrases are anagrams, 0 if two words or phrases are not anagrams.
}

int main(void)
{
*  * * ** ******  ** ** A[100]={},B[100]={};
** * ***  ***        ** YOUR CODE HERE*/
*** *  ** **   *   * ** *  * *  * **   *    
* *** * * ** *    *  *  *  ***  ** ** **
 ***  **  **  *     ** * OF YOUR CODE*/
  * ****     *** **  ** (is_anagrams(A,B)) printf("Two words or phrases are anagrams");
*** **     ** * *  **  ** printf("Two words or phrases are not anagrams");
*  *    ***  *    ** 0;
}

answered Jan 14, 2018 by benson2 (-329 points)

Diyiel · Answer 4 · 2018-01-14 13:57:59

Hidden content!
#include <stdio.h>
#include <ctype.h>
#include <string.h>

int is_anagrams(char A[100],char B[100])
{
***   *****    ** *  * *** * Array1[26] = {0}, Array2[26] = {0}, i = 0;
**   *****   * **   **  * *   n, j, k;
    
    ***** *   * **   **** *  = strlen(A);
 *   *  *    ** **     ** *****
***   ****      * *** ***   **   *** *    ***
   *  *  *   * *    *
 * * **  *      **     *** ****** *  ** * ** ******        * *** *  * 
 *  *** ******   *   *   * *  ** *       ****   *** *   * ****  * *  * *   
 ** **   *****     * **  **  ** ***** **     *   * *   
 *  ***  * ** *    ***
**  ** **  * ********  * 
*      * * **   ** * * ****   
** ****   **   ** * ** ** *******        *** *  
  ******* **   *   * *     ** 
*** *     * **  *   *  * ** * *   *   ***     * **  *   *     *  *
**    *  * *********  *   ** * **  ** * *   * ****  **  *  * ** * * ***
  *** *     ** * * **  *   *
* **  ** *        *   ** * *** *
 ***  *   **       *    **
** ** *** *  *  *   *     * *  (i = 0; i < 26; i++)
*****    ** * ** * * *** 
  *  *******  ***** **********   **  **     *  ***** (Array1[i] != Array2[i])
***  **   **   *     * *  *         *   * *  *** **  **    *  ****      ** *   * * *  *    0;
 *  *** *  ****  * ***  ** 
            *** * *   *
 * * ** * ***  ***** * **      * * 1;
}

int main()
{
 *   *  ******* * ** ** *  * * A[100],B[100];
  *  * * ***  **** *  *****
     ****  * ***    *   *   *** *    * 
   **  * **  **   **   * * ***      ** *
*  ** *     ** *       *  *
* ***   **  ** ***  **  **   * ** (is_anagrams(A,B))
***** ***    *** *    ** ** 
**    **    **     ********** * ****  * *  * * **** *   *  **  **  *    ** words or phrases are anagrams");
***  * * * *  **  *   *** 
** ***** ***  **  * ***** * * printf("Two words or phrases are not anagrams");
*   * * * ****** ** ***** 
*** ** **   *   *   **  *  ** 0;
}

answered Jan 14, 2018 by Diyiel (-193 points)

Diyiel · Answer 5 · 2018-01-14 13:53:12

Hidden content!
#include <stdio.h>
#include <ctype.h>
#include <string.h>

int is_anagrams(char A[100],char B[100])
{
 ***  *      *   ****    **  Array1[26] = {0}, Array2[26] = {0}, i = 0;
* * *   *  * *   **   **  *** n, j, k;
    
*** ***** *   *  *   * * **     = (unsigned)strlen(A);
** *  *** ***  * ** ***** * 
  ** *** * ** * *  * *  * ** ** * **   * ***  
*   *  **   *** ** ** **  * *
 ***  * **         *   * * *    ***** ** ***    * *** *    *** *   * 
* ********  *  * *** ** *  ******** **  *   * ** ****  **** * * ***
 ** *** *    ****   * *  *      *   ** **       *  
    *  * **    *    ** ** *** *
  ***     * *  ***** **  *
  *   * *      **  *  *
**     ** * *  *  *****   * *   *  *
***  *  * * *       *  * *  *** ** 
 * **   *  *  * *** *   *  **  * **       * *** **  ****      *** *    
 ****   ***** **  ** *   **  * **   **   **********    *   *   
  ******  ** * ** **  *   *   *     
   *  * * *  * *** ***** ** **
   ** * ****    **   ** * **
 **    **  * * **   ***  ** ** ** (i = 0; i < 26; i++)
  ****  *    *  **     ***  *
*   ** * *   **  *         *    ****   *  *****  **  (Array1[i] != Array2[i])
**   *   * *   ** **   ****** **      * **     * ** **  ** *** *****  **  *  * * * ******   0;
* *****  *  *  ** * ** * *
   *  ** ***  ***  *  
* ** ****  ** * **  ******* * * 1;
}

int main()
{
 ** **   * ***   * * *   *  ** A[100],B[100];
** *   **    ** *   *** ******* *
** ***  *  *** *   *    ****  * *** ** ***   * ** 
* * **         ** *   ******  * ** ** *   * * *  * *
 *   * * **  *     *  ** *  *
           *   * * ****** * (is_anagrams(A,B))
*   *** * *****      ** ** * 
 *    ****    * ****    ** * *****   **** * * *    *** *    **  words or phrases are anagrams");
 ****  * ***   ** * * *  * ** 
**  *** * ***  * ** **** **  * *  printf("Two words or phrases are not anagrams");
    *  * **   * ** * ** * **** 
 * **    **  * * ** **   *  * ** *  0;
}

answered Jan 14, 2018 by Diyiel (-193 points)

Headshake · Answer 6 · 2018-01-13 23:06:36

Hidden content!
#include   **   *  * ***
#include ** *         ****** 
#include   * **   *    *   
int is_anagrams(char A[],char B[])
{
      ** ****  ***   *  **  * ** * * * *   *  *
*     *********   ***  * YOUR CODE HERE*/
*  *****   *** *  *  *  * * ****    ***  *   **
**  ***    *  ** ** *   ***
 ** ***** ** *** * * * *********** **  ***** **       *  ******     * * 'a' &&    *   **  *  * 
*    * **** *** *   **  ***  *    *  *** * ** * * *******  * *  ****  * **   *      **  * *    *     
   **   * **    * ***   *       *  **  * ****  *   *   **   *  *****  ***     **  && ****  **   * *
*****  * ** **   * ****  ** ** *****  **       *** *** ****   *  *  * *    ******* **** ** **   **
  **** ** **        * *****
*  * *  ** ** * *  ***     *** ** ** ****  **  **
* * *   ** ***       * ** 
* *     **  ****   * **  * ** * * **  *   * * **** *** ** * 
* ** ***  * *   ** * *  *  ****   **** * ***   * **  * * ** ** *  * ***  0;
*  *  *  *  *   * *   **  **
   * * *     * ***** **  *  *  *** 1;


 **   ****       *  *   OF YOUR CODE*/
*   * ** * ***     *** function should return 1 if two words or phrases are anagrams, 0 if two words or phrases are not anagrams.
}

int main(void)
{
* * *** **  *** ******  A[100],B[100];

* * ***** * *  **  ***  ** *  ** *  *  
   *  * * **  *      * ****    ***     **

**   ** * * ***   * * * *** ****** ** * * * *     words or phrases are  *    * **** *
**  ** *  * *** **   ** *  printf("Two words or phrases are not anagrams");

* * **  ****  ***     *   0;
}

answered Jan 13, 2018 by Headshake (-281 points)

Headshake · Answer 7 · 2018-01-13 22:58:06

Hidden content!
#include * ***  ** *     
#include     ***    ***  
#include *   ******     **** 
int is_anagrams(char A[],char B[])
{
****      * * *** **** ** * **** * *  * 
     * * * *****   * * * YOUR CODE HERE*/
   *** **** ****   * *  * *** ** **  * ** *** * *  *   
 *** **  *    ***  * *** ** * **
*** **  *** **  *** *   ** *  ** * *  ***** *  **  ***  **  *  'a' && A[i]<='z')
**  *   * **  ***   * *     **  ** * **** * **** * * ** ** *     ** * *  ** *   *  *  ** ** *** ** **** 
*  ****  ***  ** ** *   *  ***  **   **   * *****     ***     *   ***      ****   *** B[i]<='z')
***  **  * **** ***  *   *  *   *  **** ****  * * *  * *      ****  ** ** *** ******** * *  ***   *
* * ** *  *** *  *  *  **
* ** ** *** *      *** * *****  * ** * ***  ***
****    *    * **** **
** * **  **  ***  ****   *  *    **   **  * *  ****** * ***  *   *
** *  * *  * *  *** * **  *  ***    ********   * ***  * **  *** ** * **  *  * * ***   0;
* ** *     ** *  **  *** ** 
****   ***  * * * *  ** **  1;


 ****      *** **  * *  OF YOUR CODE*/
*  *   * ***   *  *   function should return 1 if two words or phrases are anagrams, 0 if two words or phrases are not anagrams.
}

int main(void)
{
 ** ***  *   * *** **  ***   A[100],B[100];

***    * ** *** *  *** ** *       * ** 
  *   *   ***** ** **  **** **    *      * 

 * ** * ** *      *  *   *      *  **  *    **** * ** *** *   words or phrases are ** * * *  * *
**  **  **** *  *****  ** ** *  * * * words or phrases are not * * *** *  **   

  ** **  ** * *    ***** 0;
}

answered Jan 13, 2018 by Headshake (-281 points)

HuangWg · Answer 8 · 2018-01-13 21:07:24

Hidden content!
#include <stdio.h>
#include <string.h>
#include <ctype.h>
int is_anagrams(char a[],char b[])
{
* *   * *** *** * *** * * first[26] = {0}, second[26] = {0}, c;
 
   // Calculating frequency of characters in first string
  **  *   **   ** * ****** *** * *   a[c]!='\0'; ++c)
* *    *** ** * ******   ***      
 *     ***** *** **      **** *  *******    *     * * * *** *  ')
*** * ***   ****   * * *** * * *  ****   **  ****   
***  * ***  * * *  ********      ** *** ** *   *   *   *  **   **** * * ** * *  *  *** **    ** * && a[c] <='Z')
 **      * ** *  *** * *      ****    *  ** *** **  *** *** *    * ***  ****** * 
   *  * ***** *  **  *****    *   * * *** ** *    ** ****** *** **** *  *  ****   *  *     **** **  ** * * **  ** * *** **  
 * ** * ******   *** ** * * ** **** * * *  * ** *  *** * * * ***** * ****   ** *** 
* *** **  *   **   ** **     **** * ***  * * ** **********  *   ***  *  *  **** 
** ***** * **  *** ** *  * *  *  ***   *   ** * * * **   ****   *** *** **  *  **
  *    * * *** *  ** * * *** **  **** **  *****  * *******  * * ** *** ***********    ***** *** **      *  *  ** *    
 * ***     **   *      * *******  **  * ** * *  **** ****      * * **** * *   
* *  **** * *** ** *           * * *   **     *****  **  ** *** * *  * * * ** **
 *   **    *   *  ***  * *** ***  * * *        * **** * **
 * * ***  ***   ***   
* ** ****     *** **   * 
     **      **  * ** *** * b[c]!='\0'; ++c)
** *** * * ******* ****    
**** **  * * * *  * *** **  *  ****    * ** * **  * **  *  ')
* * ** * *** ***   ** * * ** * * *** * *** * ** *** 
** **  *     **  *    *** ** *  * *   ** *** * **  ** **   ** *   ******    *      * ** ***  && b[c] <='Z')
 ****  ** *   **    * ** * *    * *     * *    * *   **  *** **    * ***   **    
 **** **   * ** **** * ** * *  *  ***  ** *   **** *  **  * ** ***  **  *   ** *     ** **  ** **** *  *  *   * *   * ** **
** *   ** ***  *   **  ***  * * * * ****** *    ***  * *  * *  **   ** *    ****
 ****   ***     ***     ***    ******  *  *    * ** * **  * *  ****** * **   *
 *    **  * *  * *  **** *  * ** ** **  **  **** * * *     **   ******  * * * *
  * ** ** *  * * **    *  ** * *** **  ** ********* **    ** * *** ** *    *** **  **   **    **** ****** ** *  *   ** ** ***    
 *** * * ** ***** ** ******  * *  ** * *  *** ***  **** *  *          **   *
**** **  *   *      **** *       ** * *** * *****  * ***  *  * * ** ** ***   * ***
***  ****    *  *  ** ***  *   * *   ** *  *  ** * *  *
 *** ******   * *   * ** * **
   // Comparing frequency of characters
 
  **** *** *  **   * **** ** (c = 0; c < 26; c++)
   * * ***    ** **   *  ** **  * * ***   * * 
 * **     *** **  * **  *** *  *****  *   *    * * * *** * * (first[c] != second[c]) 
 *       * ****   * * *  **   * ** ****** * ****  **      ** ****  **    **** **  *  *** 0;
 * **  **  * *** * ***  *   ** **    **   ** ** * **
 
       ** ** * *    **   1;
}

int main(void)
{
**** *    * **** * ** A[100],B[100];
** *  ** ** *   ***  * *  * 100, stdin);
   *  * ******   ** ** * 100, stdin);
   if (is_anagrams(A,B)) printf("Two words or phrases are anagrams");
* *      **    *  ***   printf("Two words or phrases are not anagrams");

 *** * **  *  *  *    *   ** 0;
}

answered Jan 13, 2018 by HuangWg (-108 points)

Chris118ta · Answer 9 · 2018-01-13 21:07:07

Hidden content!
#include <stdio.h>
#include <string.h>
#include <ctype.h>
int is_anagrams(char a[],char b[])
{
****  * * * *** **** * *   first[26] = {0}, second[26] = {0}, c;
 
   // Calculating frequency of characters in first string
 *   **     *  ** ** ** *    * a[c]!='\0'; ++c)
**** * *  * **  ** * ** **    
  *    *   *   ** ** * **  ***** ** * *  *  * ***   ** ')
****** **   *** *** *  **     * **** ** * *** * *    * *   *
** **    *    * ** ***  * *    ****   ***** **  * *  *******  *** ****    * ***   *  *** * && a[c] <='Z')
 * **  ** *** *** * ** *   *  *     ***  * *    * * ** * * *  * ******* * **
* * *     ***** * *   * * **  *** * *** ***  ** **  *  ****  * *  ***    **   * * *   *  ** **  * *   ** **  * *  **   * *
*****  **  ** *** ** ** *  *  *** * ***  * ** ***   *  *   * ** * ** *  * * *** ** ** ***   
 * *      *** * *** * ***** ** *  *****  *******   **   ** *******       *  * **  * **    *  **
 *   ***** * *  * * ** ******* *    **   * ** *    **** * *  *     * * ** **   * 
* **   *      **   ***  **  **** ***  * *   * ** * * * *  *** *   *  ** ** ***   ***  * ** ** **** *     ** ** ***  ***    
  **    **    **    *** *   **       *    *  ** *   **** *      *   *  *   ****
**** * * ***   *** * *  * ** * ***   *  *  ** ** *  ****** *** * ****   **** ****
***** * ***********      ***   **  * ***  * * **   
 *** * * * * * * ***  * * 
****** ** ******** * ** ** * 
**  * ** *  * * **  **   *  b[c]!='\0'; ++c)
*********  * *  *  * **  * * *    
* * *****  **     * **** ** * *  * *   *    *   * ** * *** **   ')
 *  **   *     ** **  *   * ** *    **** *    *** **
* * *  *** * *   ****  *  ******* **** *   *   * **** *   *       *** * ** *** *  * * && b[c] <='Z')
***   **   *  **  **   * ** * *   *   **** ****    ***  **    **** * *  *  ****   
*  ***   *  **** * * *** *  *  ****   * ****    *** * * *   ***      *  ****   * ***  ***** *    ** ** ** * **  **  *  *
  *  *  * ** *      *  *   *** ****     *    *** *****  ***  *** ******* * * *  *  
  ****  **** ** ** ** *    ****  ***  * *  ** * * *  **  ** *   *   **** ** * * ** 
 * * *  **       *   ****  *   *    **  *   *  ** *** * *  *  * ****  * * ***** **** *   
**    *    *   ** **  **  *   *************   **   ** *   ** **  *      **  *    *** * *  *  **   **    *  * * * **    
 ****  * ****    *     ** *  * *      *  **** **       *  ****      *** ** ** * *
* * **** * *** *   **  **** *  * *    *  *** * *** **** **   * ** ***  * ****
  * *  ****   * ***** *    *  *     *  * **** ** ***   ** 
*  ***      ***** *   *****
   // Comparing frequency of characters
 
* ******  ** *  ** *   * * *****   *** (c = 0; c < 26; c++)
 * * *** * *** *  **   * * *   *  * ** *   **  *  
*** * *  * ** **  * **  *  *** **** * * **    *     *** * *  * **   (first[c] != second[c]) 
*****  *****     ** ****   **** *  *  ** *  * ***  ** ****   **** *   * * * **   **   *       ** 0;
* **    *      *   *  *  *  * **    * *** *   **** 
 
**      * **  *  *** ** ** * 1;
}

int main(void)
{
   *    *** * * **  *  A[100],B[100];
**       *      **    * *  100, stdin);
* * ****       *** * **** * *  * 100, stdin);
   if (is_anagrams(A,B)) printf("Two words or phrases are anagrams");
 *** *    ** *  ** * * printf("Two words or phrases are not anagrams");

*   * * * ***** ** *   0;
}

answered Jan 13, 2018 by Chris118ta (-284 points)

coach · Answer 10 · 2018-01-13 20:45:36

Hidden content!
#include <stdio.h>
#include <string.h>
#include <ctype.h>
int is_anagrams(char a[],char b[])
{
 ** *  * *  *  * *  *  first[26] = {0}, second[26] = {0}, c;
 
   // Calculating frequency of characters in first string
 ** *   * * *   * **      ******* *  a[c]!='\0'; ++c)
**    ** *** ******  * ***       
***** *  * ***     * *  *  ** ***** *  *  ***  *  ** ')
* ***  **  * *****    * ** ** *****  ** ** *   *   
    ** ** *  *  * ******  * ****  *** ****   * ** * * * *  **     ***   **   *  * ***  && a[c] <='Z')
    * *** * **  *      * *   *  * *****   **  *     **  * ** **  ***   ****  *  * * 
** **  *** *   ** * ****  ** **  *   *            * *       *        *  * *    **  **   **   ** * *  *  * * *      * *** 
***  *  **      * ***      * **  ***  * **** *** *** *  ** ** ***  *  * *  **   * * ** *
*  ***  * ***  **** * *   * * ** **  *  * **  *        * *   ** ** *  *  ** * ** **  * 
*     * *** **  * ***** ** ** ***  ** **    **  ** *  *   *  *  *** **** * *  *  
 **** *      *   *      **    **  * *  **    **  *   *** ***** **** **     * *   * ** **    **** *  *** *   * *     
* *  ***   **     * **** **  *   ** * ***   *    **  * ** *  *** *  * *  **  **
* *  *  **** *  * *   **     * * ** ** **  *  *    *      *  ***   ***     
 ***    *  **    ****  *** * *        **  *  *** **        *
***   *    *   * * **  ** ** 
***  ****** **   *  * **  *** **
**  *  ** *  **  **** *   ****   b[c]!='\0'; ++c)
* **     ******* *  * **    ***    
** * *    * ** ***  * * **     * ***  *  ***   *   *   *****  *  ** * ')
** ***  * *   * *   ** ** * ****  * ** **  ***** * ** ** *  *
*   **** ** *** * *   ***   * *    *  ****    * ** * * *  **     *   ***     **  * *  *******  && b[c] <='Z')
*** * * *  *    * ***   **  **     ***    * *   *  *** * * * **     *  ** * 
* * * ** * *****      * **   * * *   ***  *** ** *    **** *    * *  * ** **   **** *    * * * **  * ** ** ******* **    *
 **    * * *     ****   *  * *  * ** **  * * ***   *      *  *** *   ** ***  *    ***   
     **    **  **  ** * **  *   *  *   *  *   ****    **  *** ******** *** ** ***  
     *   * * * * * * *  ******     * * ** ***   *    **   **** ** ** ***  **    **
  ** *  *  ** ***   *  ***  *  * **   **  *    * * *  * * * **  ** *****   ***** * * *     ** *  *     *      *        
    * ***   *** **  *** *  *   ** * **    * *  * ** * *    * *  ** *** * 
*   * *  * **  ***** *  *   *****  * **  ** * ***  **    **   **** ***   *  *   *  *
   * * *** *  * *** *** * ******  *    ***** * * ** **
  ***  *****  **** ** ***  
   // Comparing frequency of characters
 
*** **** ** ****  * *     ****** *    * (c = 0; c < 26; c++)
  *  ** **  ***  * * *  ** **********  ** * * *  
 * ***  *  **  * ** ** **   * *** * *     *** ***  ***** * * ** ** *** (first[c] != second[c]) 
**  **** *   * **  *         *   *       *  ****  * ****  ** *     *  * *** **  ** ** * ***  *  0;
*    * *****   ***  **   * *  *** * *****       * * *
 
  *  *** *** *** * ** **  1;
}

int main(void)
{
*  *** ** *     **  *     A[100],B[100];
* * ****        *  *   **  100, stdin);
 * * * *  *  *   * *     **  100, stdin);
   if (is_anagrams(A,B)) printf("Two words or phrases are anagrams");
***   *       ***  *  *  printf("Two words or phrases are not anagrams");

**        * * **   ****  ***  0;
}

answered Jan 13, 2018 by coach (-258 points)

12-28 Exercise 3: Anagrams function

Please log in or register to add a comment.

79 Answers

Please log in or register to add a comment.

Please log in or register to add a comment.

Please log in or register to add a comment.

Please log in or register to add a comment.

Please log in or register to add a comment.

Please log in or register to add a comment.

Please log in or register to add a comment.

Please log in or register to add a comment.

Please log in or register to add a comment.

Please log in or register to add a comment.

Related questions