11-30 Exercise 3: Various filters on an array

0 thích 0 k thích
5.1k đã xem

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) - đã hỏi trong Chapter 8: Arrays bởi (5.2k điểm)
ID: 34968 - Xem được từ: 2017-11-30 18:00 - Hiệu lực đến: Không giới hạn
đã sửa bởi | 5.1k đã xem

55 Trả lời

0 thích 0 k thích 
Hidden content!
#include<stdio.h>
void sort(int a[],int n)
{
    int i,j,temp;
* *   *   *** **  * *  **  * **** **       * 
    {
** * * *  * ****  * ** *       *   *   ** *    *       * * **   ***
   * * * ******* *  ***** *   **  *  *   ***     **  *
    * ****    * * ** *   * ***    **   **  ** ***  **  *  * ** ** *****  ** *            *  
   *   *    ******  *  **  * * *****  * **** **  ***        * *  *    * *  
 * * ** **  **  *  *    ******       ** *  *  **  *  ** ****  **** **  * ***  *   * ***  **** * *****   * **** **   *
* *     ** *    ***     * *     *  ** * **** ** * *** * ***** * ** ** ** ** ** *  ** * * *** ** *****   * * *
* *   * **   ****  ***    *  *  *   * **   * * ** *   * * * **   * *** * * **    * *** ***  ***  * *   *** *     *
  * **** *    *  * * *   **  ****   **      *  * **   ****  *  ****** ** ***   * * 
  **  *  * *  ***    * ** *     * * * *   ** *** 
    }
}
int search(int b[],int n, int j)
{
    int i;
   ***** ** * *  *  ** ***********
    {
 *    *   *  **  *****  *    * ****     *  **  **** *****      * * *  
* **** *** *  *    *** *  ***   **** * *    ***** *
  ***   ** ** ** *  * *  * **       ** * * *    * * ********* ** *** ***** *** * *       ** i;
***** ** *** **     *    *** ***  *  * ** ** ** ** ***
    }
    return 99;
}
int greatest(int a[],int n)
{
    int i,g;
    g=a[0];
 *     *****    *** *  *       ** **   * *  
    {
 *     *     **** * * ***   * ** * * ** ** ***   *** ****   **   
*** *  ****** ***  * * **  **** ** **  ***** ***  ***  
*    ***  ** *  **      *  **    * *** * ***** * * * * * **** *   *** *** * **
  **** * ***    * ***   * *       * *  *  ***  * ***** 
    }
    return g;
}
int main()
{
    int a[10],b[10],counter[10],o[10],i,j=0,k,n,g;
   ***   **     ** ** * * ** *****  *   **
    {
*** * * * * **      **  * * ***   * ***    *    ***   * *    *
*  ***** * ***  * *  ** ****** **** *** * * * * * *
** *   * *         *    *   ***    *    ***   ** ***** * * *** *
*  * *****   *      *   *    **  * ** ****  ***  *  ***  
    ******** *   ***     ***      * * **** *****   *  *  *****  ***** ** * *** * *** 
    }
    sort(a,10);
 ***  * * ** **    *  **  *  *     * *    * **** ** ***   * 
**** ** ** ** ***  *****  *    ** * *  ****  *    * ** *** ** *  ** 
  ****   ***   *  **  ****   ** **  *   ******
    {
 *     **   *    *  **********  *  * *  *** ** *
*******   ***  *** **   **   *  * **  **  ******* * **       *** *
* * ** * *     ** ****** *   *  * ***    *  ***   **  *    * 
****  *         ****    ***   **  * * * **  *  *****   ***
**   **  * *  * *   *********** **   *** **** * ***** *     *  *  * ** **   *** *  *** *
* * * * **    ***          * *  ***  * *   * *   *  * *  
*** **    ** **** ** **    * ** **  **  *   ** *** * **
 * * *****   ** ** * ***  *** * ** *  **** *
 *******  **    ** * **     *  *   *    **  *****  **   **** * ***  *  **   ** *     * 
* ** **** ***** *** **     **    *  **** * ** ** * *** * *    **   ***   ** *  ***  * **  *
*  *  * *** ** **     ** **** * *    *  *****   ** **  ** **   *  * *  *       * **    
**   * *  **  *** *** *** ***   ***  **** *   **  *   *  
    }
*****   * *  ****** *  ** **   *     
* ** *****    ** * ****  ***** * ***  **    most occurring digit:");
 * *********  *   *   **    *   *  *      * 
    {
    *** * *** *  *  *     ***  *** ** ** *   ***  * *  *   *  
*  *        **   ***   ** *  ** * * **    ** ***     ****
**** *  *  *     *   ** **** ** ** ** **** * **  *    *** * ** *  *  ** **        **   *  * **   *     * ******  **  
***  ***  **         ***      * ***  ********  * ******  ** *   ***** *  *  *  *  *
 ********* * **   *     ** ***  * ** * *  *  *****  * * **** 
    }
}
trả lời bởi (-255 điểm)
đã sửa bởi
0 0
Case 0: Wrong output
Case 1: Wrong output
Case 2: Wrong output
Case 3: Wrong output
đã bình luận bởi (4.3k điểm)
0 0
Case 0: Wrong output
Case 1: Wrong output
Case 2: Wrong output
Case 3: Wrong output
đã bình luận bởi (4.3k điểm)
0 0
Case 0: Wrong output
Case 1: Wrong output
Case 2: Wrong output
Case 3: Wrong output
đã bình luận bởi (4.3k điểm)
0 thích 0 k thích 
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;
}
trả lời bởi (-140 điểm)
0 0
Case 0: Correct output
Case 1: Correct output
Case 2: Correct output
Case 3: Wrong output
đã bình luận bởi (4.3k điểm)
0 thích 0 k thích 
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;
}
trả lời bởi (-66 điểm)
0 0
Case 0: Correct output
Case 1: Correct output
Case 2: Correct output
Case 3: Wrong output
đã bình luận bởi (4.3k điểm)
0 thích 0 k thích 
Hidden content!
#include * * ** ***  * * * 
#include  ** ***** *****
int main(int argc, char *argv[])
{
   * * *     *   arr[10];
 * *     ***** *  mode[10][2];
***  *  *    **** * * %d %d %d %d %d %d %d %d * **  ** ***  **  &arr[1], &arr[2], &arr[3], &arr[4], &arr[5], &arr[6], ** * ** ******  * **  *  *   *  *

 int i,j,temp;

** *  *    * * ***
*       * ** * * **  **** *  ***  * 
**    ** **   **   ** * *** ********  ***  **  ** ** * {
* * *  **  * **** * ** *  *    ** *  ** ***    * ** * * **** * *  *    temp=arr[j];
*****  *  *** ** *     ***   *    **  *    *     * ** * **  * * * * ** ** * * * 
*  ** *   * ***  *  ***  * * **  * *     * * **  *    ** **  ** ***  * **  ** 
 }

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

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

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

int max;
int k=0;
max=mode[0][0];
  * **  *     **  **   **   *   *   ***
* **   * * **    *  * * * *** *  ** ****  *  *  ***** *    

*** * ******* *   * *** ***   most occuring *   ******* ** *
 *  ****      * ** *** 0;
}
trả lời bởi (-168 điểm)
0 0
Case 0: Wrong output
Case 1: Wrong output
Case 2: Wrong output
Case 3: Wrong output
đã bình luận bởi (4.3k điểm)
0 thích 0 k thích 
Hidden content!
//
//  main.c
//  midterm
//
//  Created by 蘇沛潔 on 07/12/2017.
//  Copyright © 2017 蘇沛潔. All rights reserved.
//

