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