Elimina Duplicati

4 Risposte

• 

  Rubik

  Utente Attivo

  Iscritto da

  ago, 2020

  Messaggi:

  440

  Re: Elimina Duplicati

  03 set 2020, 23:26

  Le soluzioni sono molteplici, e non so quante istruzioni conosci, con distinct, basta una riga di codice.
  
  Ma forse visto come hai impostato il codice, ti aiuto con la logica dei due cicli di for nidificati, come hai tentato di fare.
  Per capire meglio hai anche bisogno di una seconda matrice dove depositare i numeri non duplicati, per cui oltre a:

  
  int[]A=new int [n];
  

  dichiari anche:

  
  int[]B=new int [n];
  

  il primo dato da mettere in B, è quello in posizione 0, che essendo il primo non è un duplicato

  
  B[0] = A[0];
  

  Ora i due cicli for il primo cicla tutte le le posizioni della matrice A[], e mette a false la variabile: boolean duplicato;
  
  il secondo cicla tutte le posizioni riempite della matrice B[]
  per fare questo hai bisogno di un indice che incrementi ogni volta che metti un dato non duplicato in B[]
  
  per cui il confronto avviene in sequenza tra il dato prelevato in A[] e tutti idati in B[] ma senza superare l'indice che ti dice quanti numeri hai immesso in B[].
  Se il confronto dice che uno qualsiasi dei dati in B[] è uguale al dato che stai processando prelevato da A[], metti a true la variabile: boolean duplicato; e esci dal ciclo con break;
  Alla fine del ciclo di B[], se duplicato == false incrementi l'indice, copi il dato di A[] in B[indice]; e il processo ricomincia con il dato successivo che si trova in A[].
  
  alla fine anche del ciclo di A[], in B[] ci saranno solo numeri non duplicati, che puoi visualizzare come hai gia fatto, l'unica accortezza è non stampare tutti i valori presenti in B[] ma solo quelli da zero a indice.
  

  
   for (int i = 0; i < indice; i++)
          {
             System.out.print(B[i] + " ");
          }
  

• 

  andbin

  Super Famoso

  Iscritto da

  ott, 2013

  Messaggi:

  6272

  Re: Elimina Duplicati

  04 set 2020, 04:24

  Tuyo ha scritto:

  ---

  Scrivere un programma Java che legga da input una sequenza A di n interi e stampi a video la sotto-sequenza di A priva di duplicati.

  Se devi solo fare la stampa priva di duplicati (quindi non modificare A per togliere i duplicati, non generare un nuovo array senza duplicati, non altro ..) allora è banale.
  
  Hai un array A. Ciclo for principale, per ciascun elemento A[j] ti devi chiedere se è un duplicato, anzi dicendo meglio: se quel valore l'avevi già stampato prima.
  
  Quindi per ciascun indice j devi "guardare" i valori negli indici da 0 fino a j-1 (for annidato).
  Se trovi il valore, allora A[j] è un duplicato ---> non lo stampi.
  Se non trovi il valore, allora A[j] non è un duplicato ---> lo stampi.
  
  È proprio tutto lì! E si può usare una variabile boolean per il trovato/non-trovato ma si può anche usare in modo furbo l'istruzione continue con label ("etichetta") per far continuare il ciclo principale saltando la stampa.