#include <stdio.h>
#include <stdlib.h>

int main()
{
 ***** *   ** * **  **  ** *   **  a[10],Greatest = 0,Smallest = 1000,i,j,x = 0,y = 0,k;
******* * * *  **** ** *** * * *** = 0 ; i < 10 ; i++)
 ** * ***    *   * *  **  * * * ** * *   * * *  **  ***  * * *  *    *  *    **      * 
  *** * *   *      * **   *   *  = 0 ; i < 10 ; i++)
***   ** ** * *   *       
* * **** *** ***  ***  *** **     *  ***  *** *   **  * **** * ** > Greatest)
     **  *** *  *** *     *  ***** ** ********  ***  *****  ***  * ** ** * *       = a[i];
 *  *   * ** *   ** *** *  **  ***** *** * * * ** ***  *** *   ****   < Smallest)
***  * *** *   ***  ***** **  *      ** *  *   * * ***  * ***   * **  * * *     * **** ** *  * = a[i];
**   ** * *********  *    *
    ** **    *  ******* * *  * *  *** *** *****   **  *  ** ***   
*  **  * * * * ** *******     * ** *******   **  * **  *  *   *
   ****     * ******    * *  **
*  ***  *    **   *  *  = 0 ; i < 10 ; i++)
* *    **    * * ***** ******
* *  ***  ** *** * *****     **** ******  ***  * ***   ***     *** = 0 ; j < 10 ; j++)
*  ** * *** *    *** ***   * **** *****  *  ****   **
  *  **** * * * *  * *   * ****  *    **  **    * **** ***   * *       * *****  * * ** *****  == a[j])
 * ****   *    **   * *  ******* * ****  * * * *** ****  ***    *  * * ** * ***  ** * ***   **** **      
    *     *   **    *** * **  * *  ********  **  ** *
  *       *****      * ***  **** * **   *  **    * **** ******  > x)
   ** *  **  * ****     * *  **  *  ****  *  * ** *   *
 *      *    *** *  *    ****** *  * *    *    ** ***     * * **    *** ***  = a[i];
     *** * ** *** ** **  *      *  *** *    * * ****** *   * *** *** *   = y;
       ** *   *    * * * * ** *** *   *  ***    
 * **    *** *  **** ****  ***** ** * *  *** * *    = 0;
 *** * * *  ** ******** **  *
