12-28 Exercise 3: Anagrams function

Question

12.7k 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.7k 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