Trouver le plus proche nombre de 0

Je suis en train de dépanner un programme en Java.

Exigences: la Nécessité de trouver la valeur la plus proche de zéro dans un Tableau. Dans le Tableau si les valeurs sont 1 et -1 le plus proche doit être à la valeur positive.

public class CloseToZero {    
    public static void main(String[] args) {    
        int[] data = {2,3,-2};    
        int curr = 0;    
        int near = data[0];     
        //find the element nearest to zero    
        for ( int i=0; i < data.length; i++ ){    
            curr = data[i] * data[i];     
            if ( curr <= (near * near) )  {     
                near = data[i]; 
            }     
        }    
        System.out.println( near );    
    }    
}

ce qui ne fonctionne pas?
ici, la sortie d'obtenir -2.Mais je suis à la recherche est supposons que 2 et -2 dans la matrice de cette situation positive de la valeur doivent être prioritaires
techniquement 1 et -1 les deux sont tout aussi proche de 0. par la différence de 1.
Dans ce cas, ajouter un autre if instruction pour vérifier si il est positif ou négatif.
La quadrature du nombre est mathématiquement élégant, mais il a considérablement restreint la gamme de nombres qui peut être accepté dans votre tableau. Je voudrais utiliser les Mathématiques.abs() à la place.

OriginalL'auteur user3172930 | 2014-05-20

java

Trier le tableau (ajouter une ligne de code) de sorte que le dernier numéro que vous choisissez sera positif si la même valeur absolue est sélectionné pour les nombres positifs et négatifs avec la même distance.

import java.util.Arrays;

public class CloseToZero {

    public static void main(String[] args) {

        int[] data = {2,3,-2};
        int curr = 0;
        int near = data[0]; 
        Arrays.sort(data);      // add this
        System.out.println(Arrays.toString(data));        
        //find the element nearest to zero
        for ( int i=0; i < data.length; i++ ){
            System.out.println("dist from " + data[i] + " = " + Math.abs(0 -data[i]));
            curr = data[i] * data[i]; 
            if ( curr <= (near * near) )  { 
                near = data[i];
            } 
        }
        System.out.println( near );
    }

Terrible exécution de la complexité. Il est O(n) avant de, tri prend plus que cela.

OriginalL'auteur JuanZe

Cela fera en O(n) temps:

int[] arr = {1,4,5,6,7,-1};

int closestIndex = 0;
int diff = Integer.MAX_VALUE;
for (int i = 0; i < arr.length; ++i) {
    int abs = Math.abs(arr[i]);
    if (abs < diff) {
        closestIndex = i;
        diff = abs;
    } else if (abs == diff && arr[i] > 0 && arr[closestIndex] < 0) {
        //same distance to zero but positive 
        closestIndex =i;
    }
}   
System.out.println(arr[closestIndex ]);

OriginalL'auteur kmera

Si vous utilisez java8:

import static java.lang.Math.abs;
import static java.lang.Math.max;

public class CloseToZero {
    public static void main(String[] args) {
        int[] str = {2,3,-2};
        Arrays.stream(str).filter(i -> i != 0)
                .reduce((a, b) -> abs(a) < abs(b) ? a : (abs(a) == abs(b) ? max(a, b) : b))
                .ifPresent(System.out::println);
    }
}

OriginalL'auteur M. Abbas

1

Juste ajouter un zéro à cette liste.

Ensuite trier la liste
```
Arrays.sort(data);
```
puis saisir le nombre de chiffres avant ou après le zéro et de choisir le minimum de plus grand que zéro

Il n'.
cela fonctionne, mais ce problème peut être résolu en temps O(n) fois. votre solution nécessite O(n lg n)
juste point

OriginalL'auteur Bachmann
0

Que vous multipliez les données[i] avec les données[i], une valeur négative et une valeur positive aura le même effet.
Par exemple, dans votre exemple: 2 et -2 sera 4. Donc, votre code n'est pas en mesure de sorte que vous avez besoin.

Donc, ici, il faut -2 comme la proximité de la valeur, car il a le même "poids" que 2.

oui c'est pourquoi je suis à la recherche de toute nouvelle méthode pour le programme donné ou de toute modification à l'interne
Donc, il devrait être une bonne chose pour indiquer que, dans votre question. Parce qu'il n'est pas clair.

OriginalL'auteur lpratlong
0

Hypothèse est que le tableau data a au moins 1 valeur.
```
int closedToZero = 0;
for ( int i = 1; i < data.length; i++ )
{
    if ( Math.abs(data[i]) < Math.abs(data[closedToZero]) ) closedToZero = i;
}
```
La valeur dans closedToZero est l'indice de la position fermée à zéro, et non de la valeur.

En fait, je veux la logique sans utiliser de fonction intégré
ensuite, la fonction return (num*num)/num;
Puis remplacer Math.abs(...) avec votre propre valeur absolue de la méthode/de code.
Ce code est faux. Il a essayé avec int[] data = {2, 3, -2, 4, 10, 6, -1};
problème, le code fonctionne parfaitement. Elle retourne le numéro d'index de la plus proche de zéro, et non pas le nombre lui-même!

OriginalL'auteur munyul

voici une méthode qui vous donne le plus proche de zéro.

cas d'utilisation 1 : {1,3,-2} ==> retour 1 : utiliser les Mathématiques.abs() pour la comparaison et obtenir le moins.
cas d'utilisation 2 : {2,3,-2} ==> retour 2 : utiliser les Mathématiques.abs() pour la comparaison et obtenir les Mathématiques.abs(moins)

cas d'utilisation 3 : { -2,3,-2} ==> retour -2: utiliser les Mathématiques.abs() pour la comparaison et obtenir le moins.

public static double getClosestToZero(double[] liste) {
//if the list is empty return 0
if (liste.length != 0) {
    double near = liste[0];
    for (int i = 0; i < liste.length; i++) {
        //here we are using Math.abs to manage the negative and
        //positive number
        if (Math.abs(liste[i]) <= Math.abs(near)) {
            //manage the case when we have two equal neagative numbers
            if (liste[i] == -near) {
                near = Math.abs(liste[i]);
            } else {
                near = liste[i];
            }
        }
    }
    return near;
} else {
    return 0;
}

}

Code sans aucune explication n'est pas considéré comme une bonne réponse dans la. Pouvez-vous également préciser votre réponse? (à partir de l'examen)

