Java 正在查找与0最近的数字

我正在尝试用Java对一个程序进行故障排除

要求：需要在数组中找到最接近零的值。在数组中，如果值类似于1和-1，则最接近的值应为正值

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 );    
    }    
}

接近零的公共类{
公共静态void main（字符串[]args）{
int[]数据={2,3，-2}；
int curr=0；
int near=数据[0]；
//找到最接近零的元素
对于（int i=0；i如果（curr将数据[i]乘以数据[i]，则负值和正值将产生相同的影响。
例如，在您的示例中：2和-2将是4。因此，您的代码无法按需要排序

因此，这里，它取-2作为近似值，因为它与2具有相同的“权重”。
只需将零添加到此列表

然后对列表进行排序

Arrays.sort(data);

然后获取零之前或之后的数字，并选择大于零的最小值。假设数组
数据
至少有一个值

int closedToZero = 0;
for ( int i = 1; i < data.length; i++ )
{
    if ( Math.abs(data[i]) < Math.abs(data[closedToZero]) ) closedToZero = i;
}

int closedToZero=0；
对于（int i=1；i

closedToZero
中的值是闭合到零的索引，而不是值。
对数组进行排序（添加一行代码），这样，如果为具有相同距离的正数和负数选择相同的绝对值，则您拾取的最后一个数将为正数

源代码：

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 );
    }
}

导入java.util.array；
公共类接近零{
公共静态void main（字符串[]args）{
int[]数据={2,3，-2}；
int curr=0；
int near=数据[0]；
Arrays.sort（data）；//添加此
System.out.println（Arrays.toString（data））；
//找到最接近零的元素
对于（int i=0；iO（n）
时间内完成：

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 ]);

int[]arr={1,4,5,6,7，-1}；
int closestinex=0；
int diff=整数最大值；
对于（int i=0；i0&&arr[closestinex]<0）{
//到零的距离相同，但为正
闭合指数=i；
}
}   
System.out.println（arr[closestinex]）；
如果您使用的是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);
    }
}

导入静态java.lang.Math.abs；
导入静态java.lang.Math.max；
公共类接近零{
公共静态void main（字符串[]args）{
int[]str={2,3，-2}；
Arrays.stream（str.filter）（i->i！=0）
.减少（（a，b）->abs（a）
这里有一个方法，可以为您提供最接近零的值


用例1:{1,3，-2}=>return1：使用Math.abs（）进行比较，得到最小值
用例2:{2,3，-2}==>返回2：使用Math.abs（）进行比较，得到Math.abs（最少）
用例3:{-2,3，-2}=>return-2：使用Math.abs（）进行比较，得到最小值

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;
}

public静态双getClosestToZero（double[]liste）{
//如果列表为空，则返回0
如果（liste.length！=0）{
双近=列表[0]；
for（int i=0；i
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);

String res=”“；
数组。排序（arr）；
int num=arr[0]；
int ClosestValue=0；
对于（int i=0；inum）
num=arr[i]；
//积极的
if（arr[i]>ClosestValue&&num

首先，您需要将所有数字存储到一个数组中。然后对数组-->进行排序，这就是让您不使用Math.abs（）的诀窍。现在是进行循环的时候了。知道数组已排序后，首先对负数进行IF语句，然后对正数进行IF语句非常重要（这样，如果有两个最接近零的值，假设-1和1-->将打印正的值）

希望这能对您有所帮助。
处理此问题的最简单方法是将数组分成正数和负数排序，并将前两项从两个数组推送到另一个数组中。祝您玩得愉快

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)
}

功能接近零二（arr）{
设arrNeg=arr.filter（x=>x<0.sort（）；
让arrPos=arr.filter（x=>x>0.sort（）；
设retArr=[]；
重新定位推送（arrNeg[0]，arrPos[0]）；
console.log（retArr）
}
按升序对数组排序的最简单方法假设输入如下：

int[] array = {10,-5,5,2,7,-4,28,65,95,85,12,45};

然后在排序后，它将给出如下输出：

{-5,-4,2,5,7,10,12,28,45,65,85,95,}

对于正整数，最接近的正数是：2

逻辑：

public class Closest {

public static int getClosestToZero(int[] a) {

    int temp=0;
    //following for is used for sorting an array in ascending nubmer
    for (int i = 0; i < a.length-1; i++) {
        for (int j = 0; j < a.length-i-1; j++) {
            if (a[j]>a[j+1]) {
                temp = a[j];
                a[j]=a[j+1];
                a[j+1]=temp;
            }
        }
    }
    //to check sorted array with negative & positive  values
    System.out.print("{");
    for(int number:a)
        System.out.print(number + ",");

    System.out.print("}\n");
    //logic for check closest positive and Integer
    for (int i = 0; i < a.length; i++) {
        if (a[i]<0 && a[i+1]>0) {
            temp = a[i+1];
        }
    } 
    return temp;
}

  public static void main(String[] args) {
    int[] array = {10,-5,5,2,7,-4,28,65,95,85,12,45};
    int closets =getClosestToZero(array);
    System.out.println("The Closest Positive number is : "+closets);
  }

}

