12-28 Exercise 3: Anagrams function

0 like 0 dislike
21.2k 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 | 21.2k 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:104.23.197.94
©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