[c++] ricorsiva: operazioni su array(esercizio)

[mistergks]

Ho provato a svolgere questo esercizio..c'è qualcuno che mi dice cosa sbaglio?:

Si scriva in c++ una funzione RICORSIVA che, ricevuti come paramentri un array di interi e la sua dimensione, restituisca true se e solo se è verificata la condizione descritta di seguito: l'array (la cui dimensione si suppone essere multiplo di 3) va esaminato per terne di elementi. Ciascuna terna deve avere gli elementi esterni uguali tra loro e maggiori dell'elemento centrale. Inoltre, a sequenza di terne contenuta nell'array deve essere strettamente crescente, nel senso che in ogni terna gli elementi esterni devono essere strettamente minore dell'elemento centrale della terna successiva:
esempio:dato l'array: 2 1 2 5 2 5 7 5 7 9 6 9, di dimensione 12, la funzione dovrebbe restituire true. Infatti si può notare come ciascuna delle terne abbia sempre gli elementi esterni uguali fra loro e maggiori di quello centrale (ad esempio nella prima terna gli elementi esterni valgono entrambi 2 e sono maggiori dell'elemento centra che vale 1). Inoltre, la sequenza di terne è crescente: ad esempio, gli elementi esterni della seconda terna valgono 5, strettamente minore di 7 che è il valore degli elementi esterni ella terna successiva; Inoltre l'elemento centrale della seconda terna vale 2, strettamente minore di 5 che è il valore dell'elemento centrale della terna successiva.
Specificare quale deve essere la prima invocazione per la funzione.

CODICE SVILUPPATO DA ME:

bool ricorsiva(int array[],int dim, int i){ 
     if(dim%3!=0)
     return false;
     
     if(i==(dim+1)) //caso base
     return true;
     
     if(a[i-1]!=a[i+1] && a[i+1]<=a[i] && a[i]<=temp_centro && a[i-1]<=temp_sin && a[i+1]<=temp_des)
     return false;
     
     return ricorsiva(array, dim, i+3);
     
     temp_centro=a[i];
     temp_sin=a[i-1];
     temp_des=a[i+1]
}


La prima invocazione deve essere: ricorsiva(array, dim, 1)

[tuccio`]

Originariamente inviato da mistergks

Ho provato a svolgere questo esercizio..c'è qualcuno che mi dice cosa sbaglio?:

Si scriva in c++ una funzione RICORSIVA che, ricevuti come paramentri un array di interi e la sua dimensione, restituisca true se e solo se è verificata la condizione descritta di seguito: l'array (la cui dimensione si suppone essere multiplo di 3) va esaminato per terne di elementi. Ciascuna terna deve avere gli elementi esterni uguali tra loro e maggiori dell'elemento centrale. Inoltre, a sequenza di terne contenuta nell'array deve essere strettamente crescente, nel senso che in ogni terna gli elementi esterni devono essere strettamente minore dell'elemento centrale della terna successiva:
esempio:dato l'array: 2 1 2 5 2 5 7 5 7 9 6 9, di dimensione 12, la funzione dovrebbe restituire true. Infatti si può notare come ciascuna delle terne abbia sempre gli elementi esterni uguali fra loro e maggiori di quello centrale (ad esempio nella prima terna gli elementi esterni valgono entrambi 2 e sono maggiori dell'elemento centra che vale 1). Inoltre, la sequenza di terne è crescente: ad esempio, gli elementi esterni della seconda terna valgono 5, strettamente minore di 7 che è il valore degli elementi esterni ella terna successiva; Inoltre l'elemento centrale della seconda terna vale 2, strettamente minore di 5 che è il valore dell'elemento centrale della terna successiva.
Specificare quale deve essere la prima invocazione per la funzione.

CODICE SVILUPPATO DA ME:

bool ricorsiva(int array[],int dim, int i){ 
     if(dim%3!=0)
     return false;
     
     if(i==(dim+1)) //caso base
     return true;
     
     if(a[i-1]!=a[i+1] && a[i+1]<=a[i] && a[i]<=temp_centro && a[i-1]<=temp_sin && a[i+1]<=temp_des)
     return false;
     
     return ricorsiva(array, dim, i+3);
     
     temp_centro=a[i];
     temp_sin=a[i-1];
     temp_des=a[i+1]
}


La prima invocazione deve essere: ricorsiva(array, dim, 1)

credo che

if(a[i-1]!=a[i+1] && a[i+1]<=a[i] && a[i]<=temp_centro && a[i-1]<=temp_sin && a[i+1]<=temp_des)
     return false;

dovrebbero essere tutti or qui, invece di and

cioè se una di quelle condizioni è vera devi ritornare falso, no?

e poi aggiorni quelle variabili globali dopo la chiamata ricorsiva, non credo abbia molto senso che poi alla prima chiamata chi le inizializza quelle variabili?

[mistergks]

ops mi sa che è vero....vanno sostituiti con degli OR

per quanto riguarda le variabili temporanee andrebbero messe prima della chiamata ricorsiva? ma così facendo si memorizzano le a[i] correnti..invece a me serve memorizzare quelle della passata precedente

[tuccio`]

Originariamente inviato da mistergks

ops mi sa che è vero....vanno sostituiti con degli OR

per quanto riguarda le variabili temporanee andrebbero messe prima della chiamata ricorsiva? ma così facendo si memorizzano le a[i] correnti..invece a me serve memorizzare quelle della passata precedente

voglio dire... tu sei alla prima chiamata.. ora la seconda chiamata dovrà controllare che i valori precedenti siano minori di quelli che stai analizzando ora, ma nel momento in cui vai a fare quell'if.. nella seconda chiamata ricorsiva, nessuno modificherà mai quelle variabili, perché hai

