12-28 Exercise 3: Anagrams function

Question

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