* *    *****     * ***   *   ** *  * * * ** most occurring item:%d",k);
** **      * **  ** *  *  *
* ** * ******  * ** ** *  *   0;
}
trả lời bởi (-127 điểm)
0 0
Case 0: Correct output
Case 1: Correct output
Case 2: Correct output
Case 3: Correct output
đã bình luận bởi (4.3k điểm)
0 thích 0 k thích 
Hidden content!
#include<stdio.h>
int main(void)
{
    int tab[10],i,j,o,b,a,g,s;
    a=0;b=0;
    for (i=0;i<=9;i++)
    {
* * * * ** **    * *  *   *        *    ****  * ** ** ****** ****    **  ****    *
    }
*   ** *   ** *  *  *    *** **   * *
    for (i=0;i<=8;i++)
    {
    *** ***    *    ****    *  * *     **  **   (j=i+1;j<=9;j++)
 *    **     * ***  *  ** ** *  ** *     ***** *
  * **** **       ** *  * **  **   *********** **  ** **  * * ***   ** **  (g<tab[j])
 *  * *  **   *   * * **   **    **  ** * * *  *   **      *** ** *** 
* ** **   *  *   **** *** ** *****   **  **** **** *  ***  *   ***   * *    * **  ** * *     **** ***   ** ***      ** * 
 *   ***  **   *    **** *   *  ***** ***   **    *  ***  ***  * **** *** *** **   ****  ****
 *  ****     ** *** **   *  ****     *  *   * *  **** *   ****     **  *** ***** * * * 
    *  *   * **  **  *  * * * **  * * ** *  ** * ** * * **    * ****** **  * 
 * * **     **    *   *** **  ***   * *  **  ** **** **  * *   *  ** *** ** *        **   * *   ****** **
    *  ** *** **** ** * * **  ** * **    * ** *   **  *  *  *  * ******   *          ***
 * * **  ******* *  *  *  ** **  ** *  *  *  *  **  **  * *** *** (tab[i]==tab[j])
* ** *    * ** ******** **   * ** **** **   * *     *  * *  * * **** **    ** *   *
    **   **      **  **** *  ***  *** ** *    * **    *   * * *      *    **  * *           *  *      
 *  *  **   * ** * * **  *    ** *  ** ** *          * *    **     * ***** ****    *
   ** **  * ****  * *  ***  * * * * * *  *     * **    ** 
***        * ***   * ****    * *     ** ***   *   ** *
**** **     *  *  **** ****  * *  **** **** *   *  * 
  * *   *     * * ****  ***  **     ** *  ****     *** **  * ** *** * *** **   *  ** **
   * ****  *********   **      *  ** ** ***  ** ** ***  **** **  *   *  ****  * *   *
      *    **  ** **    * *   *  *   ** * * ***  **  *  * * * * 
 * *  *   **   **  * * **  ***     *  **     **  * ** *  * *  *

    }
* * *    ****     ****    *****    **  **   * * * *     * *
** **   *  *  *** * ****    * ** *  * *    *** **  **    
********  *  *   *  *** * ** *  * *   *** *     most occurring item:%d",o);
    return 0;
}
trả lời bởi (-168 điểm)
0 0
Case 0: Correct output
Case 1: Correct output
Case 2: Correct output
Case 3: Correct output
đã bình luận bởi (4.3k điểm)
0 thích 0 k thích 
Hidden content!
#include<stdio.h>
int main(void)
{
    int tab[10],i,j,o,b,a,g,s;
    a=0;b=0;
    for (i=0;i<=9;i++)
    {
 * * ***  * **  *  *  * **      * *****   *  * *  *  *** ****  * *  ** * *  * ** *** *  ***  ** * **
    }
  * * *  *        **  *****  *  ** * **   **    * 
    for (i=0;i<=8;i++)
    {
** * ***  **       *  * * *  **** **    *****  *   **   (j=i+1;j<=9;j++)
****      ** ** * * *  **    *  * *  *      *** *  **  
*  *   * **  *** *  *  ***  *  **  ***** ** * *** * ****** **  * * ***     * * **  **   (g<tab[j])
*  *    *  ***  ***  * *     *  ** **   ** *   ***** * **  ****   *** *   * *   *  ** *
 ** *  ***  *** *  *   **  ***   *      * **  *  ** **  * **** **  * *   ********* * * **** ***  *   *  * * **
* **   **  ****   **  **     *    *  ***** * **  * ** ***  **    *    **  **   *  *
*** ** ***** *** *    *****  ** *  *  *   **** **** **      ***     *** *  ** * *  ***       *** * 
*   **    ** ** *   * *  ****  ** *******  * *** * * ***  * *   *     **   ***  *   *
 * * **  ** ***  ** *   ***  *  ** **       ***  **   *  **** ** **   ***** * *  * **   **    ****   * *   *** *
*  **  *  *  * * ******  * *****  * **  **** ***  ***  **  ** *     *   * **   * *   **  *
*  * *  * *    *    *   *    *  **  ** ***** *   * ***  **  *      *** * * (tab[i]==tab[j])
  ** * *  ***  *  **  * ******  *   *****  * * ****   **** ** * ** * ***     *
 *   *  *  *   *   * * *   *******  ***** **   **   *    ****  ** * *  * ** **** * * ** *    *  *  *** ***
********* ** * ** * ** * **   ****** *  *  * **  * * ** **   * * *   *  *****
   ****   * *  * * *  *     **   ** *      *  ***  *** 
 * * **  ****** ****  **   **  ** *  **     **  ***  * * * ****
*     *** **  *   **  **** *  ***  *  ***   
      ***  ** *    ** *  *  *  *  * * **** * ** ***       *** **  *** ** *   *  * **   *
 *   * ** ******** * *    **  * *    ***** * *   * ****       * * *   ******   **    * *
* * *****  * **  * *      *** *        *  *   *    **  *  

    }
  ***   *  *** **** ** ***   * * ** **      ** **  *****
*  *  **  ******* * *****  **** ** *    ******* *  ***   *  *** *  
 *** ** *  **  * **   **   * ***** ** most occurring item:%d",o);
    return 0;
}
trả lời bởi (-168 điểm)
0 0
Case 0: Correct output
Case 1: Correct output
Case 2: Wrong output
Case 3: Correct output
đã bình luận bởi (4.3k điểm)
0 thích 0 k thích 
Hidden content!
#include<stdio.h>
int main()
{
    int arr[10],i,greatest=0,smallest,j,counter=0,place=0,num=1;
    for(i=0;i<10;i++){
 * * *  * *****  *** *  **   *         *  **   ** *   *      *    * *    **** * *   *  
    }
    smallest=arr[0];
    for(i=0;i<10;i++){
*  *** **  * ******  *  *  **** * *      ** ** * *** * ** ** ** *   **** 
  *** *  *** * **  * *    * *    ** *  *** *
***   *******   *  ***   *  *** * **  * ***  *   * * ****** * *** * *     * * ****  ** ***
  ** ** *  * * *  ****  **   * *  * *   **   * * * * *
 **** **** * *   * ** *   **  **** ** *** **   *** *  **   **  
 * * * *  *  * * * *     ***** *    **  *  **  ***
  **  * * * **  **  * *  ** ** *   *** **** * ***  ** **  * * * * * *  *  * * *** * *
*  ** **  *   * ***         *  * * * ** * **
    *** *  *  ******     *** *    *      *   * ** *  *       *** **  *
      ***   **   *  ** *** * *** ** ** * ***  *  ****  **
** *** **** * *** **** **  * ****    ***** * *   ** **  **    ** ***** *  * ** *    *    *
  * **     ****   * ******      * ***  *****   *    **** **      ** *** *   ***  **** *
***   *** *   ** ** *   *  * **  ***    ** *     *  ***   * **  * ** ***   *  ****** * ***   * *****   
*   **      * * * * **** *  **  **    * *  *    ** *   **     *   * * ******* ****   *
   ***  *  *       ** ****  * ****** **  **** *  **  *  ** ***
* *  *  *****   * **  ** *   **  *   *** *** * *   * *** ****   *  * * *********  ** * *       ***     
****  ******** * **** ***** **   ** * ****     *  *  *   *   **  * * * **     * **
  ****   * * ** * **  * *        * ** *  *** ***** ** ***  *  *    *** ***  ***** *     ** * *** ***   *  ***    
 * * **** *   ****  ** *  ** ****    * * **     ****** ***   * *****   * ** * ****   **** ** * **   *   **** ******
 ** **** ***  ** ** * *   *    ***  **       *        ** *         **  * *    **
**   **   **  ******    ** ********* * *** ****  ***  **  * *  **  *   **  * ***  *
    }
   *   * ** ***** ** ***** * *****  ** *     *****   ** ** 
*  **** *** *** *   *    * **    *   **  * * * * *** *  
    printf("The most occurring item:%d",arr[place]);
    return 0;
}
trả lời bởi (-323 điểm)
0 0
Case 0: Correct output
Case 1: Correct output
Case 2: Correct output
Case 3: Correct output
đã bình luận bởi (4.3k điểm)
0 thích 0 k thích 
Hidden content!
#include <stdlib.h>

