11-30 Exercise 3: Various filters on an array

0 like 0 dislike
14.6k views

Write a program that will prompt the user to input ten integer values. The program will display the smallest and greatest of those values. It also displays the value that occur the most.

寫一個程式 輸入十整數 找出最小值、最大值、眾數

Example input:

100 5 5 7 89 62 54 611 1 87

Example output:

Greatest:611
Smallest:1
The most occurring item:5

 

Example input 2:

100 5 5 7 7 62 54 611 1 87

Example output:

Greatest:611
Smallest:1
The most occurring item:5
[Exercise] Coding (C) - asked in Chapter 8: Arrays by (5.2k points)
ID: 34968 - Available when: 2017-11-30 18:00 - Due to: Unlimited
edited by | 14.6k views

55 Answers

0 like 0 dislike 
Hidden content!
#include <stdio.h>
#include <stdlib.h>

int cmpfunc(const void *a, const void *b )
{
** * ** **** * **** * * * *** *(int*)a-*(int*)b;
}
int main()
{
 *        * * ****   * * * * *  i,j,count=0,most,tempc=0,arr[10];
    ** *  * **    **     **** (i=0;i<10;i++)
 ** *** * **  *  ***  *  *****    ****    *  *****  *** * *** ***   ** *** **
     **  *  ** *  ** * *      * ****  * * ** * **  *
 ***  ***** *  *****     *  (i=0;i<10;i++)
    {
** * **  **** *   *** ***** *  * * * *  *** ** * *   * ** (j=0;j<10;j++)
 **   ** *       * ** *    *    *  *** ** * **
* ***  ***   ******* *  **  ***  * **** * * * ** *     **  *  *     *** ** * ** ** (arr[i]==arr[j])
   **    *  *  *  ** **  *    * *     *  * * ** *   * **  * *  ****  *  * * *  * * * * ** *  * ** * * *    ***  * ** 
*  ***   ******  * * *******    **       ** *** *   * *  *
*** *  ***** *** * * *  *     ** **** **  *** ** *   *  *  * (tempc>count)
*** ******  ****  **    * * *** *****  ** ** *  *
   *** **** ***  **** **  **   ***  **  *** *** *  **     ***  ****  *  **  *
**  ** * *****  ** ** * ***  * ****  ***  **   * * * ****  *   **   *** *   *   *  * 
**  ** * * *** *    *  *  ** ***       * * *    *  * *
**  *  * * *** *  **  * ***     *** ** *  ****** * *
    }
*  * ***    ******* **** **    *  *  *  * ***** *  * * * * **   
 ***   ***** * * * *   ***  * **    ****  *   *     *  * ** *** *
    *     *   ***  *  * *  ****  *   *   **  most occurring item:%d",most);
**     *  * ** ** ****    * **** 0;
}
answered by (-249 points)
edited by
0 0
prog.c: In function 'main':
prog.c:40:5: error: expected declaration or statement at end of input
     return 0;
     ^~~~~~
