12-28 Exercise 3: Anagrams function

Question

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! 

Comments

STRUPES!

Answer 1

Hidden content!
#include <stdio.h>
#include <string.h>
#include <ctype.h>
int is_anagrams(char A[], char B[])
{
 *  ** ** ** *   ** * * ** first[26] = {0}, second[26] = {0}, i = 0;
  *     *  *****    *******
 //string 1
 ***** *****      **  *  * ** *  * (A[i] != '\0')
*   * ** *    * *  ***   **  * 
**  *** **   ** *** * * **   *   * *      *   ***  *     * * * * **
 *** * * ** *   ** *  *       *     * *  *  ***  ** *  
  *   **     ******   **  ***
 ** *     * **  *       * *  * 
 *****   * *  ***   *  * ** = 0;
** * **** *   **  *    ****   *** * **   2
   ** *     ** *    * ****  *  * (B[i] != '\0')
*  **  *    ** *   *** ***** 
 *** *   * * * **** ** *     **    *****   **        ***  * **   **** ** *
 *****  ******  ***   ** *** ***      **  *  ** ***    *  
  * *****  ** * * ** *** *  * 
* * **   **      *** *   *
***   ** *  *   **  ** * *   *** *
  ** *  * ****   ***  * *        (i = 0; i < 26; i++)
  *   ** ***    *  ** * ** 
*  *   ***    *   ** ** *    *  *    *** *  *    * * **  ****** * *  (first[i] != second[i])
 * *  *  ** ***    * ***  *  ** *   **  ***   **    * ***   * *  ***  * *    * ** *** 0;
 * **  * * ***** *   *** ***  
 ********* *** * ********  
*  **    *   *** *   ** ** *  ** ** * 1;
}
int main(void)
{
  ** ****      ***    ****   * A[100],B[100];
 * * * * **  *  ** *   *
  *     *  *   **   ** **     * *       * *** A);
******   * *  ***    **    **  ** ******* *  * *   * B);
*** *     **   ****   * * **
 ** *   * *  ** * ** * * * (is_anagrams(A,B))
** **   ***  * *  * ***** **     * * words or phrases are anagrams");
*   * * **  **   **  **  *   
*  *  ***  * *** ** ** **   * **    *    * ** **   **  ****     * **  * * words or phrases are not anagrams");
 * ***      **    *   **    *
 ***  * **     **  * *****  *
}

Comments

Case 0: Correct output
Case 1: Correct output
Case 2: Wrong output
Case 3: Wrong output
Case 4: Correct output

Answer 2