int main()
{
***** * *  *  * * * **  *** a[10],Greatest = 0,Smallest = 1000,i,j,x = 0,y = 0,k;
     *    ******   ***   *** * = 0 ; i < 10 ; i++)
  * *   ******        ** * **      ** * *    **  ***** * ** ** * * **  * * **   * *   *  *** *
 ***  *  *  *** **   ** *  * = 0 ; i < 10 ; i++)
 * *   *  * * *  ****  *   
  ****  ** * * *  ***       *     * *     *  ** * *   > Greatest)
 * ***   *   **** ***  ***  **   * **  *   *****   *   *  ** *   * **  *** *   **  = a[i];
  *  ** * * ** **  * **  **  * *** * *   *** **  ** *** < Smallest)
 **  **  * * ***** *  * *  * * ***   ** *** ***    ** **   *  ***  **      * **  **   * = a[i];
    }
 *    * * **    ****  *****  *  *  *** * *   *    ** ** ****
*  *  * *  *    ****   ** ****** ** ** *   *    ***** * *  **** * * * *

  ****   ****  **  ** ** ** = 0 ; i < 10 ; i++)
    {
      *  * ***** **  *****   *   * ** **  *    * ** ***  = 0 ; j < 10 ; j++)
 *   ** * ** ***** **   ***   **  ***** ** * ******* *
