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! 

Show more...

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