Hidden content!
#include <stdio.h>
#include <string.h>
#include <ctype.h>
int is_anagrams(char A[],char B[])
{
 ** ***** *** *  *  * *  ***  temp;
**   * ** **     **  ** * i, j;
* * **   * ** * ***   *  *** n  = strlen(A);
******  *    * ***   * * n1 = strlen(B);
**** *     * *    ***  ** ***
 *** * *   ** ****   *****  ** n != n1) {
  *  *    ****  ** *    *    ***      * * *    ******* * **   *  0;
 * ** *** * ** * * ** ** 
 *  **      * *  *  *     * **  sort
  *  * * * *      ****  ***   * (i = 0; i < n-1; i++) {
*   * *   * *  ***   **  *   *    *  *  ***** * * *** * ***  (j = i+1; j < n; j++) {
* * * *  * * ** ****  * **** **    *   ** * * * ** *   **   *****  ** ****  **   (A[i] > A[j]) {
*  ***   *  ** * *  ** ***   *  ***    ** ** ** * *  *   *****    * *   ** **  *   * *     ****  *   ** *     = A[i];
* *  *** ** * **   **  ***** * *   *  * **   **  *     * *  * *  *  * **  *               **** ****  ** * *   = A[j];
*** **  ** *** **  ** *** *   *  **       * **  * * ***    **** *      *** **  *********  *** * **      ** = temp;
*      **  ***  *  *  * **  ** * * ** *   ** ********    * * ***    ***    *  *  
**  *** ****  **  **   * ** *   *  *   **  ** ***         ** *   * *****  **   **  * **      *  (B[i] > B[j]) {
* *    **********  * ** **   *******  *  *   *  ***  ***  *  * * *  * *  * * ***** ** * *** *  * ** *  *  ****   ***  = B[i];
   * *  *** *****  *  *  *    * *      *   ****  ***** ***  * *   * ** *    *   * **   **** *     * * *  * * ** = B[j];
*****  * *** *    **** * ** *  **        * **     *** * **     **  *  * ** *  *   *  *  **   **   ** * * *  * *   * *** = temp;
}
 }
  }
*** *** *  ******  *    *   Compare
**  *     ** * ** * *      * * *  = 0; i<n; i++) {
**** *  *  ***** *   ** **  *   **  ** * **   ***   ** * * ***  *  != B[i]) {
 **   * * *    * ** *  ** *   ** *   **  ******* *      * * ***** ** *     * ****  **     *  0;
  * *** * * *     ** *     ** * *** ****        ***  **  **   *
* *** *** ** ***  ** ***** 
  return 1;
}
int main(void)
{
* *    *  *** ****** ** A[100],B[100];
 ******* *** *   ** ***    
*    * ** * * * **  **** *  **     * *   *   * A);
** ***    *   ***** *    *   * ** *     *  ***  B);
*     **  ** *  ** *  **** * 
 *     * ** * * ** *   * * * (is_anagrams(A,B))
   * ***   * * *    ****  * ** *****     words or phrases are anagrams");
****     ***  ** **  *  **
 *** *  ******  *  **  *   ******      ** *  *** * ***** **   ** words or phrases are not anagrams");
*    *   ** *      **   **   
* *    ******  ** * *  ** ** **
}

Comments

Case 0: Correct output
Case 1: Correct output
Case 2: Wrong output
Case 3: Wrong output
Case 4: Correct output

Answer 3

Hidden content!
#include <stdio.h>
#include   * ***   *      
#include <ctype.h>
int is_anagrams(char A[],char B[])
{
** * * ** ** ******  * *   ***   temp;
   ***  ******* * ***** * i, j;
**    * *   * * ** * **    **  * * ** *  n  = strlen(A);
  ** * ******  *   * **   *  *  n1 = strlen(B);
  *  ** * ** *  * ***     ****
* *  *  **   **  *   **  *  * n != n1) {
   **   * ****  ** * ****  *   *** ** *   * * *     * *  0;
*** **** *      * *  ***   
***     ****    *  ***   ** * sort
* ****     * ****** * ****   (i = 0; i < n-1; i++) {
   * **** **  * *   ***  **   **  * ** *********    * **  *** * (j = i+1; j < n; j++) {
  *** *  *  *** *      * ** *  *    *** *    ***       * *   **** **     ** *  ** (A[i] > A[j]) {
 **    ******     * * * * *  *** *     * * *  *  *** ***    * *     **   *****   ** * * ******  *    = A[i];
   ** *    *    *** * * ** ******  ****  * * ** * * * * *** * * *   **** *  * * * **  ****** * **  ***  ** * = A[j];
**  ** ***    * ** **  *   * * *  *  **  * * * *   * *  ****  *     ** * ** **   ** ** *  ** ****  *  *    * = temp;
 **  * **    *** *   ****** **  * *** ****  ** ** * *     ** * ** * ****  
*****  * * *   * * *  *  * *   * *** * ***** **   * *  ** **   * ***  *  **   (B[i] > B[j]) {
      **  *  **       *******      *      *** *** **** **  ****  **   **  *  *  * ***     **     **  *     = B[i];
 *  *  * ** *   *  **  *  * * *  * ** *   *  *  * **   * **   ***   ** * * *  * *   *** ****** **    ***  * * **  **  ** = B[j];
     ****** *****  ** **  **   * * *  *** ****  ******* *  *  **** ***  * *    *  *    **     *   ***  * *   * *   * = temp;
}
 }
  }
 *  ***      * **   ****     ***** Compare
   *  * *****      ** *    *  ** = 0; i<n; i++) {
    * *   * ****     ***   * ** * *    *  **    ** ** *  ** *** *   != B[i]) {
*  * **** *******  * **  * *** *** **   *  **  * ***   **    *  ****  *   * * **** * * *  0;
**  * *  * **   *       *   *  *   **    **    *** *
  **   * * * *   ** *****   
** ***       ****  * 1;
}
int main(void)
{
**     ** *     ** * *  ****   ***  *  A[100],B[100];
*   ***  ** ** *  * * ******  * 
    *** * * *  ****   ***  * * **** * *  **  *  A);
 * ***    *****    **    * * **  * ****   * B);
