12-28 Exercise 3: Anagrams function

Question

12.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 | 12.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