** *****  ** ** ********   * ****  ***   ***    **  * ***  **     ** *   ***  == a[j])
* *  *  * **       *  * *     ** **    ***   *   ** * * ***   *  * ** *        * * **        *  *  *    ** **    
 * * *   *   * *  ** *** ***  *    ** ********  ***  *** * * ** 
 *   *  ** ** ** *  * **   **  **   * * *   ***     *  > x)
 * *    ****  ** **  **   ** ***  ******* *  * * *   ***
      * **  ***        *   ****** *** *  **    *  * ** ** ****     ** *   * ***         * = a[i];
 ***  *   **      **  *    * * * ***       **** **  *   * ** *  *** *  ****** *  = y;
** *  **  *   ***  ***    *** * * **** *** *** 
*** *   *    ****   * *   *  ** **     *   *    *   * *  * = 0;
    }
  * *  * *  *    *  *  ****    **   most occurring item:%d",k);

* *  ****  **    *     *    ** * * 0;
}
trả lời bởi (-127 điểm)
0 0
prog.c: In function 'main':
prog.c:7:9: warning: implicit declaration of function 'scanf' [-Wimplicit-function-declaration]
         scanf("%d",&a[i]);
         ^~~~~
prog.c:7:9: warning: incompatible implicit declaration of built-in function 'scanf'
prog.c:7:9: note: include '<stdio.h>' or provide a declaration of 'scanf'
prog.c:15:5: warning: implicit declaration of function 'printf' [-Wimplicit-function-declaration]
     printf("Greatest:%d\n",Greatest);
     ^~~~~~