* **    ****  *  ***  * ***
** *   *   ** ***** *  ** **  (is_anagrams(A,B)) printf("Two words or phrases are anagrams\n");
 *  * ***** ****   **  *  printf("Two words or phrases are not anagrams\n");
     ** ***** * * ** * * **
 *  * ***  *         *  ******  0;
}

Comments

Case 0: Wrong output
Case 1: Wrong output
Case 2: Wrong output
Case 3: Wrong output
Case 4: Wrong output

Answer 4

Hidden content!
#include <stdio.h>
#include  **   *      *    
#include <ctype.h>
int is_anagrams(char A[],char B[])
{
** *  * *  * **** *** * **** temp;
**** * ** *   *     *   * i, j;
** *    **  * *  * **  * n  = strlen(A);
 * *    * ** **  ***    **  n1 = strlen(B);
      * * *  ** * ***
*   **** ** **** *  **  *******   n != n1) {
 * *** * * *  **  * * ***** ** ******   *** **    *  *    ** *  0;
 * * *   ** *  ******* **** **
* **  * *****        ** *** ***  sort
*   * ***       * *    * *  * (i = 0; i < n-1; i++) {
      **   *  * *  **** **** * ***  *  **** * *   **   *  *** (j = i+1; j < n; j++) {
  *    *   *  *   ** ***   * ** *   * **    **  **  ** *** *******    * * ** (A[i] > A[j]) {
* ** *    **** **  *  * ** *** ***     *** *** * **  *      * *   *  ****   ** *  *   **  **  *   *** ****  = A[i];
* *****  ** * * **   *** *  *       * ** *** ******** *  *       **  ** ***** ****** *  ***** *   *   *** *  *     *** = A[j];
*  * * *  *   **  **   ** * **    *** *   *** *    * **** * *     ** ****** *   **   ***** **  *  ******  *** * * = temp;
**  ** ** **    ** *  ** * **  *  *****  * *******   *   **** **   *  *** 
 **** **  ***   ***     ***** *   *   ***     *  **** *    *   * ** **       * * * ** (B[i] > B[j]) {
*****   ** * *  * * *  * *  **** * **    * *    * * **    **   * **** ** *  *   *     * **   **  * **** *    ****    = B[i];
 *    * * *   ** ***** ** ** *  ** * * *******    ** *  **  *** *   *** * * **  **    * ***   ***  *** *   *** **** *  = B[j];
** *  **   ********* * ***   ** * ** *   *     ******* *  * **   * * *   *  **  * * **     ***   *  ** *   * = temp;
}
 }
  }
**   *  *  ****   * *** *** * Compare
       *     ***********     **    = 0; i<n; i++) {
** * **  *  ** **** ** ***  **   ** *   *  **    *  * **  * *  != B[i]) {
  **** ****  * ***  *** *** ***   *  * * * *** ********* *****  *    **   *  ***  ***   *** 0;
 *     * ** ** ** ** ***     * **** * * **  ***   * *** ** *  *
 ** ****** *   *  **   ** 
** *    **   *    * ** 1;
}
int main(void)
{
*    *   *  ****  **    *   **   A[100],B[100];
  ***   ** ****  * **
** ** ****  **  ***  **  * ** *****   * ****  A);
  * *   *   * **   *   *****   *** *   * B);