commented by (4.3k points)
0 0
Case 0: Wrong output
Case 1: Wrong output
Case 2: Wrong output
commented by (4.3k points)
0 0
Case 0: Wrong output
Case 1: Wrong output
Case 2: Wrong output
commented by (4.3k points)
0 0
Case 0: Wrong output
Case 1: Wrong output
Case 2: Wrong output
commented by (4.3k points)
0 0
Case 0: Wrong output
Case 1: Wrong output
Case 2: Wrong output
commented by (4.3k points)
0 0
Case 0: Wrong output
Case 1: Wrong output
Case 2: Wrong output
commented by (4.3k points)
0 0
Case 0: Correct output
Case 1: Correct output
Case 2: Correct output
commented by (4.3k points)
0 0
Case 0: Correct output
Case 1: Correct output
Case 2: Correct output
commented by (4.3k points)
0 like 0 dislike 
Hidden content!
#include<stdio.h>
int main()
{
 *  **** ****  ***** *  *    * ** *****   * *** * *  * *   *  
*   **  **  **  *** ** * *** ** ****  ** * *
    {
***     **  *  ** ** * ****  * * ***  **   ***  **  input 10 numbers
**   ***   * ** *  *    ****** ** *  ****  **  * * **       **  *  ** *  ****     * ***  *
    }
    // Part A. greatest number
*** *  *   **  *    ***  *  *  = num[9];
*   ** *    **    **      *    * *   * * **    *
    {
    *  ***** * * *** * ** * * ***  *** **  *   *    ***     ****  *  * * **  
 **** * * *** * ***  *** **  * * *    ***   * *** * ** *
*** * * * * *  ** *     ***** * * *** *  * **  *  * ***** **  **  * ** *****    * ** *******
** ** *   * *     *      *  *   **** *   **  * * *  * *** 
    }
    // Output
**   ** *    *  **  **  *  * ** * *** ** *  * *   * * *   

    // Part B. smallest number
*      *****  * ** ****     *  * *    *** 
** *     *** *   ** * * *  * *** **** ** * 
    {
  *  *  *   ** **  **** * ***  *** **   ***  *  *  **  *  *    
* ******* ***     * * ****** **   ** * *    ** *  *
 ***  *      ****  **   * **   ****       **** **  **  ***  **   ** **  **      * ******* 
 *** *  **    **    * * *    ***  **    *   * * * *** * * **
    }
    // Output
* ****   *   *  *   ****    *****  *  **      *  ****  *** *  ** 


    // Part C The most occurring number
 **  *    * * * ***   * ***   * *       *
    {
* *  * * ******  ***   ** * * *** * *   * ** *    * ***   * *
* *******  *  *  * *   **** ** * **   *  * * ** ** * *  **
********      **** ** * **  * ** *   ***  * **  **  *    * **  ** ***  ** **** ** **  *****  * 
 **  *   *** **  * * *** ****  **** *** **   ** ***   *  ***   ******   *** ** 
***   * * *  **  **    ****   *   *** ** * *    *** **** ******  *   ** *  **    *****  *  **  ****  *  ** *   
   *     *  **   **  *   ** **  *  ****    *  *   *  * * *****  *     * *  * *  
***  *   * * ***      ***   * *    *    **  *   *   ** *  ** **  ***** * ******** *  *  * *  
**     ***   ** ** ** *** *** *****  **** *    *****   * *  ****    *** * ***  **
*  * *  * ** * **      *  * * **** *** *   **  ** *       *   *****   ****  * *  *** * **     **** * **  ****  * *
 ***** *     * **  * * *  *  *   * **      **    **   * *  **  *****     * *  * *** * *  ** ** *  * ***
**  *    **      * **** * * **** ****    ** ** * *   *****  ****** * *    *  * **
**       ***   *     ***** * * *     **** *    ** *     * *** ***   * * *******    * *   * 
  * ** *      ****  * **    ***  * ** *    *  ** ***
    }

*   *   ********* *** *  ** *    * *  ** ** **   most occurring item:%d",num[place]);
**  ***   *  * **      **** *****   0;
}
answered by (-323 points)
0 0
Case 0: Wrong output
Case 1: Correct output
Case 2: Wrong output
commented by (4.3k points)
0 like 0 dislike 
Hidden content!
#include<stdio.h>

int main(){

    int a,b,c,d,i,j,k,num[100]={'\0'},con[100]={'\0'};

 *   *   * *    *    ** ** ** **   * *** **  *  
 *    *   *     **  ****** *  *       ** **  *****  **** ** ***  *  ****  ** * * 
    }

    a=num[0];
    b=num[0];
*   * **        ***  *   * *    *** 
    d=num[0];

** ***  * * * *****   *  ** *    * ** **    *
 **  ****  ***  * ****     ***** *  *    ** **  *** * **   ****** ****   * * *    ** *

   ** * *** *** *** ****   *  *  *  ****  ******* ***   *   *
 ******   ** * *    ** ** *  ***      *    * * * ***  **    ***    ***** ** *** * ** 
    }
***    **  *  *  ** * ***  *  * **  *   * **  **  * * *** * ** ***  *
*  *    * *****    ******   **  ** *  *   *  *    * *  **  *  **   **   *  **** * ** ** ** **    ** 
    }
 ********** ***  *  ** ***   **  **** * ** *   ***
*   ****  *******  ****   *** *   *  * **     * *  * * **       **  **   ** *****   * ** **** *
   * *** **  * *  ***      * * *  ** * *   * *  ***   ** *** ** *******  ** ***   ** **   **     * ****  
*  ***   * * *** ****** * * ** ***   ** ** **** ********** ******  ***    ****   ** 
* **  *** *      ****  *  ***   *  *   * **   *    *    * *        *
  * ** * *** *** *     *   *     * *** ***  **  **  *    * *  *  **   * * *  ***** 
