Posloupnost-prumer-maxima a minima – C / C++ – Fórum – Programujte.com

Dobrý den,

potřeboval bych pomoci s tímto programem a hlavně s těmi min a max.

Děkuji

   Je dána posloupnost celých čísel ukončená 0. Spočtěte aritmetický průměr této posloupnosti a zjistěte kolik čísel posloupnosti je menších než aritmetický průměr a kolik čísel je větších než aritmetický průměr.

#include<stdio.h>
#include<stdlib.h>
int main(void)
{
    int a,min,max;
    float p,s,b;
    printf("Program pro posloupnost celych cisel.\n");
    s=0;
    b=0;
    do {
    printf("Zadejte cele cislo:");
    scanf("%d",&a);
    b++;
    s=s+a;     
     
           if(a<p){min++;};
            if (a>p){max++;};                                                                                                  
        }while(a!=0);
    p=s/(b-1);
    printf("Prumer je %.2f \n",p);
   
    printf("Cisel mensich jak prumer je %d a cisel vetsich jak prumer je %d.\n",min,max);        
            
            

system("pause");
return 0;
}

Pocet mensich a vetsich nez aritmeticky prumer nejsou minima a maxima!

A tohle zadani uz mi docela zni jako "musis si ulozit vsechny zadane hodnoty, aby se to dalo vypocist"

#2 KIIV
Ano, napadlo mě to, jenomže nevím jak se to dělá.

Zkus pole milý .... Marku   

hu

1) v tom zádání není nic o tom, že to musíš načítat z konzole, takže si spíš vytvoř pole čísel, kde poslední bude 0
2) přes cyklus vypočteš průměr z pole čísel
3) přes druhý cyklus zjistíš čísla, kerá jsou menší než průměr a která větší

#4 hlucheucho
Mno jestliže chci ty čísla ukládat do pole a potom je porovnat s průměrem a vypsat je, tak jak napsat to pole v tom cyklu ? Díky

pole v cyklus psát rozhodně nebudeš, pole musí být definováno předem a přes cyklus ho jen naplníš případně potom zjistíš co je potřeba

Jedna verze může vypadat takto (psal jsem to nad c++ ale melo by to byt validni pod C) 

#define MAX 10

typedef struct Cislo
{
    int cislo;
    bool mensiNezPrumer;

    Cislo() : cislo(0) {}
    Cislo(int cislo) : cislo(cislo) {}
};

void nactiCisla(Cislo* pole)
{
    int i = 0;
    for (; i < MAX - 1; i++) {
        pole[i] = Cislo(rand() % 100);
    }
    pole[i] = Cislo(0);
}

void vypoctiPrumer(Cislo* cisla, int* prumer)
{
    int i = 0, sum = 0;
    for (; i < MAX; i++) {
        sum += cisla[i].cislo;
    }
    *prumer = sum / MAX;
}

void zjistiMinMax(Cislo* cisla, int prumer)
{
    int i = 0;
    for (; i < MAX; i++) {
        if (cisla[i].cislo < prumer) {
            cisla[i].mensiNezPrumer = true;
        } else {
            cisla[i].mensiNezPrumer = false;
        }
    }
}

void vypis(Cislo* cisla, bool mensiNezPrumer)
{
    int i = 0;
    for (; i < MAX; i++) {
        if (cisla[i].mensiNezPrumer == mensiNezPrumer) {
            printf("%d,", cisla[i].cislo);
        }
    }
}

int main()
{
    Cislo cisla[MAX];
    int prumer;

    nactiCisla(cisla);
    vypoctiPrumer(cisla, &prumer);
    zjistiMinMax(cisla, prumer);
    vypis(cisla, true); // vypise mensi nez prumer
    printf("\n");
    vypis(cisla, false); // vypise vetsi nez prumer

    return EXIT_SUCCESS;
}

PS: pardon, jsem přehlédl, že se jednalo pouze o počet čísel menších/větších, ale nevadí, aspon to mas i vypisem o jaka cisla se presne jednalo... jinak stačí upravit zjistiMinMax(..) na 

void zjistiMinMax(Cislo* cisla, int prumer, int* vysledek)
{
    int i = 0;
    for (; i < MAX; i++) {
        if (cisla[i].cislo < prumer) {
            cisla[i].mensiNezPrumer = true;
            vysledek[0]++;
        } else {
            cisla[i].mensiNezPrumer = false;
            vysledek[1]++;
        }
    }
}

a potom main() bude 

int main()
{
    Cislo cisla[MAX];
    int vysledek[2] { 0 };
    int prumer;

    nactiCisla(cisla);
    vypoctiPrumer(cisla, &prumer);
    zjistiMinMax(cisla, prumer, vysledek);
    printf("Mensich: %d\nVetsich: %d", vysledek[0], vysledek[1]);

    return EXIT_SUCCESS;
}

+ vymazat funkci vypis(...) (pokud ji tam nechceš)

#5 ingiraxo
Když tedy bych chtěl načítat hodnoty z konzole a někam je ukládat abych následně porovnával s průměrem, tak jak to tedy mám udělat, když pole musí mít nejdříve nadeklarované čísla?

#8 Marek
nemusí, však z konzole budeš ukládat čísla do pole.. víš jak index tak hodnotu, pokud neznáš přesnej počet čísel, tak klidne nastav poli treba velikost 100, kde načítání z konzole potom ukoncis přes nějaký speciální číslo (třeba záporný)