** *  * * * ** **  ** *   ***  * *   
*** *  ****  ********** * * *  (is_anagrams(A,B)) printf("Two words or phrases are anagrams");
 **  *******    **   *   * printf("Two words or phrases are not anagrams");
*  * *     * ***  * **  **** **
*   **    * **   ** * *  *  ** 0;
}

Comments

Case 0: Correct output
Case 1: Correct output
Case 2: Wrong output
Case 3: Wrong output
Case 4: Correct output

Answer 5

Hidden content!
#include ****  * *  **
#include   ******   ** *  *
#include **   * ****** *  
int ***  ****    A[],char B[])
{
 **     *  ** ****  *  * *  *        * 
 ** *   *   **   * *  * **  YOUR CODE HERE*/
** ** *******   **   **  * ***  **** **   
 **  *    *   * *    *     
* * *  **  **   * ** ***  *  *  **   *    ***       *** **  * * *   *
**       **  *  **  ****** *** *  *  ***  *     * *** ***  ** ****** 
  *******    **   ** **** **      ** * ****  *  ***       *
  ** * **    *********** **  **    * * ******** ** **          ** * *  ***  *   *  *    *    0;
** *** * *** *  * ***    *  *** ****  *    *** *   ** 
 * * ** *    ****  ** *****  *   ***    * * * ***  *    **** return 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)
{
*  ** ** *    *** * **  *   ****      * **
***  *    *   *  * **   *    YOUR CODE HERE*/
***       * ***    *** * **    *
 * * *  ** **  *  **     * *     *  ** *   


  *   ********  ***  **   OF YOUR CODE*/
* ** **** ** * ** ** *****  ****  * *  *   words or phrases are **   **** *  *
  *  ** **** **  * **  * * * *  *     **** * words or phrases are not  **** ***

*  * ** *  *  * ** *  *** 0;
}

Comments

Case 0: Correct output
Case 1: Wrong output
Case 2: Correct output
Case 3: Correct output
Case 4: Wrong output

Answer 6

Hidden content!
#include *  * * **  *  **
#include     *** ***  *
int is_anagrams(char A[],char B[])
{
 * *  * ** ** ****  ** *  * **    * *** * first[26] = {0}, second[26] = {0}, c = 0;

******    * *  ***** * Calculating frequency of characters in first string

****           **   *** * (A[c] != '\0')
* *****  *  ** * *** *
*  **  **  ****  ****  **    *  * *     **    * *  * *  **   * * ***  **  A[c]<='Z')
** *  *** **** ****    **   ****** *     ** 
**** **  * * ***  *  *    * ** ** ***** **   *    * * * * * * *   ** ****** **    + 32;
  **** **  **** **  *  * *  *** * * ** **** ** *
*  *  *  *  *** * * **  *   ** *  *  *    * 
 **   *** *   ** *  **    **   * **    * ** 
**  ** ** *****  *  

** **   **      *   *  = 0;

   ** *   ** **  **  (B[c] != '\0')
**   ***   ** *  * ***  *
**** *     *     ** *** **  * ** * * ***     *    * *    ***  * ** * * *  *** B[c]<='Z')
*** **    ** *    * **  ** *****    *  **  **   
  *   * ** * ***  ***  * ** ** ***  **  ** *  *  *  **   * ***** *    *   ** + 32;
*   *   ***  **** **   ***  **       *  **  **
**      * *   * **    ******* **  **   *** *  ***
* ** *******  ** * * ** * **   ***  **   
     * *  *  *  **** *

    *  ** * * *    *  * Comparing frequency of characters

 *** *  * * *  ** ** * (c = 0; c < 26; c++)
******   *****   * 
** *****  *  ******  **   * * * ***   ** (first[c] != second[c])
   ***   *  *  *   * ****  ***  ******* ****   *** ***  *  ** * **  0;
 *** ***    **  ** 

 **    *     * *     1;
}

