12-28 Exercise 3: Anagrams function

Question

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