12-28 Exercise 3: Anagrams function

Question

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