• 

  Rubik

  Utente Attivo

  Iscritto da

  ago, 2020

  Messaggi:

  440

  Re: Elimina Duplicati

  05 set 2020, 00:55

  Quattro soluzioni, due scolastiche, una logica e l'ultima compatta.
  Per l'input dei dati ho lasciato il codice scritto da Tuyo.
  

  
  package rimuoveduplicati;
  
  import java.util.*; 
  
  public class RimuoveDuplicati
  {
      public static void main(String[] args)
      {   
          // 4 metodi per stampare senza duplicati una matrice di interi
          // INPUT DATI, UNICO, senza controlli ************************
          Scanner input = new Scanner (System.in);
          System.out.println("Quanti valori immetterai?");
          int n = input.nextInt(); // usato nel metodo 1) e 2)
          System.out.println("Immetti " + n + " interi");  
          int A[] = new int [n]; // usata nel metodo 1) 2) e 3)
          int B[] = new int [n]; // usato nel metodo 1)
          ArrayList<Integer> C = new ArrayList<>();  // usato nel metodo 4)
          int indice = 0; // usato nel metodo 1)
          boolean Duplicato = false; // usato nel metodo 1) e 2
          // caricamento interi utente in matrice A e ArrayList C
          for(int i = 0; i < n; i++)
          {
             A[i] = input.nextInt(); // usata nel metodo 1) 2) e 3)
             C.add(A[i]); // usato nel metodo 4)
          }//**********************************************************
          
          // 1) CON MATRICE AGGIUNTIVA E INDICE (SCOLASTICO)
          System.out.println("con matrice e indice");
          B[0] = A[0]; // il primo dato non è un duplicato
          for (int ing = 1; ing < n; ing++) // ciclo A
          {
              Duplicato = false; // ad ogni ciclo si parte con false
              for (int usc = 0; usc <= indice ; usc++) // ciclo B
              {
                  if (B[usc] == A[ing]) // è sufficiente la prima corrispondenza per uscire con true
                  {   
                      Duplicato = true; 
                      break;
                  }
              }
              if (Duplicato == false) // controllo alla fine del ciclo B
              {
                  indice = indice + 1; // mi dice quanti interi 
                  B[indice] = A[ing];  // non duplicati ho immesso in B[]
              }
          }
          for (int i = 0; i <= indice; i++) // stampa alla fine del cilo A
          {
             System.out.print(B[i] + " ");
          }
          System.out.println();
          
           // 2) STAMPA DIRETTA (SCOLASTICO)
          System.out.println("stampa diretta");
          System.out.print(A[0] + " "); // il primo dato non è un duplicato
          for (int ing = 1; ing < n; ing++) // ciclo Totale
          {
              Duplicato = false; // ad ogni ciclo si parte con false
              for (int usc = 0; usc < ing ; usc++) // ciclo Parziale
              {
                  if (A[ing] == A[usc]) // è sufficiente la prima corrispondenza per uscire con true
                  {   
                      Duplicato = true; 
                      break;
                  }
              }
              if (Duplicato == false) // controllo alla fine del ciclo Parziale
              {
                 System.out.print(A[ing] + " "); // non duplicato, stampo
              }
          }
          System.out.println();
          
          //***********************************************************      
          // 3) CON CONTAINS: IL PIU' LOGICO, si ha anche il risultato usabile. 
          System.out.println("con contains");
          ArrayList<Integer> D = new ArrayList<>(); // per uso futuro e controllo con contains 
          for (int corr : A) // for each
          {
              if  (D.contains(corr) == false)
              {
                  D.add(corr); // nell'ArrayList
                  System.out.print(corr + " ");
              }
          } 
          System.out.println();
          
          //*****************************************************************
          // 4) CON DISTINCT IL PIU' COMPATTO
          System.out.println("con distinct");
          C.stream().distinct().forEach((e) -> {System.out.print(e + " ");});
      }   
  }       //*****************************************************************
  

• T

  Tuyo

  Pochi posts

  Iscritto da

  set, 2020

  Messaggi:

  4

  Re: Elimina Duplicati

  17 set 2020, 19:32

  Grazie a tutti per il vostro tempo
  Contestualizzo meglio la mia situazione: questo è un esercizio scolastico, come programma svolto siamo veramente al minimo sindacale: al di fuori degli Array (liv. base) e i cicli while e for (e gli if) non abbiamo fatto nulla.
  Quindi le soluzioni 3 e 4 di Rubik sono da 'scartare' (non perché non siano valide, anzi) ma perché usacose che ancora non ci sono state insegnate, quindi opterei per la soluzione 1/2.
  -andbin grazie anche a te: purtroppo non abbiamo fatto l'istruzione continue con label ("etichetta")