*       *** **   ** ** **  * * * * *  * *****  *  * *     * * **      **** *  *****  *** 
 ***  **  * * *** ** ** **  ****    * * *  *****  *** ****    * *  * **  * **  **    ** *  
****  ****  ** *  **** **   * *   *   **   **** *    * * **  * *** **  

}



 *** * * **    *  **   ******** * **  * ***  ** *****  *
   ** *   ** *  ****  *  ***  * **** *    *  ** *   ***   *
***     *  **   *  *****   ****  ** most occurring item:%d",d);

}
answered by (-301 points)
0 0
Case 0: Correct output
Case 1: Correct output
Case 2: Correct output
commented by (4.3k points)
0 like 0 dislike 
Hidden content!
*  *  * ** ***  
int a[10]={'0'};
int max,min,i,temp,j,k;
int old[10]={'0'};

int main(){

 *  *     * *  *** 
*** ** * **  ***  **  * *  *
*  ***  ** **** ***  *** ** ***   **** ** ****   *  *       * ******  *
**** *  * * *  *  * ** *



for(j=0;j<40;j++)
{

 *** **** *    *
{
   *  ** * ***** ** **** ** * * (a[i]>a[i+1])
 ***** **  * * *   *** **
**** **       ******   **   * * ***  ** * ** ** *** = a[i+1];
 *** * *  * *** * **  *   *** * *  ***      * * * * *  **** = a[i];
  *  * **   ** *    *** ***    ** * ***  * *   ***   *  *  * **  = temp;
 **** **** ***   ****** *   *** * *          *  *  ***   *  * 
  ** *  *** **    ***
}

}
*   ** ** **  ***
* *  ** * ** * ** * *  * ** ** ****  ** * * 
* *     *** ****  **  **   ** *  **  * **     * * ** *     *    * ****

 *     *** **** *    *  ** 
}
 *     *** * *    * **
*** ** * ** ***
*   **** **** * *  **      *
}
int r=1;
   *  *   ***   *  * *
 * *         ******     * ** ** * *** **
  * * *  *** **     *** ** *   * *   **   ** *** ***
*  ****     *** * ****  *  *  

**  * *        ** ** **  ** **

for (i=1;i<11;i++)
 ** *   ********   *      * 
//printf(" %d",a[i]);
** *   *  *  ***  * ** *  
     ****** *   * * ***  * 
 * * *  ***   ** * **** ***  * ** * 
