array di nomi

[lucas72]

Ciao!!
Ho da sottoporre un problema che riguarda
gli array (non ho ancora dimistichezza con gli array ,
anche se le cosa stanno migliorando)

Vorrei:
1) creare due array 2 array i cui elementi (massimo 15 o 20)
devono essere dei cognomi (del tipo: Rossi, Della Valle, Pisano, De Roberti ecc)
i quali devono essere scelti ed inseriti dall'utente;

2) verificare quale cognome è il più lungo per ogni array e visualizzarlo a
terminale;

3) quale dei 2 array ha il cognome più lungo e visualizzarlo (ovviamente può
essere anche lo steso di prima)
Quale potrebbe essere il codice?
Io ci sto provando ma non riesco a risolvere il problema
(scusate sono alle prime armi).
Grazie anticipatamente.

[Fenomeno85]

che linguaggio?

~§~ Sempre E Solo Lei ~§~

[Fenomeno85]

in c

const n = 20;
void massimo (char cognomi[])
{
int i, y;
y=0;
for (i=1;i<n;i++)
{
if (strlen(cognomi[i]) > strlen(cognomi[y])
{
y=i;
}
}
return cognomi[y];
}

void carica (char cognomi [])
{
int i;
for (i=0;i<n;i++)
{
printf ("Inserisci %d cognome",&i+1);
fflush (stdin);
gets (cognomi[i]);
}
}

void main ()
{

char cognomi1 [n][20];
char cognomi2 [n][20];
char cognome [2][20];

printf ("Caricamento primo array");
carica (cognomi1);
printf ("Caricamento secondo array");
carica (cognomi2);

cognome[0] = massimo (cognome1);
cognome[1] = massimo (cognome2);

//ocio che se esistono nomi della stessa lunghezza prende il primo e basta

printf ("Massimo primo array %s",cognome[0]);
printf ("Massimo secondo array %s",cognome[1]);

if (strlen(cognome[0]) > (strlen(cognome[1])
{
printf ("cognome di lung sup è %s",cognome[0])
}
else{
if (strlen(cognome[0]) == (strlen (cognome[1])))
{
print ("congomi della stessa lung %s e %s",cognome[0],cognome[1]);
}
else
{
printf ("cognome di lung mag %s", cognome[0]);
}
}

}

}

per il basic basta che lo ritocchi con le sue istruzioni

~§~ Sempre E Solo Lei ~§~

[Joestar]

#include <stdio.h>
#include <string.h>

#define SIZE 2 /* questo definisce QUANTI cognomi (di cui ho settato la lunghezza max a 30) puoi immettere per array.
cambialo se ne vuoi di +, ma per i test un valore basso è comodo. */

int main (void)

{
char nomi1[SIZE][30];
char nomi2[SIZE][30];
unsigned int i=0,k=0,h=0;
unsigned int longest1=0,longest2=0,lonpos1=0,lonpos2=0;

for (i=0; i<=SIZE; i++) {
h=i+1;
printf("Inserire %d° cognome per il primo array: ",h);
fgets(nomi1[i],sizeof(nomi1),stdin);
}

printf("I cognomi inseriti nel primo array sono: \n");

do {
for (i=0; i<=strlen(nomi1[k]); i++) {
printf("%c",nomi1[k][i]);
}

k++;
printf("\n");

} while (k<=SIZE);


for (i=0; i<=SIZE; i++) {
if (strlen(nomi1[i])>longest1) {
longest1=strlen(nomi1[i]);
lonpos1=i;
}

}

printf("Il nome + lungo del primo array è: %s",nomi1[lonpos1]);

printf("\n\n\n");

for (i=0; i<=SIZE; i++) {
h=i+1;
printf("Inserire %d° cognome per il secondo array: ",h);
fgets(nomi2[i],sizeof(nomi2),stdin);
}

printf("I cognomi inseriti nel secondo array sono: \n");
k=0;

do {

for (i=0; i<=strlen(nomi2[k]); i++) {
printf("%c",nomi2[k][i]);
}

k++;
printf("\n");

} while (k<=SIZE);

for (i=0; i<=SIZE; i++) {
if (strlen(nomi2[i])>longest2) {
longest2=strlen(nomi2[i]);
lonpos2=i;
}


}

printf("Il nome + lungo del secondo array è: %s",nomi2[lonpos2]);

printf("\n\n\n");

printf("Comparazione tra i 2 array. \n\n");

if (longest1 > longest2) {
printf("Il primo array contiene il cognome + lungo: %s",nomi1[lonpos1]);
}

else
if (longest2 > longest1) {
printf("Il secondo array contiene il cognome + lungo: %s",nomi2[lonpos2]);
}

else {
printf("I 2 array contengono un cognome della medesima lunghezzaa. \n%s\n%s",nomi1[lonpos1],nomi2[lonpos2]);
}

return 0;

}

[Joestar]

Ciao,

domani quando sarò + lucido, aggiungerò il caso in cui ci siano + cognomi della stessa lunghezza massima nel medesimo array, in modo che li stampi tutti, indipendentemente da quanti sono.
Era complicato da gestire ed avevo sonno

Altra cosa da fare, abbellire il tutto e raggruppare il raggruppabile in procedure e funzioni.

Spero cmq che tutto ciò serva a darti un'idea generale su un possibile modo di affrontare il problema. Se hai qualche domanda chiedi pure, se sono in grado di rispondere lo farò

[Fenomeno85]

mmm perchè ti devi complicare la vita nella visaulizzazione dei cognomi???

do {
for (i=0; i<=strlen(nomi1[k]); i++) {
printf("%c",nomi1[k][i]);
}

k++;
printf("\n");

} while (k<=SIZE);


ti basta fare

for (i=0;i<SIZE;i++)
{
puts (nomi1[i]);
//oppure usi printf con %s
}

poi ti conveniva come avevo fatto io mettere sotto funzioni così oltre che a essere più leggibile scrivi meno codice e quindi meno probabilità di errore.

~§~ Sempre E Solo Lei ~§~

[Fenomeno85]

altra cosa che ho visto

(k<=SIZE) questo è sbagliato nei cicli perchè gli array vanno da 0 a n-1

quindi

k<SIZE

~§~ Sempre E Solo Lei ~§~

[anx721]

Ciao Lucas72,

ti riporto due link a dei corsi introdutttivi sul C:

http://www.beta.it/beta/ext/corsi/c-intro/index.htm

http://alpha.science.unitn.it/~fiore...ac/indexc.html

[lucas72]

ops scusate !
mi serve in c++
C'è qualche differenza con quello scritto sopra?
Vi ringrazio

[cionci]

In teoria va bene...ma dipende sempre come fai tu il C++
Usato oggetti e template della libreria standard ?

[Joestar]

Originariamente inviato da Fenomeno85
altra cosa che ho visto

(k<=SIZE) questo è sbagliato nei cicli perchè gli array vanno da 0 a n-1

quindi

k<SIZE

~§~ Sempre E Solo Lei ~§~

Hai provato il programma prima di dire che è sbagliato ?
Rileggi la tua frase e capirai che non ha senso, in + è corretto così com'è.

[Fenomeno85]

Originariamente inviato da Joestar
Hai provato il programma prima di dire che è sbagliato ?
Rileggi la tua frase e capirai che non ha senso, in + è corretto così com'è.

mmm la cosa non convince scusa se io ho una matrice le righe sono 0 e 1 se definisco size = 2 ... e se lo faccio partire da 0 fino a size fa 0 1 2 ... o no??

----------
0|come
---
1|ciao
----------

si la mia risposta precente non è corretta ma mi riferivo a questo

~§~ Sempre E Solo Lei ~§~

[Joestar]

Originariamente inviato da Fenomeno85
mmm la cosa non convince scusa se io ho una matrice le righe sono 0 e 1 se definisco size = 2 ... e se lo faccio partire da 0 fino a size fa 0 1 2 ... o no??

----------
0|come
---
1|ciao
----------

si la mia risposta precente non è corretta ma mi riferivo a questo

~§~ Sempre E Solo Lei ~§~

Dipende da come è definita questa "matrice".

Nel mio caso ho definito 2 array identici come segue:
nomearray[2][30];
Per come lo visualizzo io mentalmente la prima dimensione definisce il numero massimo di elementi la cui lunghezza massima è 30 (0-29). In questo caso sono 3 (0-2).

[Fenomeno85]

Originariamente inviato da Joestar
In questo caso sono 3 (0-2).

non capisco ma se definisci da 2 come fai ad avere 3??

~§~ Sempre E Solo Lei ~§~

[fpucci]

Originariamente inviato da Joestar
Dipende da come è definita questa "matrice".

Nel mio caso ho definito 2 array identici come segue:
nomearray[2][30];
Per come lo visualizzo io mentalmente la prima dimensione definisce il numero massimo di elementi la cui lunghezza massima è 30 (0-29). In questo caso sono 3 (0-2).

Se mi è consentito intervenire, vorrei dire che definire:

#define SIZE  2
   ...
   char nomi1[SIZE][30];

e poi fare:

   ...
   for (i=0; i<=SIZE; i++) { 
      h=i+1; 
      printf ("Inserire %d° cognome per il primo array: ",h); 
      fgets (nomi1[i],sizeof(nomi1),stdin); 
   }
   ...

stai accedendo ad una area di memoria al di fuori del contesto della variabile per cui è definita.
Può anche essere che ti funziona (il programma è di poche righe), ma prima o poi andresti ad accedere ad un area di memoria in cui si trovano altri valori, causando una eccezione.
Se facessi girare su Unix quel programma, anrà quasi sicuramente in crash!
Fidati

Pertanto quello che dice Fenomeno85 è vero.
Se tu definisci un array di dimensione 2, vuol dire che hai due elementi nell'array. E poiché in C gli indici dell'array partono da 0, gli unici indici validi sarebbero 0 e 1.
Quindi accedere all'elemento 2 è una operazione illecita e dannosa.

Ciauz

[lucas72]

prima di passare al conteggio dei cognomi ho provato
con i numeri (sembra più facile)
Ho scritto ( assemblato pezzi è il termine più corretto, forse)
questo codice in c++

#include <iostream.h>

const int DIM1 = 6;
const int DIM2 = 7;

// prototipi di funzioni
void leggiGruppo(int vettore[], int dimensione);
void leggiMassimo(const int vettore[], int dimensione, int &max);

main()
{
int gruppo1[DIM1], gruppo2[DIM2];
int max1, max2;

//visualizzazione di un messaggio iniziale
cout << endl << "Programma che calcola il massimo tra 2 array " << endl << endl;

//lettura del primo gruppo
cout <<"Inserisci i numeri del primo gruppo: "<<endl;
leggiGruppo(gruppo1, DIM1);

//lettura secondo gruppo
cout << endl<<"Inserisci i numeri del secondo gruppo: "<<endl;
leggiGruppo(gruppo2, DIM2);

//calcolo il massimo e visualizzazione
leggiMassimo(gruppo1, DIM1, max1);
cout << endl <<"Il massimo del primo gruppo e': " <<max1<<endl;

leggiMassimo(gruppo2, DIM2, max2);
cout << endl <<"Il massimo del secondo gruppo e': " <<max2<<endl<<endl;

if(max1>max2)
{
cout<<"il massimo tra i 2 vettori e': " <<max1<<"(nel primo gruppo)"<<endl;
}
else if(max1<max2)
{
cout<<"Il massimo tra i due vettori e'"<<max2<<" (nel secondo gruppo)"<<endl;
}
else if(max1=max2)
{
cout<<"Il massimo dei numeri dei 2 gruppi e' identico"<<endl;
}

system("PAUSE");
return 0;

}
void leggiGruppo(int vettore[], int dimensione)

{
for (int i = 0;i < dimensione; i++)
{
cout<<"inserisci numero: "<< i + 1<<" ";
cin>>vettore[i];
}
}
void leggiMassimo(const int vettore[], int dimensione, int &max)
{
max = 0;
int i;
for(i=0;i<dimensione;i++)
{
if(vettore[i]>max)
{
max= vettore[i];
}
}
}


Il programma, dopo numerosi tentativi ( tra messaggi di errori),
adesso funziona.
quello che mi interessa ora è il simbolo & delle funzioni,
scusatemi sarò di coccio
ma vorrei capire bene questo aspetto teoricamente e praticamente.
Se lascio nel codice sopra il simbolo &(vicino max per intenderci) il risultato (esatto) in consolle per esempio è:

Programma che calcola il massimo tra 2 array

Inserisci i numeri del primo gruppo:
inserisci numero: 1 1
inserisci numero: 2 2
inserisci numero: 3 3
inserisci numero: 4 4
inserisci numero: 5 5
inserisci numero: 6 6

Inserisci i numeri del secondo gruppo:
inserisci numero: 1 1
inserisci numero: 2 2
inserisci numero: 3 3
inserisci numero: 4 4
inserisci numero: 5 5
inserisci numero: 6 6
inserisci numero: 7 7

Il massimo del primo gruppo e': 6

Il massimo del secondo gruppo e': 7

Il massimo tra i due vettori e'7 (nel secondo gruppo)


se ometto il simbolo & abbiamo:

Programma che calcola il massimo tra 2 array

Inserisci i numeri del primo gruppo:
inserisci numero: 1 1
inserisci numero: 2 2
inserisci numero: 3 3
inserisci numero: 4 4
inserisci numero: 5 5
inserisci numero: 6 6

Inserisci i numeri del secondo gruppo:
inserisci numero: 1 1
inserisci numero: 2 2
inserisci numero: 3 3
inserisci numero: 4 4
inserisci numero: 5 5
inserisci numero: 6 6
inserisci numero: 7 7

Il massimo del primo gruppo e': 2293728

Il massimo del secondo gruppo e': 2293592

il massimo tra i 2 vettori e': 2293728(nel primo gruppo)
Premere un tasto per continuare . . .

Ecco!!
cosa succede in questo caso?
Devo capire bene questo punto.

Già che ci sono: se non volessi assegnare una dimensione definita per ogni array, ma far in modo che ne contenga massimo 100 di valori ad esempio come potrei fare?
Praticamente il codice sopra dovrebbe inglobare la caratteristica di quest'altro semplice codice che ho trovato :

//inizializzazioni
#include <iostream.h>

int main(){

// dichiarazione delle variabili
const int TAPPO = 0;
int num, max;

// stampa del titolo
cout << endl;
cout << "Calcolo del massimo" << endl << endl;

cout << "Inserisci una sequenza di numeri interi positivi "
<< "terminata da 0" << endl;

// Leggi il primo numero
cin >> num;
cout << endl;

max = 0;

// finchè (la sequenza non è finita)
while(num != TAPPO){

// Se (l'ultimo numero letto è > del massimo tra i
// numeri già letti)
if (num > max){

// Massimo tra i numeri letti = ultimo numero
// letto;
max = num;

}

// Leggi un altro numero
cin >> num;

} // fine while


// Se (è stato letto almeno un numero)
if (max != TAPPO){

// Stampa il massimo tra i numeri letti
cout << endl << "Il massimo e': " << max << endl << endl;
}

else{

// Stampa il messaggio "Non sono stati introdotti
// numeri"
cout << endl << "Non sono stati introdotti numeri" <<
endl << endl;

}
system("PAUSE");

return 0;
}

Ciao e vi ringrazio ancora per la pazienza.

[Fenomeno85]

allora il parametro dim è inutile se la dimensione degli array è sempre uguale comunque per renderlo generico va bene, altra cosa, le funzioni le puoi mettere sopra il main così elimini la dichiarazione dei prototipi.
Un accorgimento che farei è quello di ricevere in ritorno dalla funzione i valori massimi.

Nella funzione che trova il valore massimo ti consiglio di inizializzare il valore max con il primo valore dell'array.

Poi non so a cosa ti serve mettere in pausa.


Non ho capito quello che vuoi fare nella seconda parte... ma se vuoi che al massimo leggi 100 persone, la condizione del ciclo la metti < 100

allora siccome utilizzi una variabile che è stata dichiarata in locale alla funzione e non globale, se vuoi modificare il valore contenuto nella variabile devi passare l'indirizzo.
Quindi nella dichiarazione dei parametri formali passi la variabile con & mentre nei parametri attuali devi mettere *.
Altra cosa che ti dico è che se passi gli array cosa che può succedere, nei parametri formali non devi mettere & perchè il nome dell'array indica già di per se un puntatore, mentre nei parametri attuali l'array lo richiami o con *array oppure array[]

Questi sono i cosidetti passaggi di parametri. Ricordati che nella funzione devi utilizzare la variabile come *variabile se non fai errore.

~§~ Sempre E Solo Lei ~§~

[Fenomeno85]

per correttezza esistono due tipi di passaggi di parametro:

passaggio per valore

passaggio per indirizzo

Il passaggio per valore significa che passi solo il valore e, i cambiamenti a quellla variabile che vengono fatti non influenzano il valore contenuto nella variabile passata.
Al contrario se utilizzi il passaggio per indirizzo i cambiamenti di valore nella funzione influenzano direttamente la variabile passata perchè vai a modificare il valore della cella di memoria della variabile passata.
Per come passare spero che hai capito come devi fare comunque:

funzione (&variabile_indirizzo, variabile_valore); -> void funzione (tipo *valore, tipo valore);

funzione (array); -> void funzione (tipo array[] oppure tipo *array);

ricordati che è sbagliato passare così:

funzione (&array);

~§~ Sempre E Solo Lei ~§~