prog.c:15:5: warning: incompatible implicit declaration of built-in function 'printf'
prog.c:15:5: note: include '<stdio.h>' or provide a declaration of 'printf'
đã bình luận bởi (4.3k điểm)
0 thích 0 k thích 
Hidden content!
#include <stdlib.h>

int main()
{
* ** *  * * *   ****  *  *  a[10],Greatest = 0,Smallest = 1000,i,j,x = 0,y = 0,k;
 **  *    *   **     *  **   * = 0 ; i < 10 ; i++)
* *  ** * ******* *   * *  ** *  ****** *      **** **   * **   ****** **      *** 
   *   ***** * **    **    ******** = 0 ; i < 10 ; i++)
  * *    **    ** * * * *
*   ** **    * * * * *  *   ***** **  *   *** *  *  **** *   *  > Greatest)
    **    *  *   *      * * * *   ** * *      * ** * *   *  ** ** ***** *****    *  = a[i];
** * ****  *   * * *  *** *  *  ****  * * * * **** * *  **  < Smallest)
     *    ** * ** **    *****  *   *  *   * ** * *   ** ** * * **  ** * ***  *  * *   *    **  = a[i];
    }
** *    *   **** ** *     *  ** ***  * * *  ***   *****   ****  * 
 ***  ** * ****   ** *** *    *  * * * ** * *** *   * *****