int main(void)
{
****** * *** * ** ** * A[100],B[100];

 * **   ****  *  ** ** *  ****
     ** **    ** *** *   ****    * ***


 *** ***** * *     *      (is_anagrams(A,B))      * ***    *  * words or phrases are  * ** * **** * 
 *  * **  * * **     *  **  ***    * ** words or phrases are not  *  * *** * 

      ** * ** *  * *   **  0;
}

Comments

prog.c:5:4: error: expected identifier or '(' before 'while'
    while (a[c] != '\0')
    ^~~~~
prog.c:11:4: warning: data definition has no type or storage class
    c = 0;
    ^
prog.c:11:4: warning: type defaults to 'int' in declaration of 'c' [-Wimplicit-int]
prog.c:11:4: error: redefinition of 'c'
prog.c:1:43: note: previous definition of 'c' was here
    int first[26] = {0}, second[26] = {0}, c = 0;
                                           ^
prog.c:13:4: error: expected identifier or '(' before 'while'
    while (b[c] != '\0')
    ^~~~~
prog.c:21:4: error: expected identifier or '(' before 'for'
    for (c = 0; c < 26; c++)
    ^~~
prog.c:21:18: error: expected '=', ',', ';', 'asm' or '__attribute__' before '<' token
    for (c = 0; c < 26; c++)
                  ^
prog.c:21:25: error: expected '=', ',', ';', 'asm' or '__attribute__' before '++' token
    for (c = 0; c < 26; c++)
                         ^~
prog.c:27:4: error: expected identifier or '(' before 'return'
    return 1;
    ^~~~~~

---

Case 0: Correct output
Case 1: Correct output
Case 2: Wrong output
Case 3: Wrong output
Case 4: Correct output

---

Case 0: Correct output
Case 1: Correct output
Case 2: Correct output
Case 3: Correct output
Case 4: Correct output

Answer 7

Hidden content!
#include ***   * *** 
 ***  * *  *** ***  *
  ***  *    *   ** *  * **
int   *     **  A[],char B[])
{
*  ** ** **         *** * YOUR CODE HERE*/
*  **    * ******* ***** *   * * ** i;
 *  **   *     **** ****  * n = *****

 * * *  * * ** *    ** * = 0; i       n; i++)
 * ***    *** ***
****  *** *** * *  * **** * **  ** **   ***** * * = **   * *
**    ** **** *  *  *** *** *** * **** * *** *  ****
  ** *   * * ** ** **

*** ****  *  ** **   **   *  = 0; i  * * ** n; i++)
  *  **   ** * ****  *  
  ** **  ****   *   ***  **  * **   * *****  *    =  *   **  
*** ** *  ** ** * **  *** * * ****  *** ***  *** * *  ** *
* *** **** **  ** * *

     * *** **** * * ****   = 0; i < 26; i++)
** **     **  * *  * 
 **  ***              ***  **  **  * * *  ** * *  * ****  != b[i])
* *  *    ********* ***** *** **  **  * ** ****  * * ***  **   0;
* *    ***   **    *   **
  **  *** *****     ***  1;

** * ***      *  * *  **  OF YOUR CODE*/
    * *  *****   * * *    * * ** should return 1 if two words or phrases are ****     0 if two words or phrases are not   * * 
}

int    *   
{
 * ** ** ** *  * **  * **    *** * *
*  ** ** ***   ***      YOUR CODE HERE*/
* ***    ** * * *  ***  *   100, stdin);
 ***   * *     ***   ***   * * *  * *   100, stdin);

**       *  **  **** OF YOUR CODE*/
  **    **    *** ***    ***  * *   *  *      ***  words or phrases are ** * ***  
* * ****** ** *  ** *       **  **  * words or phrases are not * * * **   **

 * *   ******* * **** * *  0;
}

Comments

Case 0: Correct output
Case 1: Correct output
Case 2: Correct output
Case 3: Correct output
Case 4: Correct output

Answer 8