return ricorsiva(array, dim, i+3);

quindi nel momento in cui, ad esempio, la seconda chiamata ricorsiva terminerà (quindi saranno finite anche tutte quelle "superiori", cioè tutte tranne la prima), ritornerà anche la prima (c'è un return, insomma.. deve ritornare quello che ritorna la seconda, quando ritorna la seconda), senza nemmeno modificare mai quelle variabili

secondo me fai molto prima ad aggiungere tre argomenti alla chiamata ricorsiva, tipo "sin, centro, des", e di volta in volta chiami

return ricorsiva(array, dim, i+3, i-1, i, i+1);

oppure semplicemente torni indietro nell'array nel caso in cui i sia maggiore di 1 per controllare i valori dietro

[mistergks]

non ho capito come faccio a dire che la variabile sin d esempio deve essere uguale a i-1?cioè come devo scrivere nei parametri della funzione??

[tuccio`]

gli passi a[i-1], oppure l'indice nell'array (cioè i-1).. insomma puoi fare un po' come vuoi

[mistergks]

e poi come faccio a controllarle nell'if?se metto a[i+1] si riferisce alla posizione corrente ... boh non ho capito...mi faresti vedere un esempio ?

[mistergks]

Originariamente inviato da tuccio`

secondo me fai molto prima ad aggiungere tre argomenti alla chiamata ricorsiva, tipo "sin, centro, des", e di volta in volta chiami

return ricorsiva(array, dim, i+3, i-1, i, i+1);

oppure semplicemente torni indietro nell'array nel caso in cui i sia maggiore di 1 per controllare i valori dietro

1)Questo intendo...dove devo usare nell'if queste variabili? i-1,i e i+1? ho un dubbio: è possibile passare 4 argomenti con lo stesso nome in una funzione?!
2)Cosa intendi per tornare indietro nell'array?!

[tuccio`]

Originariamente inviato da mistergks

1)Questo intendo...dove devo usare nell'if queste variabili? i-1,i e i+1? ho un dubbio: è possibile passare 4 argomenti con lo stesso nome in una funzione?!
2)Cosa intendi per tornare indietro nell'array?!

1) dovresti sostituire quelle temp_sin, temp_centro, temp_des che non aggiorni correttamente
2) intendo, che ad esempio, se i = 1 fai soltanto il controllo

if (a[i-1] != a[i+1] || a[i+1] <= a[i])
{
     return false;
}

se invece i è maggiore di 1, per controllare anche l'andamento crescente puoi fare così:

int j = i - 3;

if (a[i-1] != a[i+1] || a[i+1] <= a[i] || a[i] <= a[j] || a[i-1] <= a[j-1])
{
     return false;
}

senza usare var globali o ulteriori argomenti

[mistergks]

ho provato a rifarla seconde le indicazioni:

bool ricorsiva(int a[],int dim, int i){ 
     int j=i-3;
     
     if(dim%3!=0)
     return false;
     
     if(i==(dim-1)) //caso base
     return true;
     if(i==1){
              if(a[i-1] != a[i+1] || a[i+1] <= a[i])
              return false; 

     }else if(i > 1){
     if(a[i-1] != a[i+1] || a[i+1] <= a[i] || a[i] <= a[j] || a[i-1] <= a[j-1]) || a[i+1] <= a[j+1])
     return false;
     }
     return ricorsiva(a, dim, i+3);    
}

[sottovento]

Non ho capito bene:

Originariamente inviato da mistergks

dato l'array: 2 1 2 5 2 5 7 5 7 9 6 9, di dimensione 12, la funzione dovrebbe restituire true.

pero'

Originariamente inviato da mistergks

Inoltre, a sequenza di terne contenuta nell'array deve essere strettamente crescente, nel senso che in ogni terna gli elementi esterni devono essere strettamente minore dell'elemento centrale della terna successiva

A meno di clamorosi svarioni (che mi capitano spesso ) dovrebbe ritornare false.
Infatti la terna 5 2 5 ha gli elementi esterni (=5) che NON sono strettamente minori dell'elemento centrale della terna successiva.
Infatti la terna successiva e' 7 5 7 e non mi sembra che 5 sia strettamente minore di 5

[mistergks]

Originariamente inviato da sottovento

Non ho capito bene:



pero'


A meno di clamorosi svarioni (che mi capitano spesso ) dovrebbe ritornare false.
Infatti la terna 5 2 5 ha gli elementi esterni (=5) che NON sono strettamente minori dell'elemento centrale della terna successiva.
Infatti la terna successiva e' 7 5 7 e non mi sembra che 5 sia strettamente minore di 5

opsss...mi sa che ho sbagliato a scrivere la traccia...
dovrebbe essere cosi, ma controllerò stasera quando torno a casa..:
Inoltre, la sequenza di terne contenuta nell'array deve essere strettamente crescente, nel senso che in ogni terna gli elementi esterni devono essere strettamente minore degli elementi esterni della terna successiva

[mistergks]

ho provato a rifarla seconde le indicazioni:

bool ricorsiva(int a[],int dim, int i){ 
     int j=i-3;
     
     if(dim%3!=0)
     return false;
     
     if(i==(dim-1)) //caso base
     return true;
     if(i==1){
              if(a[i-1] != a[i+1] || a[i+1] <= a[i])
              return false; 

     }else if(i > 1){
     if(a[i-1] != a[i+1] || a[i+1] <= a[i] || a[i] <= a[j] || a[i-1] <= a[j-1]) || a[i+1] <= a[j+1])
     return false;
     }
     return ricorsiva(a, dim, i+3);    
}