*    ****  * *  **    ***** ****** = 0 ; i < 10 ; i++)
    {
* ***  *   *  *  *     * *    * * * *    **  **    ***** *  = 0 ; j < 10 ; j++)
***           **   *  * *  * * * ***  *  *  * *  **** * 
**  * ***   ****** ** ********  * * *  **    ***   ***  *  * **  ** * *  *     *** * == a[j])
*   * * ** *   *  *   ** ******* * ****        *** ***    *  * *** *   **** *  ** *   * ***   *  ** ***
  *  **    **   * ** ** ***  *** * * * *** *    *  
   *    ***    ** * * *   * **  *****   **  ** *  > x)
 * **    ** ** ***    ******   *    ** * * ***      *  
*  **  *  *   ******* *  **    **   **** * ** *   **  *** *     *  * * ** * *   = a[i];
***   ****  *  **** * * * * **  *  ****  ****  **  ***       * * * ** ** *** * ** ** = y;
* * * **  ***  ** * *   *  ** ***  ***  *** ***  *   *  
 ** ** **   ***    * ** *    *  *   ** ***    ***  * *** * = 0;
    }
****  *  * *** *  *  ***** *  **  *** most occurring item:%d",k);

**** *****    **  ** * **** * * *   0;
}
trả lời bởi (-127 điểm)
0 0
prog.c: In function 'main':
prog.c:7:9: warning: implicit declaration of function 'scanf' [-Wimplicit-function-declaration]
         scanf("%d",&a[i]);
         ^~~~~
prog.c:7:9: warning: incompatible implicit declaration of built-in function 'scanf'
prog.c:7:9: note: include '<stdio.h>' or provide a declaration of 'scanf'
prog.c:15:5: warning: implicit declaration of function 'printf' [-Wimplicit-function-declaration]
     printf("Greatest:%d\n",Greatest);
     ^~~~~~
prog.c:15:5: warning: incompatible implicit declaration of built-in function 'printf'
prog.c:15:5: note: include '<stdio.h>' or provide a declaration of 'printf'
đã bình luận bởi (4.3k điểm)
Trang:
Welcome to Peer-Interaction Programming Learning System (PIPLS) LTLab, National DongHwa University
English 中文 Tiếng Việt
IP:162.158.212.221
©2016-2024

Những câu hỏi liên quan

0 thích 0 k thích
56 trả lời
11-30 Exercise 2: Rotated Array
[Exercise] Coding (C) - đã hỏi ngày 29 tháng 11 năm 2017 trong Chapter 8: Arrays bởi semicolon (5.2k điểm)
ID: 34913 - Xem được từ: 2017-11-30 18:00 - Hiệu lực đến: Không giới hạn | 4.5k đã xem
0 thích 0 k thích
46 trả lời
11-30 Exercise 1: Fibonacci numbers (Array)
[Exercise] Coding (C) - đã hỏi ngày 29 tháng 11 năm 2017 trong Chapter 9: Functions bởi semicolon (5.2k điểm)
ID: 34912 - Xem được từ: 2017-12-14 18:00 - Hiệu lực đến: Không giới hạn | 3.7k đã xem
0 thích 0 k thích
47 trả lời
12-07 Exercise 3: Function to delete an element from an array
[Exercise] Coding (C) - đã hỏi ngày 7 tháng 12 năm 2017 trong Chapter 9: Functions bởi semicolon (5.2k điểm)
ID: 35785 - Xem được từ: 2017-12-07 18:00 - Hiệu lực đến: Không giới hạn | 3.5k đã xem
12,783 câu hỏi
183,443 trả lời
172,219 bình luận
4,824 thành viên