printf("The most occurring item:%d",a[r]);
}
answered by (-336 points)
0 0
Case 0: Correct output
Case 1: Correct output
Case 2: Correct output
commented by (4.3k points)
0 like 0 dislike 
Hidden content!
#include<stdio.h>
int main()
{
 *  *   * *  **   *   * *   num[10];
    int Num[10]={0};
* * * **** **    ** **  max,min,mode,count;
    int max_num,min_num,max_count;
* ** *  *   *  **   *****  i=0,j;
** ******* *** ** ** ** * *  ***  ********** ** * ***
  **  * ** *** **  ***    **  ** * * *   ** **    *  ** 
 *      *    * *  *** ****  *          * 
  **    **  * * *   *  * **  * ***
    *   * *    ** * * ***  *   * **    **    ***
 *** *   ***  **    *    *** * *  ***** 
    {
*   *  * *  ***** *  **      * * ** *  * ***** ** ***   * * ****  *** ** *  **   *** **  * 
*     *  ** * * ******* **    *** * * * ****   **  * ** ** * * ** ** *
   ***  **   *** ****  *  * *** ***  ** *     ** ** *  * *   ** * *  *     * * *  ** *
** * ***  *  *  ** * ** *  * *  * *  **  *     *****  ***** * ** * ***  *    ***   * *** 
* *   *  * ****   ** **** **   ****  * *** ** *   * * *   **** * *   * 
**  *  *****  *    * * *** * *     **** **   *   **** ****  * *   ** *  * * * * *   ***** ** 
  *** * **  * *   *  **  **** *   * ***    ** ****  * ** ***  
    }

* * * ***   *  *  **   * *    ****   *  **** *   ** 
**   ** * *   *** **  *  * **** * ****  *  ********     *** * * *

  ***  ******** ** * *  ** *  ****   *** * *  * 
    {
*   **    ****   ** * ** *  **  *   *  *     * ** * **   **   * ** * * * *
   ** * * ***   ** *** **  *  ****     *   ** ** * ******   ***  * **  **  ***    * 
 * * ***  *  **  ** *    *   *  ***  *    ** **  *****   *
** ****** ** *** *   *** * * * *    *  * * **  *  *  *  *  * ** ****** *  ** * **  *    * * * *** 
    ** *** ******** ** **  * * ***  *   *     * * ***  * *** **  ***  * *  ***   * *
*  * ***  ***  * * * * ** * ** **  ***** **  *   ***** * *  * *      *  **  ** **  *  *      * * * * * ** *    * * ** *  **** * * ***** * *  
  *  *** * * **********   ****   **   *  ***  **    * * * *  ** **  ** *  *      *****

*   * ***** ** *   ** ****** **        **  *   ** ********  *   ** **  
    }
    int occur_num=0;
    /*
 ** *** *   ** *** * **  *  *  (i=0;i<10;i++){
 *** *** **  *  *** **  *   * *   ** * * ****** *   * *** ****    * * ** ********   *   ** *  
    }
    */
*   *  **   ** ***** *  * *** * * * (i=0;i<10;i++){
 ***    **** **  *    **    * *** **  * **  ****  *    *** ****** (Num[i]>occur_num)
***   * *   * *   ** **        * * *** *   **   *  * *   **** **** ********* * *    *** = Num[i];
    }
* * *      *** ****  ******   ** * * ** * * *   **** *** *** * ***

    for (i=0;i<10;i++){
* *  * * **** *   ** *  ***  *  *** **  *       * * (Num[i]==occur_num){
* **  **  *** **  *  * **** *    *   ****  ** ** *****     **   ** *   *  *** ** **   *   most occurring item:%d",num[i]);
     ** *  * *   ****  *** *** * *   *   **   ** * *** * *** * **   *   ** *       **
* * * ***  * **  **  ** ** *  *  **           *  ** * ****  
    }
 **** ***** ** *  **    ***   ***   **  * ***
   *  *  *  *** *** * * *       0;
}
answered by (-32 points)
0 0
Case 0: Correct output
Case 1: Correct output
Case 2: Correct output
commented by (4.3k points)
0 like 0 dislike 
Hidden content!
#include<stdio.h>
int main()
{
    int i,j,k=0,l=0;
    int a[10];
       *   *  ** *** **   * ** ****   ***  *
    {
** ** * *  ****** *  *   **  **  ***  ****** **** **     **  * **********   *  *  **** * **  *  ** ** ******* **
    }
    int max=0;
  **   ** **** *    ** * ** *     *  ****
    {
*  ** * * ****  * * * * ***** ***  * *  *  * * **  ****** *  *** **
**** * * * *  ** ** * * ** **  *            **  * * *  
  **  * * * ** * *   * * ***  ***     *   * ** ***  **  ***     * *** **   *     **  *  * 
      *********   * * *    ***      ***   *** *   ***** * 
    }
    int min=a[0];
 **   ** * ** * **  * ***** ** ***  * *  *   
    {
** **  *  *** **   *********  *** ***    *   *** * * **** * *   ** ****
**    * ***  * *    *** ** * *   *   ***       ** *  **
** **  *** * * *     * ** ** ** **  * ** **  *  * * ** **  ** **    ***  *  * * *** 
*  **   *  * ***    * ** ** *  ****  *   ** *** * *
    }
*   *    *   *     ****   most=0;
    ** ****  *** *****        *  *  * * 
    {
** ******** * ***  ** *** *  ****    **** ***  ** ** ** * *    *
**** *  **  ** * **** * *       **** * **  *    
*** **   ** * *  *  ** ***    * *     *  *   *  *  *    * *    ** ** *  * * **  ** *** *** * *
 *** **  *****  * ****  * *    ** * *  ***  ******   *      *   * ** ***** ***
**        **** * *** * *********    * * * ** *     **** *   * *  *   * **   **  * **  ** * * * 
 * ****  *   *** *** **  *   ***   *  * ** ** ** * *  ** * ** ** ***  *  * 
* ** * * **   *** *   ******** * **  *** *    ***** *   * *  * *
 ** *    *  **  ***  ** * **   ***  ** *    ***  *** *    *     *
 * * * **  *   **         *  * *****  * **** * *  *   ******
  ******* *  *** *  ***** ** *  * **  ** * ** *** ***   *
 **  *** **  * ** ** ***  ** *  * **   *** *  * * *  ****  *  *  * * 
* ** * ** ****  *  ****   *** *  *   *** ** * ** **    
*** *** ** * *  *  ** ** * *  *     ********** *    
    }
   * *  *  ****  * * **** ** ** * ****** *    *  ****  * *****   *    *** * * **  * *
 *  * * ***     * * ** *    * *  * *  **  * * ** *    **  * **     * **  ** *  **** 
***** *  ** *  **  * *** * ***    *     **   **  **  **  * ** *** * most occurring item:%d",most);
}
answered by (-329 points)
0 0
Case 0: Correct output
Case 1: Correct output
Case 2: Correct output
commented by (4.3k points)
0 like 0 dislike 
Hidden content!
#include <stdio.h>
int main()
{
 **** * **  * *  ** ***  *   a[10];
***  * **  * * *** ** * z,max,min,x,c=0,p;
****   ***  **  * ** * * * *  (z=0;z<10;z++)
    {
** * * * **** *   * * * * *  * * *    * **  **      * *     *      ** **       *  *  *    *  
    }
** ***  ** **** *  *  **** ** * ** 
*****       ** **    * **   *  *  *** (z=0;z<9;z++)
    {
**  ***     *** *  ***       ******  *****   *  (max<=a[z+1])
 * *  * ** *** *    **  **  * *****  **   * *      *   * * *
 *    *  **      **  *    *   *     *   ***  *  *   * * **  *  *  ** *   ** *    ** * *
 *** **    **      * **  *  *   ** * * ** * ****  ***     
**  * *** *   * **  **       **
*****  **   * **   ** ***   *   ** *  *  * * * * *  * **    ****
   *    ** * **  *     * **** ** *
  *  *** *  *    **  *  (z=0;z<10;z++)
    {
   *   *  ** * ****   * *  ****    * * ** *     ***  (min>=a[z])
**  *    **    ***  ** **   ** *** ** *  *  * *  ** * **
 * * *   *  **     *** *** *  *  * * **    *   *   * ** * *** *****   *** ***  *** *   * *  * 
 *  **   **** ***  *    * ** *   **** * **  ***
    }
  * ** * **  * ****   **  *   * *********  ****    * *  * 
 * *   *    * **  * *  *  * *  *  b[10]={0};
*  **    *  **  *  **  * * **  (z=0;z<10;z++)
    {
**  *** * *   *    * ** ** *     ****  *** ** ** * *   ** *** ****  * **
 *** ** ****   *     *  **   * ** *    **    * *****  *
  *   **   *   * ** **      *  * * *   **  ***  ****  **  ***      *   **  *  *  *    *   * *
     * * * ***  * *****   *** *    *     *    * *  **      ** ** * * ** *   ** * * *    *  **  ** * * ***  *  * *  
  ** ***    *** * * ** * * *  *    **  **** **  ** *    ****
    }
  ** * * ** *    **     ** *     * *** * 
    {
* *******   **   * *    * *  * * *    *   *****  ** * ***  **  *
** * *  * * *    *  **** **** **   * * * ** ****  *
  * *** * **  **** * ** * ** ** *****   ** **       *  ***    * *  *   * * *  ***   **
   ***  ** **  *  *  * *  *   ** * * **     **  * *  * *  * *    ** *  ***** ** * *   ** * *****  
**  *     ***** *** * *  ** ** ** **   ** * * **  
    }
* ** *         *  *   * * *** ******   most occurring item:%d",a[p]);
  **    **  *    *  * *  * ***  * 0;
}
answered by (-229 points)
0 0
Case 0: Correct output
Case 1: Correct output
Case 2: Correct output
commented by (4.3k points)
0 like 0 dislike 
Hidden content!
#include<stdio.h>
int main()
{
    int array[10];
    int i,n,count_max=1,greatest,smallest,n_max=0,count[1000]={0},place=0;
* *  **   * *    * **  ****   ** ** *   *     *   **  *  ***      * 
        {
*   ** *   * **** * ***  *  *** ** * * * * ** ***** *  * *** *  * ** * ** *  ***** **   **   * ** *     * ****** * 
        }
 * * ** * ** ** ***    * ** **     ** * *  ***   **    * *** **  * ***  *
******    ** **    **** ** *  *    *     *  **  ** * ** *   * *
* * *  ** *** * *    * **  ** **  **   ** *   * ** * ****  
*  *   *   * * * ***  * ** * *  *****  *  *   ** *  ****** **     * ***    ****  *  **    ** *  greatest=array[i];
*  *   ** *  * * * * **  ** **     * *  **  ** **     ***  *    ** * *****  **   *    * **   * smallest=array[i];
*** * *          *  ** *  *** * *   *****  ** * * **  
   **  ***  * ** * *   * * *  ** **** * *** * *** **** **    *****    **    ***  ** *       **  ** *
* ** ***       *  **** ******   ** *   *** *** ** ***  *  *** ****     * * * *  ********* *   **  *
**** * *    * *  ****   *         **** ** **         ********** ** ***
        {
** ** * ** *  ****   * ** * *    *** ****      *     *  *  *      **     *** ***   
 ***  *     ** **     **  **   ***** ** * **  ** *  * **      ******     
  ***    *  ***     ****  *      * * **  * *    *  ** ***  *   *  ***  ** *  *  *     * **    *  * *  * **  ***   ** *  * ***
* *** *  ******** **   **** **     **  * **** ***  *  *   ****  **   *  * *  ** *  *****  * **  * ****    ***   ****  * ** ****
    *  *    * *  * ***   * ***      * * *  **** ****    *  ***    *** * * * *   *    if(count[array[n]]>count_max)
** **  **** * *****  **    **  * * ** * * ** **  * **    * **             * **     * * *   {
*** * **      **     *     * **    ** *    * ** *    * * * ** * ***       * ****      * * ***  *** ***  *  *     ******* **
** * *    *      *   *  ***  **   * * *  ********      *  **** ** *   *  *   **  *  *  * *  ***    *  **   * * * *   *****  ***  * 
  * **    *  **    *   ****** *   * *          * **   * * * * *   **  * **  **         }
*   * **    *** * *  *  ******* *****     *** *** ***** *  ** *  *** **    **   


 * * *  *   **   ***    ** * **       *** ** ***     ** 

 * * **  *   *    **   *  ** **  *** **     *   * ** * * **  ** * *    *  * *  **** **    ** ***  most occurring item:%d",place);

    return 0;
}
answered by (-32 points)
edited by
0 0
Case 0: Wrong output
Case 1: Correct output
Case 2: Wrong output
commented by (4.3k points)
0 0
Case 0: Correct output
Case 1: Correct output
Case 2: Wrong output
commented by (4.3k points)
0 0
Case 0: Correct output
Case 1: Correct output
Case 2: Correct output
commented by (4.3k points)
0 like 0 dislike 
Hidden content!
#include <stdio.h>
#include <stdlib.h>

int main()
{
****  *   * ** **  * *   array[10];

 **** *** * *** * **      **  * b[10] = {0};

    * *  *** *   *   * ****** * *   i = 0;

  *** ** **** **  ** * j = 0;

 * * **  *  ***  *   * * temp = 0;

*      *  **** *  * *  *    **  n = 0;

 ******   * *  * ** *  * **  **  b[i]={0};

****      *  * ***    ** * * *** = 0; i < 10; i++)
    {
**  *  * * ** * ****  **   *** **   **      **** **** ****  *  * *   *    ** &array[i]);
*** **** *** ** **  ****   


** ** * * * * *          ** **  **** = 9; i > 0; i--)
    {
* **  * * **  *  **  *** *** * * *     * **  **   * *   *  = 0; j < i; j++)
**  ***** *   *** *  *  ***********  **  *   ***  *
***  *** **  *     *    *  *** ***           **  ** *  * * * *****  *** **    > array[j + 1])
** * ***  **   **    *  ** *** *  **    *** *   ******  * **** ***   *    ** ** *** *
 **    * *** *** **  * *   * **  *       *   * ***    *** * *  ** **  * **   **  ***  *  ** *  ** **   * = array[j];

*  * ** * * * * * **  ***   ****  *       * * *** ***** ** *    **   ** *    ***   **  * ************ ***     *  ***   * * = array[j + 1];

* **  **  *  * *   * ** * *** *****  ******   * * ****     **  * *  ** ***   ** *  **   *    * ***   *  ***    + 1] = temp;
* *** *  *  *  * **  **  ** * * ***   ** ****** *** *****  ***** **      *     
*  ** * *   *** * **  ** **  *  * **  ****  ***   *  
    }