公共类{
公共静态int getClosestToZero（int[]a）{
内部温度=0；
//以下for用于对升序numer中的数组进行排序
for（int i=0；ia[j+1]）{
温度=a[j]；
a[j]=a[j+1]；
a[j+1]=温度；
}
}
}
//使用负值和正值检查排序数组的步骤
系统输出打印（“{”）；
对于（整数编号：a）
系统输出打印（数字+“，”）；
System.out.print（“}\n”）；
//检查最近正整数的逻辑
for（int i=0；istatic void closestToZero(){
    int[] arr = {45,-4,-12,-2,7,4};
    int max = Integer.MAX_VALUE;
    int closest = 0;
    for (int i = 0; i < arr.length; i++){
        int value = arr[i];
        int abs = Math.abs(value);
        if (abs < max){
            max = abs;
            closest = value;
        }else if (abs == max){
            if (value > closest){
                closest = value;
            }
        }
    }

public static void trier(int tab[]) {

    int tmp = 0;

    for(int i = 0; i < (tab.length - 1); i++) {

        for(int j = (i+1); j< tab.length; j++) {

            if(tab[i] > tab[j]) {
                tmp = tab[i];
                tab[i] = tab[j];
                tab[j] = tmp;

            }

        }

    }

    int prochePositif = TableauPositif(tab);

    int procheNegatif = TableauNegatif(tab);

    System.out.println(distanceDeZero(procheNegatif,prochePositif));



}
public static int TableauNegatif(int tab[]) {

    int taille = TailleNegatif(tab);


    int tabNegatif[] = new int[taille];


    for(int i = 0; i< tabNegatif.length; i++) {

        tabNegatif[i] = tab[i];
    }
    int max = tabNegatif[0];

    for(int i = 0; i <tabNegatif.length; i++) {

        if(max < tabNegatif[i])
            max = tabNegatif[i];
    }
    return max;


}
public static int TableauPositif(int tab[]) {

    int taille = TailleNegatif(tab);

    if(tab[taille] ==0)
        taille+=1;


    int taillepositif = TaillePositif(tab);

    int tabPositif[] = new int[taillepositif];



    for(int i = 0; i < tabPositif.length; i++) {


        tabPositif[i] = tab[i + taille];

    }
    int min = tabPositif[0];
    for(int i = 0; i< tabPositif.length; i++) {

        if(min > tabPositif[i])
            min = tabPositif[i];
    }
    return min;


}

public static int TailleNegatif(int tab[]) {
    int cpt = 0;

    for(int i = 0; i < tab.length; i++) {

        if(tab[i] < 0) {
            cpt +=1;

        }
    }
    return cpt;

}
public static int TaillePositif(int tab[]) {
    int cpt = 0;

    for(int i = 0; i < tab.length; i++) {

        if(tab[i] > 0) {
            cpt +=1;

        }
    }
    return cpt;

}

public static int distanceDeZero(int v1, int v2) {

    int absv1 = v1 * (-1);

    if(absv1 < v2)
        return v1;

    else if(absv1 > v2)
        return v2;
    else 
        return v2;



}

public static void main(String[] args) {

    int t[] = {6,5,8,8,-2,-5,0,-3,-5,9,7,4};

    Solution.trier(t);


}

  static int Solve(int N, int[] A){
      List<Integer> mInt=new ArrayList<>();
        for ( int i=0; i < A.length; i++ ){
            mInt.add(Math.abs(0 -A[i]));
        }
        return Collections.min(mInt);
    }

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

N = int(input())

arr = list(map(int, input().split()))

arr.append(0)
arr.sort()

zeroIndex = arr.index(0)
print(arr[zeroIndex + 1])

 static int Solve(int N, int[] A){
      int min = A[0];
      for (int i=1; i<N ; i++){
        min = min > Math.abs(0- A[i]) ? Math.abs(0- A[i]) : Math.abs(min);
      }
      return min;
    }

public class CloseToZero {
    public static void main(String[] args) {
        int[] data = {2,3,-2,-1,1};
        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) && !((curr - (near * near) == 0) && data[i] < 0))  {
                    near = data[i];
            }
        }
        System.out.println( near );
    }
}

public static int find(int[] ints) {
    if (ints==null) return 0;
    int min= ints[0];   //a random value initialisation 
    for (int k=0;k<ints.length;k++) {
        // if a positive value is matched it is prioritized              
        if (ints[k]==Math.abs(min) || Math.abs(ints[k])<Math.abs(min)) 
            min=ints[k];            
    }
    return  min;
}

public int check() {

    int target = 0;
    int[] myArray = { 40, 20, 100, 30, -1, 70, -10, 500 };
    int result = myArray[0];
    for (int i = 0; i < myArray.length; i++) {
        if (myArray[i] == target) {
            result = myArray[i];
            return result;
        }
        if (myArray[i] > 0 && result >= (myArray[i] - target)) {
            result = myArray[i];
        }
    }
    return result;
}

public class ClosesttoZero {
    
      static int closZero(int[] ints) {
        
        int result=ints[0];
        for(int i=1;i<ints.length;i++) {
            if(Math.abs(result)>=Math.abs(ints[i])) {
                result=Math.abs(ints[i]);
            }
        }
        return result;
        
        
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        
        int[] ints= {1,1,5,8,4,-9,0,6,7,1};
        int result=ClosesttoZero.closZero(ints);
        System.out.println(result);
        
        
    }

}

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

        for (int i = 0; i < arr.length; ++i)
        {
            arr[i] = Math.abs(arr[i]);
        }

        Arrays.sort(arr);
        System.out.println("Closest value to 0 = " + arr[0]);