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