* *   ***     ***  *  ** *  * *  * *     ** ** *** ** array[9]);

* *  ** *   *  **** **     **** ** * **** ** *  **** *    array[0]);

 ***** ***  * * ***   **   = 0; i < 10; i++)
    {
   **    ** * * *** * * ** *   **    *** *    *   * = 0; j < 10; j++)
    *     *    **  *  **** *  **    ** * * * ****  *** ** 
 * **  * * * * ***      *****  * * *   ** *** **  ***   **** **   ** ** * ** * ** * * **** *** == array[j])
 * *  * *  *   * * *    ** *   ***** *       ***** ** *    *      *** * **  *   
** *** * ** **  * * *  *   *    * * ***  **     *   * *** ***   *  **   ***  ***     ** * ****  * **    ****  ** * *
***     ** ****      ***   *** ****     * ****  ****         ****    *   ** *  * * *  
* **  **  * **  *     ** *  ** * * ***  *  *    **
    *  *  **** **** **      ** ** 

** ** **  ***   ** **  * *** max = 0;

* * * * * *  ** * * * * **   *  * = 0; i < 10; i++)
    {
* *    * *  * ******    **    **  * ** ********** ** **    * < b[i])
* *  * * *   **  ** ** ****** *****  *   *    * 
***   **       *  *** *    *** * *  ** **  *****  **  **  **  * **  * **** * ** *  = b[i];

 *   * ** **   * **  *** * * ** * **   ***  *   ** **  ** * ***   * **    *   *  **  = i;
 *  **** * *** *  * ***   ** *  *  *  ***** *  *** *** **
    }

 * ** **    **  * *     *     * *         *   * most occurring item:%d", array[n]);


}
answered by (-285 points)
0 0
Case 0: Correct output
Case 1: Correct output
Case 2: Correct output
commented by (4.3k points)
0 0
Case 0: Correct output
Case 1: Correct output
Case 2: Correct output
commented by (4.3k points)
0 like 0 dislike 
Hidden content!
#include <stdio.h>
#include <stdlib.h>

