Newsgroup: it.comp.programmare
Titolo: Media dei valori di un array

Ciao
Qualcuno mi puo dire in C
o in genrerale
come si fa la vedia dei valori di un array
Grazie
Ciao
Luca
--
內躬偕爻,虜,齯滌`偕爻,虜,齯滌`偕爻爻,虜,齯滌`偕爻,虜,內躬偕爻,虜,齯滌`偕爻,
Luca Carenzo
E-mail 
lu...@tin.it
 
peg...@bbs.olografix.org
Web 
www.alligator4x4.n3.net
ICQ# 81706942
Scout TAG Vercelli 5 (VC) (AGESCI) Novizio - Camoscio Instancabile
Immortali mortali, Mortali Immortali, da vivi custodiscono la morte altrui,
da morti l'altrui vita.
                                        --Eraclito fr.62--
Vale la pena vivere anche solo per i sogni che si fanno di notte.
(Anonimo)
Ho portato mia suocera a vedere la stanza degli orrori
al museo delle cere e uno degli inservienti mi ha avvertito:
 << Signore, la faccia camminare continuamente: stiamo
facendo l'inventario>>
                                     (Les Dawson)
La fantasia �pi�importante della conoscenza.
                       (Albert Einstein)
內躬偕爻,虜,齯滌`偕爻,虜,齯滌`偕爻爻,虜,齯滌`偕爻,虜,內躬偕爻,虜,齯滌`偕爻,

 come si fa la vedia dei valori di un array
???
Sommando i valori e dividendo per il numero di elementi non va bene?
(ti sarei grato se mettessi una signature un po' più condensata)


Mica stupido il ragazzo
grazie:-)

 come si fa la vedia dei valori di un array
In generale, sommandoli e poi dividendo per il numero di elementi.
Oppure dividendo ciascun elemento per il numero di elementi e sommando
il risultato.
--
Andrea Ferro
---------
Brainbench C++ Master. Scored higher than 97% of previous takers
Scores: Overall 4.46, Conceptual 5.0, Problem-Solving 5.0
More info 
http://www.brainbench.com/transcript.jsp?pid=2522556

 il risultato.
Vabbè, ho capito. Faccio il bravo (ma non troppo) e visto che non dici
che tipo contiene il vettore te la posto come template C++:
// header: median.hpp
#ifndef __MEDIAN_HPP
#define __MEDIAN_HPP
#include <numeric>
template <typename Container>
    double median( Container &c )
    {
        return std::accumulate(c.begin(),c.end(),0.0)/c.size();
    }
#endif // __MEDIAN_HPP


#ifndef __MEDIAN_HPP
Ma non sono riservati i nomi che iniziano per "__"?
-- 
Marco Barisione (ICQ 84277092)

 Ma non sono riservati i nomi che iniziano per "__"?
Giusto. Cosě come č non sarebbe portabile. Cambialo pure in
#ifndef MEDIAN_HPP_INCLUDED


...complimenti per la risposta su come si fa la media di un array  :-))
.....non esiste un concorso per i programmi piu "oscuri" da decifrare?????
ciao!
Andrea
Andrea Ferro ha scritto nel messaggio ...


 ciao!
Guarda che la risposta era corretta e persino estremamente chiara e
semplice da leggere per chiunque conosca il C++ (tranne per il fatto che
non avrei dovuto usare il doppio underscore). Se non ci credi chiedi a
Marco Barisione, ad Antonio Cuni o a altri che conoscono il linguaggio.
Comunque, si! Esitono concorsi (o per lo meno esistevano) di
obfuscated-code. Ma non era certo quello un esempio.
Se vuoi un esempio eccolo (in C per unix). Non trovo più il makefile per
cui non so come ricostruirlo. Però ho le "istruzioni" del programma,
quindi so cosa fa una volta compilato:
    Interactive 3D Maze
    Step into a randomly generated 3D maze and try to get out alive!
    Use the vi movement keys (hjkl) to move on a level, and u or d
    to move (u)p or (d)own from a position with a U or D on the
    map.  To simulate the feeling of being in an unknown labyrinth,
    areas which you have not visited cannot be seen.
    Reach the north-west left corner of level 1 to exit.
