12-28 Exercise 3: Anagrams function

0 like 0 dislike
15.7k views

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! 

[Exercise] Coding (C) - asked in Chapter 9: Functions
ID: 39986 - Available when: Unlimited - Due to: Unlimited | 15.7k views
0 0
STRUPES!
commented by (323 points)

79 Answers

0 like 0 dislike 
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");
 ** ** *  *      * **  **   **
   **   ** **** * *  **    
}
answered by (323 points)
0 0
Case 0: Correct output
Case 1: Correct output
Case 2: Wrong output
Case 3: Wrong output
Case 4: Correct output
commented by (4.3k points)
0 like 0 dislike 
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");
**** *  * *** ** *  **    * *** ** 
****** *    ***      *  *  * 
}
answered by (323 points)
0 0
Case 0: Correct output
Case 1: Correct output
Case 2: Wrong output
Case 3: Wrong output
Case 4: Correct output
commented by (4.3k points)
0 like 0 dislike 
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;
}
answered by (323 points)
0 0
Case 0: Wrong output
Case 1: Wrong output
Case 2: Wrong output
Case 3: Wrong output
Case 4: Wrong output
commented by (4.3k points)
0 like 0 dislike 
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;
}
answered by (323 points)
0 0
Case 0: Correct output
Case 1: Correct output
Case 2: Wrong output
Case 3: Wrong output
Case 4: Correct output
commented by (4.3k points)
0 like 0 dislike 
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;
}
answered by (-281 points)
0 0
Case 0: Correct output
Case 1: Wrong output
Case 2: Correct output
Case 3: Correct output
Case 4: Wrong output
commented by (4.3k points)
0 like 0 dislike 
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;
}
answered by (-323 points)
edited by
0 0
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;
    ^~~~~~
commented by (4.3k points)
0 0
Case 0: Correct output
Case 1: Correct output
Case 2: Wrong output
Case 3: Wrong output
Case 4: Correct output
commented by (4.3k points)
0 0
Case 0: Correct output
Case 1: Correct output
Case 2: Correct output
Case 3: Correct output
Case 4: Correct output
commented by (4.3k points)
0 like 0 dislike 
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;
}
answered by (-127 points)
0 0
Case 0: Correct output
Case 1: Correct output
Case 2: Correct output
Case 3: Correct output
Case 4: Correct output
commented by (4.3k points)
0 like 0 dislike 
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;
}
answered by (-249 points)
0 0
Case 0: Correct output
Case 1: Correct output
Case 2: Correct output
Case 3: Correct output
Case 4: Correct output
commented by (4.3k points)
0 like 0 dislike 
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;
}
answered by (-249 points)
0 0
Case 0: Correct output
Case 1: Wrong output
Case 2: Correct output
Case 3: Correct output
Case 4: Wrong output
commented by (4.3k points)
0 like 0 dislike 
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;
}
answered by (-249 points)
0 0
Case 0: Correct output
Case 1: Correct output
Case 2: Wrong output
Case 3: Wrong output
Case 4: Correct output
commented by (4.3k points)
Page:
Welcome to Peer-Interaction Programming Learning System (PIPLS) LTLab, National DongHwa University
English 中文 Tiếng Việt
IP:172.69.214.125
©2016-2025

Related questions

0 like 0 dislike
47 answers
12-07 Exercise 3: Function to delete an element from an array
[Exercise] Coding (C) - asked Dec 7, 2017 in Chapter 9: Functions by semicolon (5.2k points)
ID: 35785 - Available when: 2017-12-07 18:00 - Due to: Unlimited | 7.8k views
0 like 0 dislike
45 answers
12-07 Exercise 2: Function num_digits
[Exercise] Coding (C) - asked Dec 7, 2017 in Chapter 9: Functions by semicolon (5.2k points)
ID: 35784 - Available when: 2017-12-07 18:00 - Due to: Unlimited | 8.1k views
0 like 0 dislike
41 answers
12-14 Exercise 3: Fibonacci numbers (Recursive)
[Exercise] Coding (C) - asked Dec 14, 2017 in Chapter 9: Functions by semicolon (5.2k points)
ID: 37370 - Available when: 2017-12-14 18:00 - Due to: Unlimited | 7.2k views
12,783 questions
183,442 answers
172,219 comments
4,824 users