int main()
{
   int * ** **         *** *   **   * ** ******** *    * 
**  *  *  *   ****  ** *       ***  
 *    **  * **   * *** *  * *  **  **   *** * ***    *  **
   }
*  *     *   ***      *** * 

 * *********  *  * *  ** * **  **  ****
 *    *** ** * * * * ***  **    *   **  ***  *  *
  * ****   ** *   * *  **** ******  *     ** *  ****  *   * *** ** * 
    }
** * * **     * ***  ***     * ***    **   ** 
**** *    ** **** *** *   * ** ** **  *   **   * *** *** **  *
    }
** * * *    **   **** ***          *    **   ****
***   ** **  *  **    ***** * *  ** ** **** ******   ****  *   * 
  *  *** * **    **  ****   ********   *********   **   *    * **  **   *  **** **   **  *
***  **  ** ****  *  * * ***  ** *   ***** **   ***   ** 
******    *    ****  ***  
  *  * *  *  **** **** *      *   *** * ** ****
* ** *    * * ***  ***   * *  **  *  **  ***   *    **
***  * **  * ** **  *** *  *    **  * * ** *   **  **
    }
*   * **     * *  *  ***   *  ** 
   }
   *****  **     * * *  **  *     * ***   **  ** *  *  * 
***  *  * * *  *   *  * * ** * * * ******  *   *   
*   *     *  *     ****   *    most occurring item:%d",c[place]);
 *   **    *** *** ***  **** * 0;
}
answered by (-108 points)
0 0
Case 0: Correct output
Case 1: Correct output
Case 2: 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.10
©2016-2026

Related questions

0 like 0 dislike
56 answers
11-30 Exercise 2: Rotated Array
[Exercise] Coding (C) - asked Nov 29, 2017 in Chapter 8: Arrays by semicolon (5.2k points)
ID: 34913 - Available when: 2017-11-30 18:00 - Due to: Unlimited | 15.2k views
0 like 0 dislike
46 answers
11-30 Exercise 1: Fibonacci numbers (Array)
[Exercise] Coding (C) - asked Nov 29, 2017 in Chapter 9: Functions by semicolon (5.2k points)
ID: 34912 - Available when: 2017-12-14 18:00 - Due to: Unlimited | 13.6k views
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 | 12.1k views
12,783 questions
183,442 answers
172,219 comments
4,824 users