Ovviamente il programma non è mio. Era una delle "entry" di una vecchia
edizione di un concorso di obfuscated-code. Eccolo:
#include <time.h>
#include <curses.h>
#define P(A,B,C,D,E) mvaddch(b+A,a+B,(q[y]&C)?D:E);
#define O(A,B,C) case A:if(q[x]&B)C;break;
#define R rand()
#define U 0,1,4,5
#define J(x) (1<<x)
#define V ' '
int r[27]                     ={0,J(0)
,2,1 ,3,J                     (2),5,U,
U,U,U,U},                     u[6]={-1
,7,49,-49,-7,1},q[343],x,y,d,l=342,a,b
,j='#';int main(){srand(time(0));for(x
=0;x<343;x++)q[x]=0;x=R%343;while(l){d
=r[R%27];if(((x%7==(x+u[d])%7)+(x/0x31
==(x+u[d]                     )/0x31)+
(((x/7)%7                     )==(((x+
u[d])/7)%                     7))==J(1
))&&(x+u[d]>=0)&&(x+u[d]<343)){if(!q[x
+u[d]]){q[x]+=J(d);x+=u[d];q[x]+=J(5-d
);l--;}else if(R<R/0x7){do{x=R%0x157;}
while(!q[x]);}}}x=294+R%0x31;initscr()
;noecho(                      );crmode
();clear                      (/*|*/);
refresh(                      );while(
x>0){move(J(0),60);printw("Level %d",(
x/0x31)+J(0)); q[x]|=J(J(3));for(y=(x/
0x31)*0x31;y<(J(0)+x/0x31)*0x31;y++)if
(q[y]&J(J(3))){a=J(0)+(3*((y/7)%7));b=
J(0)+(3*                      (y% 7));
mvaddch(                      J(1)+((y
%7)*3),J                      (1)+(((y
/7)%7)*3                      ),V);P(0
,0,0,0,j                      )P(3,0,0
,0,j)P(0,3,0,0,j)P(3,3,0,0,j)P(0,J(0),
J(0),V,j)P(0,J(1),J(0),V,j)P(J(0),3,J(
1),V,j)P(J(1),3,J(1),V,j)P(J(1),J(0),4
,'U',V)P(J(1),J(1),J(3),'D',V)P(J(0),0
,J(4),V,                      j)P(J(1)
,0,J(4),                      V,j)P(3,
J(0),J(5                      ),V,j)P(
3,J(1),J(                    5),V, j)}
 mvaddch(J                  (1)+((x%7
  )*3),J(1)                +(((x/7)%
   7)*3),'@')            ;refresh()
    ;switch(getchar()){O('k',J(0),
      x--)O('j',J(5),x++)O('l',J
        (1),x+=J(3)-J(0))O('h'
          ,J(4),x-=7)O('u',4
,(x+=49,    clear()))O('d',8,(x-=49,clear
()))case   'q':x=-1;break;}}clear();refresh
(/*v*/);   nocrmode ();echo();endwin();if(!
x)printf    ("You Escaped!\n");exit(0);}


Errata:
ovviamente volevo scrivere:
double median(double* pointer, size_t elements);
Ciao
Gaetano
--
#exclude <windows>
printf("\t\t\b\b\b\b\b\b");.
printf("\t\t\b\b\b\b\b\b");

 ciao!
E a te complimenti per come quoti. Non ricordo
di aver visto programma piu' snello, mantenibile, portabile, bello, elegante
per calcolare
una media.
Forse ti sarebbe stato piu' congeniale il seguente codice:
double median(double pointer, size_t elements)
{
    int i;
    double ret = 0.0;
    for (i=0; i<elements; ++i) {
        ret+=(*(pointer++))/elements;
    }
    return ret;
}
si sarebbe potuto fare di meglio (per renderlo piu' "chiaro"):
double median(double pointer, size_t elements)
{
    int i;
    double sum = 0.0;
    for (i=0; i<elements; ++i) {
        double addendum = *pointer;
        sum = sum + addendum;
        ++pointer;
    }
    return sum/elements;
}
Caratteristiche salienti:
1) Non sono sicuro che funzioni fin quando non lo testo
2) Non e' safe in quanto elements potrebbe dire il falso
3) Funziona soltanto con alcuni tipi
4) E' veramente brutto.....
L'implementazione del Ferro non ha nulla di tutto cio.
Un'altra volta questi post mettono in evidenza la differenza
che c'e' tra programmare in maniera dilettantesca e il
programmare.
PS. La mia seconda implementazione soffre di un problema,
quale ?
--


 quale ?
