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