Java en supprimant les zéros du tableau

Question

J'essaye d'écrire un programme qui, lorsqu'il sera exécuté, passera par un tableau et supprimera toutes les instances de 0.0 et changera la taille du tableau égal au nombre d'éléments non nuls et les mettra éléments dans leur ordre précédent. Autrement dit, si n = 10 et le contenu d'un [j], j = 0 à n - 1 sont d'abord

0.0, 1.2, 0.0, 0.0, 0.0, 2.3, 0.0, 9.7, 5.6, 0.0 

puis après l'exécution du code le contenu doit être

n=4, a[0]=1.2, a[1]=2.3, a[2]=9.7, and a[3]=5.6. 

Cette est ce que j'ai jusqu'ici:

import java.util.Scanner; 
public class hw2 
{ 
    public static void main(String[] args) 
    { 
     Scanner scan = new Scanner(System.in); 
     final double KEY = 0.0; 
     int n = scan.nextInt(); 
     double[] a = new double[n]; 
     for(int i=0; i<n; i++) 
     { 
      a[i] = scan.nextDouble(); 
     } 
     for(int k = 0; k<n; k++) 
     { 
      if(a[k] == KEY) 
      { 
       a[k] = a[k+1]; 
       n--; 
      } 
      System.out.println(a[k]); 
     } 
    } 
} 

Juste un petit coup de pouce dans la bonne direction serait apprécié.

Answer 1

Votre mise en œuvre (2ème boucle) n'est pas juste, il échouera à de simples cas de test: Entrée> 5 2,0 2 0,0 3 0,0 Votre programme aura mauvaise sortie: 2.0 2.0 3.0 3.0

mais il devrait être 2,0 2,0 3

En outre, vous ne pouvez pas utiliser == pour comparer deux doubles.

Le code suivant est ma Baser solution sur votre code actuel:

public class hw21 { 
    public static void main(String[] args) { 
     Scanner scan = new Scanner(System.in); 
     final double KEY = 0.0; 
     final Double ACCEPTABLE_TOLERANCE = 0.000000000001d; 

     int n = scan.nextInt(); 
     double[] a = new double[n]; 
     for (int i = 0; i < n; i++) { 
      a[i] = scan.nextDouble(); 
     } 
     for (int k = 0, j = 0; k < n; k++) { 
      if (Math.abs(a[k] - KEY) < ACCEPTABLE_TOLERANCE) { 
       continue; 
      } 
      a[j] = a[k]; 
      System.out.println(a[j]); 
      j++; 
     } 
    } 
} 

Aussi je préfère utiliser un ArrayList comme ci-dessous:

public class hw2 { 
public static void main(String[] args) { 
    Scanner scan = new Scanner(System.in); 
    final double KEY = 0.0; 
    final Double ACCEPTABLE_TOLERANCE = 0.000000000001d; 

    int n = scan.nextInt(); 
    double[] a = new double[n]; 
    for (int i = 0; i < n; i++) { 
     a[i] = scan.nextDouble(); 
    } 

    List<Double> newList = new ArrayList<Double>(); 
    for (int k = 0; k < n; k++) { 
     if (Math.abs(a[k] - KEY) < ACCEPTABLE_TOLERANCE) { 
      continue; 
     } 
     newList.add(a[k]); 
    } 

    System.out.println("There are " + newList.size() + " no-zero double:"); 
     System.out.println(newList); 
    } 
} 

Answer 2

Envisagez d'utiliser un ArrayList, qui vous permettra d'ajouter des éléments quand vous le souhaitez, de grandir au besoin et de maintenir un nombre précis. Bien que dans ce cas, si vous vouliez/deviez utiliser un tableau, vous pourriez simplement ne pas enregistrer la valeur si c'est "0", peut-être. (Ne pas non plus incrémenter la "variable tableau utilisée", sauf si vous ajoutez, donc vous savez combien contient des données "non 0" ou traiter le premier "0" rencontré pendant l'itération comme "fin des données utiles" - les tableaux sont initialisé avec la valeur par défaut du type.)

Si vous voulez passer d'un tableau avec des zéros à un tableau sans zéros, vous devez utiliser deux passages - un pour compter les non-zéros, pour construire un nouveau tableau de la taille appropriée, puis copiez les valeurs non nulles. Cela peut également être fait en inverse (compacter le tableau initial, puis copier la partie "remplie"), mais c'est un peu plus compliqué.

Si vous continuez avec votre approche actuelle (que le tableau de résultat aura des zéros, mais à la fin), vous devez maintenir deux pointeurs d'index - l'une est la iterator boucle primaire, le second est le l'emplacement suivant pour mettre la valeur non nulle, qui est incrémentée uniquement lorsqu'une valeur est copiée (ou non déplacée, comme lorsque les deux index sont identiques, ce qui sera le cas jusqu'à ce que le premier 0 soit rencontré). Assurez-vous de "zéro" l'endroit où vous déplacez le non-zéro. Le nombre de coups peut être réduit si l'ordre n'a pas besoin d'être conservé.

Answer 3

import java.util.Arrays; 
import java.util.Scanner; 

public class StackOverflow1 
{ 
    public static final double KEY = 0.0; 
    private static final Scanner INPUT = new Scanner(System.in); 

    public static void main(String[] args) { 


     int length = INPUT.nextInt(); 
     double[] array = new double[length]; 

     for(int i=0; i<length; i++) { 
      array[i] = INPUT.nextDouble(); 
     } 

     int index = 0; 
     for(int k = 0; k < length ; k++) { 
      if(array[k] == KEY) { 
       continue; 
      } 
      array[index] = array[k]; // bring the non-zeroth element forward 
      if (index != k) array[k] = 0; //make the non-zeroth element zero in the actual location 
      index++; 
     } 
     System.out.println("n = " + index + " array = " + Arrays.toString(array)); 
    } 
} 

Answer 4

Vous pouvez supprimer ces zéros non désirés comme suit, mais dans ce cas, ils sont triés.

@org.junit.Test 
public void test15() throws Exception { 
    double[] arr = new double[]{0.0,1.1,0.1,0.0,2.1}; 
    double[] nonZeroArr = arr; 

    Arrays.sort(nonZeroArr); 
    int index = -1; 
    while((index = Arrays.binarySearch(nonZeroArr, 0.0)) > -1){ 
     double[] newArr = new double[nonZeroArr.length-index-1]; 
     System.arraycopy(nonZeroArr, index+1, newArr, 0, newArr.length); 
     nonZeroArr = newArr; 
    } 
    for (double d : arr) { 
     System.out.print(d +","); 
    } 
    System.out.println(); 
    for (double d : nonZeroArr) { 
     System.out.print(d + ","); 
    } 
} 

Answer 5

SI vous voulez sonner vraiment intelligent au point de classe que c'est un one-liner dans beaucoup de langues qui sont plus productives que Java :)