得到最接近的值在阵列

Question

一些我的正/负整数

int[] numbers = new int[10]; 
numbers[0] = 100; 
numbers[1] = -34200; 
numbers[2] = 3040; 
numbers[3] = 400433; 
numbers[4] = 500; 
numbers[5] = -100; 
numbers[6] = -200; 
numbers[7] = 532; 
numbers[8] = 6584; 
numbers[9] = -945; 

数组现在，我想测试的此阵另一int和返回最接近的int数。

例如，如果我使用号码490，我会从号码500中收回项目＃4，做这种事情的最佳方法是什么？

int myNumber = 490; 
int distance = 0; 
int idx = 0; 
for(int c = 0; c < numbers.length; c++){ 
    int cdistance = numbers[c] - myNumber; 
    if(cdistance < distance){ 
     idx = c; 
     distance = cdistance; 
    } 
} 
int theNumber = numbers[idx]; 

这是行不通的。任何建议一个好的方法来做到这一点？

Answer 1

int myNumber = 490; 
int distance = Math.abs(numbers[0] - myNumber); 
int idx = 0; 
for(int c = 1; c < numbers.length; c++){ 
    int cdistance = Math.abs(numbers[c] - myNumber); 
    if(cdistance < distance){ 
     idx = c; 
     distance = cdistance; 
    } 
} 
int theNumber = numbers[idx]; 

始终使用您考虑的第一个元素初始化您的最小/最大功能。使用诸如Integer.MAX_VALUE或Integer.MIN_VALUE之类的东西是获得答案的天真方式;如果稍后更改数据类型（哎呀，MAX_LONG和MAX_INT非常不同！），或者如果您未来希望为任何数据类型编写通用min/max方法，

Answer 2

你非常接近。我认为'距离'的初始值应该是一个很大的数字，而不是0.并使用cdistance的绝对值。

Answer 3

cdistance = numbers[c] - myNumber。你没有拿出差异的绝对值。如果myNumber比numbers[c]大很多，或者numbers[c]为负数，则比较将记录为“最小差异”。

以numbers[c] = -34200为例。 numbers[c] - myNumber然后将是-34690，远低于distance。

此外，您应该初始化distance到一个很大的值，因为在开始时没有找到解决方案。

Answer 4

这里的东西，我没有...

import javax.swing.JOptionPane; 

public class NearestNumber { 

public static void main(String[] arg) 
{ 
    int[] array={100,-3420,3040,400433,500,-100,-200,532,6584,-945}; 

    String myNumberString =JOptionPane.showInputDialog(null,"Enter the number to test:"); 
    int myNumber = Integer.parseInt(myNumberString); 

    int nearestNumber = findNearestNumber(array,myNumber); 

    JOptionPane.showMessageDialog(null,"The nearest number is "+nearestNumber); 
} 

public static int findNearestNumber(int[] array,int myNumber) 
{ 

    int min=0,max=0,nearestNumber; 

    for(int i=0;i<array.length;i++) 
    { 
     if(array[i]<myNumber) 
     { 
      if(min==0) 
      { 
       min=array[i]; 
      } 
      else if(array[i]>min) 
      { 
       min=array[i]; 
      } 
     } 
     else if(array[i]>myNumber) 
     { 
      if(max==0) 
      { 
       max=array[i]; 
      } 
      else if(array[i]<max) 
      { 
       max=array[i]; 
      } 
     } 
     else 
     { 
      return array[i]; 
     } 
    } 

    if(Math.abs(myNumber-min)<Math.abs(myNumber-max)) 
    { 
     nearestNumber=min; 
    } 
    else 
    { 
     nearestNumber=max; 
    } 

    return nearestNumber; 
} 

}

Answer 5

我这样做是为我的课程分配，我编程，它在准备程序的Java，很抱歉，如果它是一个有点混乱。

// The "Ass_1_B_3" class. 
import java.awt.*; 
import hsa.Console; 

public class Ass_1_B_3 
{ 
    static Console c;   // The output console 

    public static void main (String[] args) 
    { 
     c = new Console(); 

     int [] data = {3, 1, 5, 7, 4, 12, -3, 8, -2}; 
     int nearZero = 0; 
     int temp = 0; 
     int temp2 = data[0]; 

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


     } 

     c.println ("The number closest to zero is: " + nearZero); 

     // Place your program here. 'c' is the output console 
    } // main method 
} // Ass_1_B_3 class 

Answer 6

public int nearnum(int myNumber,int[] numbers) 
    { 
     int distance = Math.abs(numbers[0] - myNumber); 
     int idx = 0; 
     for(int c = 1; c < numbers.length; c++){ 
      int cdistance = Math.abs(numbers[c] - myNumber); 
      if(cdistance < distance){ 
       idx = c; 
       distance = cdistance; 
      } 
     } 
     return numbers[idx]; 
    } 

Answer 7

一个语句块初始化和设置最接近的匹配。另外，如果找不到最接近的匹配，则返回-1（空数组）。

protected int getClosestIndex(final int[] values, int value) { 
    class Closest { 
     Integer dif; 
     int index = -1; 
    }; 
    Closest closest = new Closest(); 
    for (int i = 0; i < values.length; ++i) { 
     final int dif = Math.abs(value - values[i]); 
     if (closest.dif == null || dif < closest.dif) { 
      closest.index = i; 
      closest.dif = dif; 
     } 
    } 
    return closest.index; 
} 

Answer 8

public int getClosestToTarget(int target, int[] values) { 

    if (values.length < 1) 
     throw new IllegalArgumentException("The values should be at least one element"); 
    if (values.length == 1) { 
     return values[0]; 
    } 
    int closestValue = values[0]; 
    int leastDistance = Math.abs(values[0] - target); 
    for (int i = 0; i < values.length; i++) { 
     int currentDistance = Math.abs(values[i] - target); 
     if (currentDistance < leastDistance) { 
      closestValue = values[i]; 
      leastDistance = currentDistance; 
     } 
    } 
    return closestValue; 
} 

Answer 9

与Java 8个流API：

List<Integer> list = Arrays.stream(numbers).boxed().collect(Collectors.toList()); 
int n = 490; 
int closestToN = list.stream().min(Comparator.comparingInt(i -> Math.abs(i - n))).get(); 

本来，你可能想使用一个列表，而不是阵列的，因此你可以在操作额外的灵活性与它的元素。

Answer 10

public class Main  
{ 
    public static void main(String[] args) 
    { 
     int[] numbers = {6,5,10,1,3,4,2,14,11,12}; 

     for(int i =0; i<numbers.length; i++) 
     { 
      sum(numbers, i, numbers[i], 12, String.valueOf(numbers[i])); 
     } 
    } 

    static void sum(int[] arr, int i, int sum, int target, String s) 
    { 

     int flag = 0; 

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

      if(arr[i] == target && flag==0) 
      { 
       System.out.println(String.valueOf(arr[i])); 
       flag =1; 

      } 
      else if(sum+arr[j] == target) 
      { 
       System.out.println(s+" "+String.valueOf(arr[j])); 

      } 
      else 
      { 
       sum(arr, j, sum+arr[j], target, s+" "+String.valueOf(arr[j])); 
      } 
     }   
    } 
}