[JAVA] Metodo boolean su un array di interi

[Laurie]

Ciao!
Innanzitutto: non so se il titolo del post vada bene..il testo dell'esercizio che vorrei proporre è lunghetto e difficile da riassumere. Se il titolo non va bene, mi scuso in anticipo!

Questo esercizio è preso da una prova d'esame recente (esame che anch'io dovrò sostenere prima o poi ). Vi posto il testo e il mio tentativo di risoluzione (tentativo, temo, miseramente fallito).

Si realizzi un metodo avente come parametro formale un array di interi A che restituisca come risultato un boolean. Il risultato deve essere true SE E SOLO SE ESISTE ALMENO un indice i tale che A[i] soddisfi le seguenti due proprietà:
-per ogni 0<= j < i vale che A[j] < A[i] OPPURE A[j]= 100
- per ogni i < k < A.length vale che A[k] è pari


RISOLUZIONE

public boolean met (int A[]) {  

/* Io ho pensato di inizializzare da subito una variabile boolean falsa; poi il valore viene modificato in base al risultato dei controlli su k e j */

  boolean b = false;

/* Nel testo non è specificato, ma, conoscendo il prof penso di dover considerare anche i casi
 particolari nel seguente modo: se i ha indice 0, cioè non ha alcun j alla sua sinistra, considero
 la condizione du j come verificata. devo quindi valutare solo la condizione sui k. Se c'è un 
qualche k per cui la condizione non è verificata, allora il while si interrompe e passo a scorrere
 l'indice i. */

   int i = 0;

   int k = 1;

   boolean h = true;

   while (k < A.lenght & h == true) {

     if (A[k]%2 == 0) {

      h = true;

      k = k+1; 

      }

     else {h= false;}

   b = h;
   
    if (b) {return b;} /* se tutti i k dopo i=0 verificano la condizione, ho trovato l'i che
 cercavo. Il metodo risponde e termina. Altrimenti prosegue valutando gli altri i, j e k. */

       else {

        int i = 1;

	int j = 0;

         boolean f = true;

           while ( j<i & f==true) {

              if ( A[j] < A[i] | A[j] == 100) {

	      }
              
                 else { f = false;}

                 j = j + 1;

                 }

               if (f == true) {

                   int k = i + 1;

                    boolean c = true;

                       while (k < A.length & c == true) {

                   
                           if (A[k]%2 == 0) {

                            }

                            else {

                            c= false;

                            }

                          K = k + 1;

                       }

...                     

 }
    
/* però a questo punto mi sto un po' incartando...cioè: 
 prima cosa: mi sa che non è ne formalmente corretto nè funzionante.
 seconda cosa : anche ammettendo che la prima parte vada bene, ora dovrei fare anche il 
secondo caso particolare, quello cioè con i= A.length -1. Ma dove lo metto?
 terza cosa: ora dovrei far sì che non appena entrambe le condizioni si verifichino insieme, il 
metodo termina rispondendo true. */

Fino a qui c'è qualcosa di giusto?
Potete aiutarmi?
Grazie

[andbin]

Originariamente inviato da Laurie
Si realizzi un metodo avente come parametro formale un array di interi A che restituisca come risultato un boolean. Il risultato deve essere true SE E SOLO SE ESISTE ALMENO un indice i tale che A[ i] soddisfi le seguenti due proprietà:
-per ogni 0<= j < i vale che A[j] < A[ i] OPPURE A[j]= 100
- per ogni i < k < A.length vale che A[k] è pari

A parte i formalismi del testo, quello che dovevi forse fare è tradurre "a parole" tutta questa logica.

Che da quanto citato, risulta essere: dato un elemento X (ad un certo indice), cercare negli elementi precedenti un valore inferiore di X oppure 100 e cercare negli elementi successivi un valore pari. Se una di queste condizioni è vera, va restituito true.

Quindi se ne deduce che sarebbero da fare 2 scansioni "annidate". Una esterna e per ogni elemento se ne fa un'altra interna. Quella interna può scansionare tranquillamente tutto l'array, facendo però una cosa se j<i e un'altra cosa se j>i (scartando quindi la situazione di i == j).
Per elementi precedenti si verifica se c'è un valore minore di A[i] oppure 100, quando la scansione passa ai valori successivi, si verifica se è pari.

Viene semplice, pulito e lineare: 2 for annidati, 2 test "principali" nel for interno e in questi due "rami" si fanno i test specifici come indicato sopra.

Si può anche fare facendo 2 cicli interni in sequenza, uno per gli elementi precedenti e uno per quelli successivi .... questione di gusti, in effetti.

Tutto qui.