nebo jako prvni parametr z konzole bude počet cisel a az potom budes zadavat jednotliva cisla, ale to uz vyzaduje alokaci pole

#9 ingiraxo
Ano, avšak musí mít nadeklarováno kolik má řádů, nebo ne ?

#10 Marek
nemusí, ale o tom jsem přece psal, si to přečti znovu.. já nevim, jaký je přesný zadání.. pokud víš, že čísel bude vždy třeba 10, tak prostě nastavíš 10, pokud nevíš, tak bych velikost ziskal pres konzoli, alokoval ho a potom nacet hodnoty

Takže jedno řešení je třeba takto 

void nactiCisla(int*& cisla, int& pocet)
{
    int i;

    printf("Zadej pocet cisel: ");
    scanf("%d", &pocet);

    cisla = (int *) malloc(pocet * sizeof(int));

    for (i = 0; i < pocet; i++) {
        printf("Zadej %d.cislo: ", (i + 1));
        scanf("%d", cisla + i);
    }
}

Ale podle zadání to vypadá, že máš načítat čísla tak douho, dokud nenapíšeš číslo 0, který má ukončit načítání.. takže 

void nactiCisla(int* cisla, int& pocet)
{
    pocet = 0;
    do {
        printf("Zadej %d.cislo: ", (pocet + 1));
        scanf("%d", cisla + pocet);
    } while (cisla[pocet++] != 0);
    pocet--;
}

C++ řešení: vector. Sám si alokuje, sám spočítá kolik bylo zadáno čísel

hu

#11 ingiraxo
Takže jsem k tomu sedl a zapřemýšlel a vytvořil jsem program, který jede, avšak je omezen 100 čísly posloupnosti. Mohl byste mi prosím mou vytvořený program upravit do podoby, aby bylo možné zadávat čísla a přitom nebylo "omezeno" kolik jich může uživatel zadat. Děkuji 

/*    Je dána posloupnost celých èísel ukonèená 0. Spoètìte aritmetický prùmìr této
posloupnosti a zjistìte kolik èísel posloupnosti je menších než aritmetický prùmìr a 
kolik èísel je vìtších než aritmetický prùmìr.*/ 

#include<stdio.h>
#include<stdlib.h>
int main(void)
{
    int a,i,b,x,y;
    float p,s;
    printf("Program pro posloupnost celych cisel.\n");
    s=0;
    b=-1;
    x=0;
    y=0;
    int pole[100];
    do {
    printf("Zadejte cele cislo:");
    scanf("%d",&a);        
    b++;
    s=s+a;
    pole[b]=a;                                                                                                        
        }while(a!=0);
    
    p=s/(b-1);
    
    for(i=0;i<b;i++)
    {
              if(pole[i]<p)
                 {x++;
                            }
              if(pole[i]>p)
                    {
                      y++;        
                      }                                                        
                 }
     
     printf("Prumer je %.2f \n",p);
     printf("Cisel mensich jak prumer je %d\n",x);
     printf("Cisel vetsich jak prumer je %d\n",y);
     

system("pause");
return 0;
}

#13 Marek
U toho průměru má být p=s/b, jsem to zapomněl přepsat.

v C++ nebo C?

hu

Nemyslim si, že je potřeba to ošetřovat na víc jak 100 pro školní potřeby, ale pokud to chceš pořešit, tak udělej následující.

1) pole bude dynamicky alokovaný, hned na začátku ho alokuješ na 10 čísel (přes calloc)
2) jakmile uživatel bude zadávat 11 číslo, tak pole realokuješ o 10, čiže bude mít velikost 20 s tím, že prvních N čísel překopíruješ. A to samé uděláš u 21,31 atd... (použij realloc)
3) na konci až skončís s práci s polem ho uvolni (přes free)

Na logiku toho cos psal jsem nekoukal, jinak tyhle funkce si můžeš snadno vygooglit, když už znáš jejich názvy ;-)

#15 hlucheucho
C

V zásadě to, co jsem psal 

#define CHUNK 10

void nactiCisla(int*& cisla, int& pocet, int& soucet)
{
    int c, n = 1;
    int* temp = 0;

    cisla = (int *) calloc(CHUNK, sizeof(int));
    pocet = 0;
    soucet = 0;

    do {
        printf("Zadej %d.cislo: ", (pocet + 1));
        scanf("%d", &c);

        if (pocet > 0 && pocet % CHUNK == 0) {
            temp = (int *) realloc(cisla, (CHUNK * ++n) * sizeof(int));
            cisla = temp;
        }
        cisla[pocet] = c;
        soucet += c;
    } while (c != 0 ? ++pocet : false);
}

int main()
{
    int* cisla;
    int pocet, soucet;
    float prumer;

    nactiCisla(cisla, pocet, soucet);
    prumer = soucet / (float) pocet;

    // dalsi logika, dopln si sam

    free(cisla);
    return EXIT_SUCCESS;
}

Stačil by malloc, calloc navíc vynuluje paměť, v tomto případě zbytečné.

hu

#19 hlucheucho
v tom máš sice pravdu, ale vždy mám radší, když po alokaci tam jsou aspon ty 0 místo něčeho čehosi :) Kdyby si např. v jeho případě chtěl iterovat, tak právě díky těm nulám poznáš konec (pokud by sis jí neuložil při načtení)

ale po realloc už to vynulovaný není, takže pak už se na to spoléhat nedá.

hu