12-28 Exercise 3: Anagrams function

Question

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