12-28 Exercise 3: Anagrams function

Question

16.2k 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 | 16.2k 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