OriginalL'auteur Anass Gandalf

Vous pouvez le faire comme ceci:

String res = "";

        Arrays.sort(arr);
        int num = arr[0];
        int ClosestValue = 0;

        for (int i = 0; i < arr.length; i++)
        {
            //for negatives
            if (arr[i] < ClosestValue && arr[i] > num)
            num = arr[i];
            //for positives
            if (arr[i] > ClosestValue && num < ClosestValue)
            num = arr[i];
        }
        res = num;

        System.out.println(res);

Tout d'abord vous avez besoin pour stocker tous vos nombres dans un tableau. Après que trier le tableau --> c'est le truc qui va faire que vous n'utilisez pas les Mathématiques.abs(). C'est maintenant le temps de faire une boucle qui parcourt le tableau. Sachant que le tableau est trié est important que vous commencez à faire d'abord une instruction if pour les nombres négatifs, ensuite, pour les points positifs (de cette façon, si vous avez deux valeurs les plus proches de zéro, supposons -1 et 1 --> imprimer le positif).

Espère que cela va vous aider.

OriginalL'auteur Cristian Babarusi

0

La façon la plus simple de traiter cette question est diviser le tableau en positif et négatif de tri et de pousser les deux premiers éléments des deux tableaux dans un autre tableau. Amusez-vous!
```
function closeToZeroTwo(arr){
let arrNeg = arr.filter(x => x < 0).sort();
let arrPos = arr.filter(x => x > 0).sort();
let retArr = []; 
retArr.push(arrNeg[0], arrPos[0]);
console.log(retArr)
}
```
OriginalL'auteur DevDisrupt

Vous devez vous connecter pour publier un commentaire.