eserciziVettori

un po' di pratica sui vettori

Esercizio nuoto

Quella cghe vogliamo creare è una applicazione che permetta ad un allenatore di una squadra di nuoto di vedere quanti dei suoi atleti hanno fatto dei tempi troppo alti rispetto ad un tempo specifico che decide l'allenatore.

Rispetto a quanto visto finora introduciamo una piccola variante: l'allenatore all'inizio decide quanti tempi vuole immettere e li immette uno alla volta.

Al momento di scrivere il programma non so quanto dovrà essere grande il vettore, in questo caso si rimanderà l'allocazione della memoria (sarebbe a dire la creazione del vettore) a quando si saprà la grandezza, cioè dopo che l'utente l'avrà comunicata scrivendola in una casella e premendo il pulsante corrispondente:


public class Piscina extends Application {
   TextField cNumeroTempi = new TextField();
   TextField cTempo = new TextField();
   Button pCreaVettore = new Button("inserisci numero tempi");
   int tempi[];

   @Override
   public void start(Stage primaryStage) {
      /* Quanto necessario per sistemare l'interfaccia grafica */
      pCreaVettore.setOnAction( e -> alloca());
   }

   public void alloca() {
      int numTempi= Integer.parseInt(cNumeroTempi.getText());
      tempi = new int[numTempi];
   }

}

La parte vista finora ci permette soltanto di creare (allocare spazio in memoria) il vettore tempi della dimensione adatta a poter contenere tutti i tempi che l'allenatore misurerà.

Una volta creato il vettore dobbiamo caricarlo (riempirlo di valori): per poter inserire i valori uno alla volta ci serve una variabile in più per tener conto del posto del vettore in cui dobbiamo inserire ciascun tempo: la chiamiamo posizione.

L'allenatore inserisce un tempo alla volta in una casella di testo: inserirà tale tempo, poi premerà il pulsante e il numero che avrà inserito sarà aggiunto a quelli immessi in precedenza. Ogni numero che inserirà andrà inserito nella posizione seguente a quella in cui è stato immesso il precedente. Tale azione la svolgeremo ogni volta che l'utente premerà il relativo pulsante, per questo useremo la variabile posizione.



public class Piscina extends Application {
   TextField cNumeroTempi = new TextField();
   TextField cTempo = new TextField();
   Button pCreaVettore = new Button("inserisci numero tempi")
   int tempi[];
   Button pInserisci = new Button("inserisci tempo");
   int posizione;

   @Override
   public void start(Stage primaryStage) {
      /* Quanto necessario per sistemare l'interfaccia grafica */
      pCreaVettore.setOnAction( e -> alloca());
      pInserisci.setOnAction( e -> inserisciTempo());
   }

   public void alloca() {
      int numTempi= Integer.parseInt(cNumeroTempi.getText());
      tempi = new int[numTempi];
      posizione = 0;
   }

   public void inserisciTempo() {
      if(posizione < tempi.length) {
         tempi[posizione] = Integer.parseInt(cTempo.getText());
         posizione++;
         cTempo.setText(""); // pulisco la casella
      }
   }

}

Fatto il caricamento, dobbiamo indicare in una casella di testo quanti sono i tempi superiori a quello previsto dal coach.
Risolviamo il problema col seguente algoritmo: confronto ciascun tempo a partire dal primo fino all'ultimo con quello del coach. Ogni volta che il tempo risulta superiore incrementerò di 1 un contatore. Alla fine mostrerò il risultato in una specifica casella di testo. Il codice:

finestra esempio nuotatori



public class Piscina extends Application {
   TextField cNumeroTempi = new TextField();
   TextField cTempo = new TextField();
   Button pCreaVettore = new Button("inserisci numero tempi")
   int tempi[];
   Button pInserisci = new Button("inserisci tempo");
   int posizione;
   TextField cCoach = new TextField();
   Button pLenti = new Button("conta lenti");
   
   @Override
   public void start(Stage primaryStage) {
      /* Quanto necessario per sistemare l'interfaccia grafica */
      pCreaVettore.setOnAction( e -> alloca());
      pInserisci.setOnAction( e -> inserisciTempo());
      pLenti.setOnAction( e -> contaLenti());
   }

   public void alloca() {
      int numTempi= Integer.parseInt(cNumeroTempi.getText());
      tempi = new int[numTempi];
      posizione = 0;
   }

   public void inserisciTempo() {
      if(posizione < tempi.length) {
         tempi[posizione] = Integer.parseInt(cTempo.getText());
         posizione++;
         cTempo.setText(""); // pulisco la casella
      }
   }
   
   public void contaLenti() {
      int contatore;
      int coach = Integer.parseInt(cCoach.getText());
      contatore = 0;
      for(int indice = 0; indice < tempi.length; indice++) {
         if(tempi[indice] > coach) {
            contatore++;
         }
      }
      eRisultati.setText("" + contatore);
   }

}

