DOMANDA Aiuto programma con array

[MPG]

Ecco la domanda:
+popolare un array A di dimensione dim (specificata dall'utente) con valori casuali compresi tra 0 e 5),
stamparne il contenuto. Popolare un secondo array B con l'ultimo valore dell'array A; popolare un terzo array C con il primo valore di A.

#include <iostream>
#include<cstdlib>
#include<ctime>

using namespace std;

int main()
{
    srand(time(NULL));
    int dim;
    cin>>dim;
    int dimB=1;
    int dimC=1;

    int A[dim];int B[dimB]; int C[dimC];

    for(int i=0; i<dim; i++)
        {
        A[i]=rand()%6+0;
    cout<<A[i]<<endl;
    }
    cout<<endl;

    int j=0;
    B[j]=A[dim-1];
    cout<<B[j]<<endl;
    cout<<endl;

    int k=0;
    C[k]=A[0];
    cout<<C[k];

    }

Questo dovrebbe essere giusto cosi' vero?

L'altro: Copiare l'array in B al contrario; +Sommare gli elementi corrispondenti di A e B e memorizzarli nell'array C.

Abbiamo appena iniziato gli array, mi potete aiutare a risolvere?
Grazie a tutti!

 

[_Achille]

Ciao! Per prima cosa ti consiglio di dichiarare tutte le variabili che determinano la dimensione di un vettore come const int, o meglio ancora const size_t (size_t è un unsigned long long specificato in cstdlib). Questo ti impedirà di apportare modifiche alle variabili per errore (const impone l’area di memoria come sola lettura). La limitazione è che dim deve essere perforza non-const.

Allora dichiara dim come dimA (visto perché hai dimB e dimC perché cambiare?). Non è specificato, ma penso che dimB e dimC debbano aver lo stesso valore di dimA, quindi non inizializzarli a 1 (possono essere const questi).

Dichiara gli array nel tipo int x[dim], y[dim]...; o
int x[dim];
int y[dim];
...
non int x[dim]; int y[dim]...;
Il ciclo è corretto.

Utilizza ora un solo for, dove il contatore deve andare da 0 a dimA, dove dai a ciascun elemento di B A[dimA-1] e a C A[0].

Puoi ora scoprire che 3 dim sono inutili e ti bastava un solo dim.
Se le varie dimensioni erano diverse, avresti dovuto fare un for per B e un for per C.

 

[DDog29]

L'altro: Copiare l'array in B al contrario; +Sommare gli elementi corrispondenti di A e B e memorizzarli nell'array C.

il modo piu intuitivo e scorrere gli array nel senso opposto, mi spiego meglio ..

se hai un array A [ 1 2 3 4 5 ] e vuoi ottenere B [ 5 4 3 2 1]

scorri l'array A partendo dall'n-1-esimo elemento e lo copi in B partendo dallo 0-esimo elemento.
Questo generalmente potresti farlo intuitivamente con un while sfruttando due indici in pratica usi un indice per l'array A e uno per il B, uno sarà incrementato l'altro decrementato;

int i=0;
int  j=dim;
 while( i<dim){
   B[i]=A[j];
    j--;
    i++;
}

Oppure potresti provare in questo modo, dovrebbe andare ugualmente ( non è codice testato ,ma ripeto dovrebbe andare ):

for(int i=0; i<dim; i++){

B[i]=A[dim-i];

}

Una volta fatto ciò suppongo resti solo la somma degli elementi corrispondenti dei due Array in un array C.
In questo caso la soluzione è banale .. ovvero basta sommare gli elementi con stesso indice e inserirli nell'i-esimo "spazio"/"cella" nell 'array C con indice uguale:

C[ i ] = A[ i ] + B[ i ]

Arrivati a questo punto se vuoi evitare di fare tanti cicli for.. possiamo sfruttare anche il ciclo che ho scritto precedentemente.. ovvero scrivendone uno unico che faccia sia l'operazione di somma che il reverse dell'array a in b:

for(int i=0; i<dim; i++){

B[i]=A[dim-i];
C[i]=A[i]+B[i];

}

Ti ricordo che per questioni di leggibilità del codice forse soluzione più corretta è quella di diversificare i cicli eseguendo questa operazione:

Spoiler

C[ i ]=A[ i ]+B[ i ];

In un ciclo for differente. Magari per questo punto aspetta ulteriori risposte.

 

[_Achille]

Leggera correzione.

for(int i=0; i<dim; i++){

B[i]=A[dim-1-i];

}

Ti ricordo che per questioni di leggibilità del codice forse soluzione più corretta è quella di diversificare i cicli eseguendo questa operazione:

Eh sì, sono anche io uno studente e i professori solitamente impongono un solo procedimento per ciclo.

 

[MPG]

Io pensavo cosi' non mi va l'ultima parte della somma...

#include <iostream>
#include<ctime>
#include<cstdlib>
using namespace std;

int main()
{
    srand(time(NULL));
    int  dim;
    cin>>dim;
    cout<<endl;
    int A[dim];
    int B[dim];
    int C[dim];

    for(int i=0;i<dim;i++)
    {
       A[i]=rand()%10+0;
       cout<<A[i]<<endl;
    }
    cout<<endl;
    for(int i=dim-1;i>=0;i--)
    {
        int j=0;
        B[j]=A[i];
        cout<<B[j]<<endl;
    }
    cout<<endl;
    for(int i=0;i<dim;i++)
   {
        int j=0;
        int k=0;
        C[k]=A[i]+B[j];
        cout<<C[k]<<endl;
        j++;
        k++;
    }
   

}

 

[DDog29]

Sembra sbagliato anche il ciclo che ti fa il reverse dell'array in quanto j non è mai iterato e per di più inizializzi una nuova j ogni ciclo.. il che vuol dire che j è ferma a 0 e inserisci gli elementi di A sempre nella stessa posizione in B in particolare in B[0]..
Quindi dovresti fare cosi:

int j=0;
for (int i=dim-1; i>=0; i--){
B[j]=A[i];
cout<<B[j]<<endl;
j++;
}

Per di più poiché A e B hanno lo stesso size e di conseguenza anche C è inutile fare 3 indici diversi per fare quella somma in un array C.. Quindi ti basta fare semplicemente cosi:

for( int i=0; i<dim; i++ ){
   
    C[i]=A[i]+B[i];
cout<<C[i]<<endl;
}

Leggera correzione.

Un piccolo grande errore :thanks:

 

[_Achille]

C’è un po di confusione in tutto il codice. Se tu scrivi int j=0 all’interno di un ciclo dichiari ma pure inizializzi la variabile ad ogni ciclo.
Nella locazione di j avviene ciò
0->1->0->1...
Soluzione: dichiarare la variabile j static in questo modo viene inizializzata solo al primo ciclo (qualsiasi variabile static può essere inizializzata una sola volta, se il tuo prof vorrà lo vedrai con le funzioni).
Dato che utilizzi j per tutto il codice dopo la sua dichiarazione non sarebbe nemmeno male.
Altra soluzione: dichiarare j come dim-1-i (se controlli al primo giro j sarebbe dim-1-dim+1 cioè 0). Dichiararla come static in questo caso è un errore.
Ultima soluzione: dichiarare j prima del ciclo e inizializzarla 0. Prima del secondo ciclo darle valore 0.

Nell’ultimo ciclo i, j, k hanno lo stesso valore eh. Sono ridondanti. L’intero programma è gestibile solo con i.

 

[MPG]

Scusate non ne vengo fuori potete scrivermi gentilmente il codice completo che poi lo verifico con calma cercando di capire il tutto per favore?
_Achille me lo puoi scrivere tutto con i? Grazie
P.s.
DDog29 scrivi prima B[j],
nella somma di A e B poi invece metti B con indice i , non j, non capisco..

 

[_Achille]

Scusate non ne vengo fuori potete scrivermi gentilmente il codice completo che poi lo verifico con calma cercando di capire il tutto per favore?
_Achille me lo puoi scrivere tutto con i? Grazie
P.s.
DDog29 scrivi prima B[j],
nella somma di A e B poi invece metti B con indice i , non j, non capisco..

#include <iostream>
using std::cin;
#include <cstdlib>
#include <ctime>

int main() 
{
    
    srand(time(NULL));
    
    size_t dim;
    cin >> dim;
    
    int A[dim], B[dim], C[dim];
    
    for(int i=0; i<dim; i++)
    
        A[i] = rand() % 10;
        
    for(int i=0; i<dim; i++)
    
        B[i] = A[dim-1-i];
    
    for(int i=0; i<dim; i++)
    
        C[i] = A[i] + B[i];        
    
}

 

[MPG]

Grazie _Achille, non riesco a capire il significato di B[dim-1 -i] . Viene tutto giusto ma non capisco bene.
Se la dim di A mettiamo è 5, quella di di B mi verrebbe da dire è 4 m poi il -i?? Sono in seconda superiore e come detto abbiamo appena iniziato gli array, mi puoi far capire meglio questo concetto? Ti ringrazio molto veramente.

 

[_Achille]

Grazie _Achille, non riesco a capire il significato di B[dim-1 -i] . Viene tutto giusto ma non capisco bene.
Se l'indice di A mettiamo è 5, l'indice di B me verrebbe da dire è 4 m poi il -i?? Sono in seconda superiore e come detto abbiamo appena iniziato gli array, mi puoi far capire meglio questo concetto? Ti ringrazio molto veramente.

Anche io sono in seconda superiore ahaha.
Comunque se la dimensione è 5 e siamo al valore dell'indice 3 (che è il quarto elemento di B) su A saremo a 5-1-3, ovvero 1. 1 e 3 sono rispettivamente complementari. Tutto si basa infatti sulla complementarità: le coppie che si vanno a formare sono (0, 4), (1,3), (2, 2), (3,1) e (4, 0). Quando farai le matrici quadrate utilizzerai questa cosa della complementarità per calcolare una delle due diagonali

 

[MPG]

Scusa _Achille (e ancora grazie), come faresti questo:
"Leggere i 10 elementi di un vettore e visualizzare l'indice dell'elemento di valore massimo?"
Domani ho verifica di recupero..... cerco di prepararmi su vari ipotetiche domande..

 

[rodhellas]

Scusa _Achille (e ancora grazie), come faresti questo:
"Leggere i 10 elementi di un vettore e visualizzare l'indice dell'elemento di valore massimo?"
Domani ho verifica di recupero..... cerco di prepararmi su vari ipotetiche domande..

Scorri l'array e ti salvi le informazioni su due variabili ( posizione e valore ).

 

[MPG]

Per completezza vorrei capire "Leggere 5 elementi di un vettore e vedere media, valore minimo , massimo e indice con valore piu' alto e piu' basso.

Ho fatto cosi' come ti sembra e in caso come la faresti tu riscrivendomi direttamente tutto il codice . Ti ringrazio.

using namespace std;

int main()
{
    int vett=5;
    int A[vett];
    double media=0;
    int minimo;
    int massimo=0;
    int imax=0;
    int imin=0;

    for(int i=0; i<vett; i++)
    {
    cin>>A[i];
    media=media+A[i];


    if(A[i]>massimo)
   {
       massimo=A[i];
   imax=i;
   }
    if(A[i]<minimo)
    {
    minimo=A[i];
    imin=i;
    }



    }
     cout<<"media : "<<media/vett<<endl;
     //cout<<"minimo :"<<minimo;
     cout<<"massimo : "<<massimo<<endl;
     cout<<"minimo : "<<minimo<<endl;
      cout<<"Indice con valore piu' alto  : "<<imax<<endl;

cout<<"indice con valore piu basso : "<<imin;

 

[rodhellas]

Cosi va bene