esercizio tema d'esame

[geme84]

si realizzi un metodo avente come parametro un array di interi A che restituisca come risultato un boolean.Il risultato deve essere TRUE se e solo se PER OGNI indice i vale che A[i] soddisfa almeno una delle seguenti proprietà=
-per ogni 0<=j<i vale che se j è pari allora A[j]<A[i]
-A[i]=A[i-1]+A[i+1]


io ho fatto cosi ..

public static boolen m(Int A[]){
//inserisco la prima condizione (per ogni 0<=j<i vale che se j è pari allora A[j]<A[i])
boolean risposta=true;
    for(int i=0; i<A.lenght;i++){
    boolean left =true;
         for (int j=i+1;j<i;j++){
         if(j%2==0){
           return A[j]<A[i];}
             else{ left=false;}
///la seconda condizione non so come metterla
//
//
//
//
//controllo finale
if(left|right){
}
else{
risposta=false;}
}
return risposta;}

[Lomio]

per questa condizione A[i]=A[i-1]+A[i+1] io farei una cosa del genere:

for(int i = 1; i < A.lenght - 1; i++) {
   if (A[i] != A[i-1] + A[i+1]) {
      return false;
   }
}

[desa]

- nell'intestazione del metodo hai scritto "boolen" anzichè "boolean"
- sempre nell'intestazione il tipo di parametro è "int" con l'iniziale MINUSCOLA (e anche il nome della variabile "A" andrebbe minuscolo, per convenzione di Java)
- non capisco bene a che servono le due variabili "left" e "right" (e quest'ultima neppure la dichiari)... se sono i risultati delle valutazioni delle due condizioni, sono superflue: è sufficiente che, non appena ne trovi una falsa ritorni "false"; se invece è tutto ok alla fine del metodo restituisci "true"
- il ciclo più interno è sbagliato: se j parte da i+1, come fa poi a essere minore di j? In pratica non ci entrerà mai
- nella prima condizione se j è pari il tuo metodo ritorna SEMPRE: a te invece interessa che ritorni false solo se A[j]>=A[i], perchè in caso contrario devi valutare la seconda condizione della traccia

Prova a effettuare queste correzioni e a ripostare il codice

[desa]

Il codice di Lomio va bene (anche se secondo me, essendo un esercizio era meglio non scrivere il codice ma indicare solo delle linee guida...). L'unica cosa è che non è "lenght", ma "length"... nulla di che, comunque

[geme84]

public static boolean m(int a[]){
//inserisco la prima condizione (per ogni 0<=j<i vale che se j è pari allora A[j]<A[i])
boolean risposta=true;
    for(int i=0; i<A.length;i++){
    boolean left =true;
         for (int j=i-1;j<i;j++){
         if(j%2==0& A[j]<A[i]){
          }
             else{ left=false;}

//seconda condizione un po diversa da quella proposta da Lomio(ditemi se va bene)
              boolean right=true;
              for(int i = 1; i < A.length- 1; i++) {
   if (A[i] = A[i-1] + A[i+1]) {}
      else { right=false;}
   

//controllo finale
if(left|right){
}
else{
risposta=false;}
}
return risposta;}

Domanda a Lomio..ma perchè abbiamo fatto (int i = 1; i < A.lenght - 1; i++)?Non andava bene (int i = 0; i < A.lenght; i++)?

grazie a tutti...

[geme84]

- non capisco bene a che servono le due variabili "left" e "right" (e quest'ultima neppure la dichiari)... se sono i risultati delle valutazioni delle due condizioni, sono superflue: è sufficiente che, non appena ne trovi una falsa ritorni "false"; se invece è tutto ok alla fine del metodo restituisci "true"

il metodo deve essere true se esiste almeno una condizione che sia vera..quindi alla fine controllo se right o left sia vera

[desa]

Ok, ho capito. In realtà non ti serve memorizzare entrambi i valori booleani estratti dai due controlli: è sufficiente che non appena un controllo fallisce ritorni false.
In genere è una questione di performance (ti eviti di eseguire elaborazioni non necessarie, alleggerendo la computazione)... ma ad esempio, ricordo che in università avevo un professore che voleva il return solo alla fine dei metodi. Insomma, informati come preferiscono da te.

Allora:
- devi sostituire TUTTE le occorrenze della variabile "a" che sono ancora maiuscole: Java è case-sensitive e, se compilato, il metodo ti segnalerebbe errore;
- attenzione che non chiudi MAI le parentesi graffe dei cicli for
- come operatori logici di congiunzione (AND) e disgiunzione (OR) è meglio usare "&&" oppure "||"
- boolean left = true deve essere dichiarato fuori dal for, come fai con "right": se no, non appena esci dal ciclo è come se non esistesse più (e non compilerebbe, visto che poi cerchi di utilizzarlo a fondo programma)
- è ridondante utilizzare un if-else se poi uno dei due rami non contiene codice... è sufficiente invertire la logica e usare solo if. Nel primo caso puoi fare

if (!(j % 2 == 0 && a[j] < a[i]))

... prova tu a sistemare anche gli altri due
- si vede che sei allergico alle doppie : l'operatore di confronto è "==", non "=" (if della seconda condizione)

Per rispondere alla tua ultima domanda: si parte da 1 perchè, se iniziassi da 0, alla prima iterazione l'elemento i - 1 sarebbe -1... e dunque non valido

Comunque: sia chiaro che con i miei appunti non voglio farti da professore...!

[geme84]

- boolean left = true deve essere dichiarato fuori dal for, come fai con "right": se no, non appena esci dal ciclo è come se non esistesse più (e non compilerebbe, visto che poi cerchi di utilizzarlo a fondo programma)

boolean left è il booleano che controlla se è vera la condizione del ciclo
for (int j=i-1;j<i;j++),il booleano right controlla il ciclo for(int i = 1; i < a.length- 1; i++) e alla fine il booleano risposta che precede il ciclo for(int i=0; i<a.length;i++) mi da la risposta totale..tutti e 3 i booleani precedono il ciclo che devono controllare...secondo me è corretto

è ridondante utilizzare un if-else se poi uno dei due rami non contiene codice... è sufficiente invertire la logica e usare solo if.

su questo hai ragione tu, ma per motivi didattici sono portato a scrivere il programma in questa maniera

Per rispondere alla tua ultima domanda: si parte da 1 perchè, se iniziassi da 0, alla prima iterazione l'elemento i - 1 sarebbe -1... e dunque non valido

Non so se ho capito bene quello che volevi dirmi...io ho fatto cosi

for(int i=1; i<a.length;i++){
boolean left =true;
for (int j=i-1;j<i;j++){

i vale1 quindi i-1 vale 0, dunque j parte da 0...



Grazie ancora per la tua cortesia

public static boolean m(int a[]){
//inserisco la prima condizione (per ogni 0<=j<i vale che se j è pari allora A[j]<A[i])
boolean risposta=true;
    for(int i=1; i<a.length;i++){
    boolean left =true;
         for (int j=i-1;j<i;j++){
         if(j%2==0&& a[j]<a[i]){
          }
             else{ left=false;}}

//seconda condizione un po diversa da quella proposta da Lomio(ditemi se va bene)
              boolean right=true;
              for(int i = 1; i < a.length- 1; i++) {
   if (a[i] == a[i-1] + a[i+1]) {}
      else { right=false;}}
   

//controllo finale
if(left||right){
}
else{
risposta=false;}
}
return risposta;}

[desa]

Ho capito quello che vuoi fare, ma così com'è il tuo codice non funziona (non compilerebbe nemmeno!).
Naturalmente ci sono molti modi per risolvere il tuo problema (ogni problema, in realtà), ma per come hai strutturato l'algoritmo ne vedo due in particolare:
1) esegui un primo ciclo su "i" per controllare la prima condizione, poi esegui un secondo ciclo (sempre su "i") per controllare la seconda condizione e alla fine, sulla base dei due controlli, valorizzi "risposta";
2) esegui un unico ciclo su "i" e, ad ogni iterazione, verifichi sia la prima sia la seconda condizione. Alla fine valorizzi "risposta" come nel caso sopra.
Il codice che hai scritto è "ibrido": presenta caratteristiche sia della prima che della seconda soluzione... ma così com'è non va bene.

Provo a scriverti il codice (riformattato, spero sia chiaro lo stesso) per la soluzione 1)

public static boolean m(int a[])
{
//inserisco la prima condizione (per ogni 0<=j<i vale che se j è pari allora A[j]<A[i])
  boolean risposta = true;

  boolean left = true;

  for (int i = 1; i < a.length; i++)
  {
    for (int j = i - 1; j < i; j++)
    {
      if(j % 2 == 0 && a[j] < a[i])
      {
      }
      else
      {
        left = false;
      }
    }
  }

//seconda condizione un po diversa da quella proposta da Lomio(ditemi se va bene)
  boolean right = true;

  for (int i = 1; i < a.length - 1; i++)
  {
    if (a[i] == a[i - 1] + a[i + 1])
    {
    }
    else
    {
      right = false;
    }
  }

//controllo finale
  if (left || right)
  {
  }
  else
  {
    risposta = false;
  }

  return risposta;
}

Per il resto, mi sembra vada bene così.

[geme84]

for (int i = 1; i < a.length - 1; i++)
  {
    if (a[i] == a[i - 1] + a[i + 1])
    {
    }
    else
    {
      right = false;
    }
  }

ti chiedo le ultime cose...
-come mai il ciclo deve anare fino a a.lenght-1 e non fino ad a.lenght?
-volendo nel ciclo precedente, dove dico che int j=i-1, potevo anche scrivere int j=0?(tenendo conto che il testo diceva 0<=j<i)

grazie ancora