Hidden content!
#include ** * * * **
#include  **  * ** * ** ***
#include   ** *   ***  
int ** **   * a[],char b[])
{
 * *  ***  ***  ***** first[26] = {0}, *** **  = {0}, c;
 **** *   
  *  * * **   * *   **   **  *** frequency of   * *  * in first string
   * * *** *   for(c=0; ** *** * ++c)
  **    *** * * *  * * ** ** ***** 
  *** *  * * * ** * * ****      **  ')
*   * *** * ******  *  * *  * *   {
*     **  **  **    ** * *        ** * *  **  *   **       *   *  * ** a[c]      **
****   * * *** *  *  *    *   *   * * **  {
  * ****  * *  *    *   ** *    * ***   **  ** * ***     * * ***** * *  
  **  ***  **   ** *  ** **  **    *** ******  }
* ** *** ******  **  *   *****  *  **  ***  * else
** *       *   * *      * * ** * *  **  **   {
 *  **                * **   ***   **     ***   
*  * * *  **  *   **** *     *** ***       **  }
*  *  *  *  **  *    *** *  *** ****  **       **   
  **  * *  ***  * *** ** * *   }
   * * *      *  }
* * ****  ***    
******  ** for(c=0;  * *  * ++c)
 ** * **  * **      *  *  **  * *    
*****  * ** * *   *    ***  * * *  ** ** ')
 *** *  *   *    **   **   ** {
* *    *******   *  *  **** *  *  ** *  *  *   * *   *     *   * ******  *  b[c] **  * *
***   *   **  * *****   * *  **** *     **   * * ** {
* ***  **  * **    **    **  *** * ** *   ***    **     *** **   *   *  ***     *
**  *    *   **  * *** **   *  ** **    }
   * **   **** *  *    * * * *** **  *    *    **   else
   **   ** *     *    * *     **  *    ***  {
   *       **  *  *      * * ** **   *   *    * *   *       **** *  ** *  *** ** * *          
   ****   *   ** ***   *      *  **  ** *  *  *   *  * }
**     * *  *** ** *  *  * ***  ****  ***     
 * *       * *     ** *  }
****    **** *  }
*  ***** * *  ** *   Comparing frequency of * *** ***
**  * * 
         * *** **  ** *  * * for (c = 0; c < 26; c++)
**    * *     **   **  **  *   
** ** **   *     * ******   * *** *** ** *  *  * ***  (first[c] !=  ***   
 ****** *   **    ** *   ** *   ***    * * **   **   * *  *****  * **  *  * ****  0;
******** **  *  *      * **   * * * **  *** 
* *   
 **  *    *   *    ********   1;
}

int  ****
{
* **  **    * *  *****  ** *  *
***     *** * ****** ** * *  100, stdin);
 * **** *** *    ** * ***  100, stdin);
 **   **     * * * * *** * *** ** * *  *   * words or phrases are  *  ******   
*****  **   ** * ***  **         * **** words or phrases are not    ****   *** 

  **    ****  ***   **    * 0;
}

Comments

Case 0: Correct output
Case 1: Correct output
Case 2: Correct output
Case 3: Correct output
Case 4: Correct output

Answer 9

Hidden content!
#include     **  * **    *
#include *         ***** *
#include *  * **** * 
int ** * ****  a[],char b[])
{
* *  *  ****   ** ** first[26] = {0},   **    * = {0}, c;
*  * * *
 *** ** * * * * ** * **    * ** frequency of ** ** in first string
 **  * 
 ***   * *   *  **** * * *  ***** **  ******   ******   ** || *    * ** * * *        **    * *     || a[c]!=' ')
***      *  * **  {
 *    * ** * * *   *   * ** *** **** for(c=0;     * *   ++c)
* **  *   *   *** * *  *   *   ** *   * *  * *      ****  ')
*  **       * *     *   *  * ***    ** * ** {
* ****  **  ** * ** * **** ** *  ***   *  **  ** * * * **   ****** *   
** *  *    * ** *      * ***   ****** * ****  }
* * **    ***       *      * * }
 *  *  * * * }
   ** * * *** *** 
    ** * *** ***   *    **  ***   ** * *  ||   * * **   * ** *********      *  * ** * || b[c]!=' ')
