12-28 Exercise 3: Anagrams function

0 like 0 dislike
21k 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 | 21k 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:162.159.115.32
©2016-2026

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 | 11k 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 | 10.5k 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 | 9.7k views
12,783 questions
183,442 answers
172,219 comments
4,824 users