possibile overflow?
Cmq il problema si presenta anche nella versione std C++ che usa 
std::accumulate.
E cmq anche la prima versione ha un problema. Immagina di avere un 
vettore in cui tutti gli elementi sono inizializzati a 
std::numeric_limits<double>::min(); e` possibile che la funzione 
restituisca il valore 0, benche` non sia il valore corretto.
ciao Anto
-- 
Antonio Cuni, 19 anni, studente
Brainbench C++ Master: 4.73, higher than 99% of all previous test takers.
C Language: 3.32, higher than 79% of all previous test takers.
Guida C/C++ di Programmazione.it: 
http://cpp.programmazione.it

 ...complimenti per la risposta su come si fa la media di un array  :-))
era chiarissimo... per chi conosce il C++. Ovviamente la risposta del 
Ferro era un po` provocatoria: solitamente nei ng non si chiede di farsi 
fare i compiti.


 restituisca il valore 0, benche` non sia il valore corretto.
Esatto.
Più precisamente la versione con somma prima e divisione dopo ha il
possibile difetto di rischiare l'overflow. Ma è abbastanza difficile che
questo avvenga. L'altro possibile difetto è in termini di "perdita di
risoluzione". Ma anche questo ha poco senso.
E' molto più probabile che qualcuno stia usando double per maneggiare
numeri piccoli o con alta precisione nei decimali. In tal caso la
soluzione di somma prima e divisione dopo è quella fra le due che da un
risultato migliore (non il migliore in assoluto, il migliore fra le
due).


 fare i compiti.
Più precisamente: solitamente nei NG si chiede di farsi fare i compiti e
si ottengono non-risposte. Per esempio:
-) nessuna risposta punto e basta.
-) risposta dolce del tipo: "i compiti devi farli tu"
-) risposta arrabbiata sullo stile: "se vuoi che ti faccia i compiti
pagami"
-) risposta provocatoria che bypassa le specifiche. Tipo alla richiesta
di come fare una certa (dove è chiaro che chi posta usa Windows dato che
gli header del messaggio sono header outlook, ma lui non lo ha detto)
gli si risponde con la soluzione ... in RPG per sistemi VAX.
e altre variazioni sul tema "non ti rispondo e se ti rispondo la
risposta non ti serve e la colpa è tua perchè non hai specificato tutto
per bene". Notando che la conoscenza necessaria per spiegare tutto per
bene è superiore a quella necessaria per sapere la risposta!


 una media.
Esagerato.
In teoria il calcolo della media è talmente banale che non dovrebbe
essere neppure un problema. Affrontarlo come problema in maniera seria
significherebbe avere una soluzione molto più complessa di quella
postata (nel senso che dovrebbe tenere conto anche dei casi "non
ordinari").
Tento per cominciare presume che ci sia un container in senso STL.
Meglio sarebbe stato fare come con tutti gli algoritmi STL e lavorare
con "sequenze" definite direttamente con gli iteratori, invece che
passare il container.
Inoltre presume che double possa essere un valido valore di accumulo e
ritorno. Questo è vero se l'imput è di uno dei tipi predefiniti dal C++,
escluso il long double.
Non è corretto se l'imput è long double, se è std::complex o se è un
tipo definito dall'utente, come per esempio: una media di vettori (in
senso matematico), o una media di interi a lunghezza variabile, o una
media di un qualche tipo rational etc. etc.
Inoltre, anche lavorando con i double, sarebbe stato sensato realizzare
un algoritmo che controlli e quantifichi l'eventuale perdita di
precisione e che sia adattivo in base alla magnitudine dei numeri e alla
lunghezza della sequenza.
Infine, tanto per dirne una, se la sequenza non è gestita da iteratori
random l'algoritmo è suboptimale in prestazioni dato che scandisce la
sequenza due volte invece che una sola. Un algoritmo adattivo che lavori
in un modo o nell'altro a seconda del tipo di iteratore (o che lavori
sempre con un ciclo invece che con la std::accumulate) sarebbe stato
"migliore".


X Gaeteno Mendola....è chisro che hai colto il 
p.to
 della situazione..io 1°)
non sono un programmatore dilettante perche non sono un programmatore....2°)
è chiaro l'intento simpaticamente provocatorio di Andrea Ferro che risponde
a una persona che pretende di farsi fare i compiti e che non sa neppure
calcolare la media di un array( perche sicuramente alle prime armi), con un
codice sicumente snello,portabile..etc..etc..etc...ma sicuramente non
"chiarissimo" per un dilettante........se non lo intuisci da
solo.......bhe..........ciao!!
Andrea
Andrea Ferro ha scritto nel messaggio ...