Per una squadra di calcio viene data una casella di testo tSquadra1, una casella di testo tPuntiSquadra1 con relativo pulsante inserisciRisultato1 ed in modo simmetrico per la seconda squadra di calcio la casella tSquadra2, tPuntiSquadra2 e inserisciRisultato2. Si inserisce nella casella di testo del punteggio il valore 0 se la squadra ha perso; il punteggio 1 se ha pareggiato ed in fine 2 se ha vinto. Tali valori si devono inserire per le ultime 5 partite, quindi ti dovrai appoggiare ad un vettore per la prima squadra ed un altro per la seconda. Proprio come detto sopra, quando l'utente premerà il pulsante, il vecchio risultato si dovrà cancellare per facilitare l'immissione del nuovo.
Aggiungi ora una casella di testo per fornire il risultato (tRisultato) ed il relativo pulsante per calcolarlo (calcolaRisultato): scrivere il nome della squadra che ha maggiore probabilità di vincere uno scontro diretto (confronta le somme).

Dato un array di N interi scrivere un programma Java per sommare tutti gli elementi.
Dato un array di N interi scrivere un programma Java per sommare tutti gli elementi che sono multipli di 3.
Dato un array di N interi scrivere un programma Java per sommare tutti gli elementi che non sono multipli di 3.
Dato un array di N interi scrivere un programma Java per sommare tutti gli elementi che sono contemporaneamente multipli di 2 e di 3.
Dato un array di N interi scrivere un programma Java per contare gli elementi pari.
Dato un array di N interi scrivere un programma Java per contare gli elementi dispari.
Dato un array di N interi scrivere un programma Java per contare quante volte compare un determinato valore k.
Dato un array di N interi scrivere un programma Java per stampare i valori degli elementi in posizione pari.
Dato un array di N interi scrivere un programma Java per trovare l’elemento di valore massimo e l’indice (nell’intervallo da 0 a N-1) della sua posizione.
Dato un array di N interi scrivere un programma Java per trovare l’elemento di valore minimo e l’indice (nell’intervallo da 0 a N-1) della sua posizione.
Dato un array di N interi scrivere un programma Java per trovare la media dei suoi valori e contare i valori sopra la media.
Dato un array di N interi scrivere un programma Java per verificare se tutti gli elementi hanno valore maggiore di k.
Dato un array di N interi scrivere un programma Java per verificare se tutti gli elementi hanno valore minore di k.
Dato un array di N interi scrivere un programma Java per verificare se tutti gli elementi hanno valore k.
Dato un array di N interi scrivere un programma Java per verificare se contiene almeno un elemento di valore maggiore di k.
Dato un array di N interi scrivere un programma Java per verificare se contiene almeno un elemento di valore minore di k.
Dato un array di N interi scrivere un programma Java per verificare se contiene almeno un elemento uguale a k.
Dato un array di N interi scrivere un programma Java per verificare se contiene almeno un elemento pari.
Dato un array di N interi scrivere un programma Java per verificare se contiene almeno un elemento dispari.
Dato un array di N interi scrivere un programma Java per verificare se contiene almeno tre elementi uguali a k.
Dato un array di N interi scrivere un programma Java per verificare se contiene almeno tre elementi consecutivi che valgono k.
Dato un array di N interi scrivere un programma Java per verificare se gli elementi in posizione pari sono pari.
Dato un array di N interi scrivere un programma Java per verificare se gli elementi in posizione dispari sono pari.
Dato un array di N interi scrivere un programma Java per verificare se gli elementi in posizione pari sono pari e quelli in posizione dispari sono dispari.
Dato un array di 5 interi scrivere un programma Java per scambiare il valore in posizione 0 con quello in posizione 4.
Dato un array di N interi scrivere un programma Java per invertire gli elementi (cioè il primo deve andare al posto dell’ultimo e viceversa, il secondo al posto del penultimo, etc.).
Dati due array di interi A è B (di dimensione N e M non necessariamente uguali) scrivere un programma Java per verificare se tutti i valori di B appaiono in A.
Dato un array di N interi scrivere un programma Java per verificare se gli elementi seguono l’ordine crescente.
Dato un array di N interi scrivere un programma Java per verificare se tutti gli elementi contenuti sono pari.
Dato un array di N interi scrivere un programma Java per contare gli elementi pari compresi tra 0 e 100.
Dati due array A e B di N interi scrivere un programma Java per costruire un array C (di dimensione 2N) che contenga nelle prime N posizioni gli elementi di A e nelle rimanenti N posizioni gli elementi di B.
Dati due array A e B di N interi scrivere un programma Java per costruire un array C (di dimensione 2N) che contenga nelle posizioni di indice pari gli elementi di A e nelle posizioni di indice dispari gli elementi di B.
Dato un array di N caratteri (dichiarato con char[] A=…) scrivere un programma Java per verificare se contiene almeno una 'a'.
Dato un array di N caratteri scrivere un programma Java per verificare se contiene almeno tre 'a'.
Dato un array di N caratteri scrivere un programma Java per verificare se contiene almeno tre 'a' consecutive.
Dato un array di N caratteri scrivere un programma Java per verificare se contiene almeno tre caratteri qualsiasi consecutivi.
Dato un array di N caratteri scrivere un programma Java per verificare se l’ordine dei caratteri determina una sequenza palindroma (cioè che non cambia se letta al contrario; ad esempio la sequenza 'a','c','e','c','a' è palindroma).
Dato un array di N caratteri scrivere un programma Java per verificare se contiene un’alternanza di 'a' e 'b' (due esempi: {'a', 'b', 'a', 'b', 'a'} e {'b','a', 'b', 'a', 'b', 'a'}).