12-28 Exercise 3: Anagrams function

Question

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