*    *  ** ** * * {
 *  *****    *   *   ****  **        ** for(c=0; **  *    ++c)
 * * *   ** ** *****  * * **  {
  ** * *   *  *   **   * ****  *** ***     *   ***** ')
****        **  **  ** ****   * **  * *  {
*    *   *  **  *****  *   * * *   * *  **    *    ** *   * * *  *  *   *   *   **   *   * * ***  
** ** *   *** ** *  * **  ***   ***   *  * ** }
 **** * *  ***   *  ** *** **** 
** *** **  * * ***** *   ***   * }
*** *   *  *** }
  **  **    ** * 
******* *    **** *   * Comparing frequency of ***  * * 
* * *  
     *** ******  * i;
 **   ****** **   *    **  *** *  
* ** **** * *   * 
* * *      *   ** * ****  *  *   **** * *   ** *   if(c==i || c==i+32)
*     *  *  *   **  *** **      *  {
   ** **      ***   * *****    **   * ** ** **    for (c = 0; c < 26; c++)
* *       *** * ***  ** ** *** ***  {
* *  ***    *    **** * *    ***   *  **  *  *   *** *   *** if (first[c] != *  *  
*****  * * *** * ******     **    * *** ***    **  ** * *****  return 0;
* **  * * *     * ** *     *  *      * *  * ***   * ***  
     *  *  ****   *  *  *******  }
* **  **  *  *** **    *
   ***   *   *
 *  **** 
  **** * ** *    * ***   * * 1;
}

int * ***  
{
***** *   * **    * **     *  * * ****
* ** ** *** ***  **    ** 100, stdin);
 ** * *   *   **  * **** * 100, stdin);
    * ** ****    * * ** **  ** ***  **          words or phrases are    *  ** *    **
  * **** **  * **  *  * * *  * * *    words or phrases are not    ******    **

   ** * ** ** *    ** * 0;
}

Comments

Case 0: Correct output
Case 1: Wrong output
Case 2: Correct output
Case 3: Correct output
Case 4: Wrong output

Answer 10

Hidden content!
#include ***   **  ** **
#include *  *     *      * *
#include *** *  ** ** ** **
int   *  *** *  a[],char b[])
{
** ***** * ** * *  * * first[26] = {0}, **  = {0}, c;
  ** *  
 * * * *   **   * *     ** * * frequency of **  * in first string
     **
* * * * **    for(c=0; ****   ++c)
** * **  * **     ***  * *      **  ')
  *** ** *     **  *    ** {
 * ****   *     *  **   * * *****   * ****    **   * ***  
* *****  *   * ***   ***  **     * }
* ****   *    *  *  * * ***  
 * *  **   ***  }
   *** * *    ** * * *
  * * ****  * for(c=0;  ****   ++c)
*  * * *** * ***  {
  *  *  *  ***   ******* ***** *  ')
**  *  *    *   ***  * * *  * {
   *     *  ****  **  *  **    ***  * *   *** *  *   **   ** ***** ***  ** ***   *  * *   
    ** * * *** **** **** ** }
********  **       * ****  * *     * 
* *   *  * * }
* *  ** *   * **   **  ****** **  * frequency of   *   
** ** ***
* * * *** * *   ** **  *  * (c = 0; c < 26; c++)
* ** *** * ** * **** 
 * *   ***  *  *******          *  **        **     **   !=   **  
** *   *     *   ** **** ** ** ** * ***    *** ****  *  * *    * 0;
 *  ******  * ** *
*** ****  
*** * ** *   **     ***** 1;
}

int *** 
{
***  * * ** **     * **  *   **   
**  **** ********  100, stdin);
*    ** **  **** ** *  **** 100, stdin);
 *    *** ** * *** *    * ** **    ***  * ** * words or phrases are *  ** * ***
*   ***  *   **** *     ****  **  *** words or phrases are not   **** **   * 

****** ***  *   *  * 0;
}

Comments

Case 0: Correct output
Case 1: Correct output
Case 2: Wrong output
Case 3: Wrong output
Case 4: Correct output