функция возвращает ближайший элемент массива в целое число

Question

Я хочу сделать функцию, которая дает массив, возвращает ближайший элемент к числу.

вот несколько примеров:

int[] arr = new int[] {12, 48, 50, 100};
my_function(1, arr); // returns 12.
my_function(40, arr); // returns 48.
my_function(49, arr); // returns 50; in two element with equal distance, returns greater number
my_function(70, arr); // returns 50.
my_function(10005, arr); // returns 100.

Извините, я понятия не имею, как написать эту функцию.

Answer 1

private int GetNearest(int[] array,int number)
{
    return array.OrderBy(x => Math.Abs((long)x - number)).FirstOrDefault();
}

, если вы хотите, чтобы большее число было перед меньшим числом, когда абсолютная разница такая же, добавьте .ThenByDescending(a => a) после OrderBy(x => Math.Abs((long)x - number))

private int GetNearest(int[] array,int number)
{
    return array.OrderBy(x => Math.Abs((long)x - number)).ThenByDescending(a => a).FirstOrDefault();
}

Answer 2

Другой способ получить ожидаемый результат - вычислить расстояние между переданным значением и элементами массива. Затем получите элемент с наименьшим «расстоянием» и найдите соответствующий индекс во входном массиве. Вам также нужен Linq.

int Nearest(int value, int[] arr)
{
    var distances = arr.Select(x => Math.Abs(x - value)).ToList();
    int min = distances.Min();

    // Using LastIndexOf is important 
    // if you get two equal distances (I.E. 48/50 and passing 49)
    return arr[distances.LastIndexOf(min)];
}

Answer 3

Это работает:

public static int my_function(int num, int[] arr)
{
    var minDiff = Math.Abs(arr[0] - num);
    var nearest = arr[0];
    for (int i = 1; i < arr.Length; i++)
    {
        var diff = Math.Abs(arr[i] - num);
        if (diff <= minDiff)
        {
            minDiff = diff;
            nearest = arr[i];
        }
    }

    return nearest;
}

Answer 4

Это решение без использования System.Linq и сложности O(n). Вы просто go просматриваете массив в l oop и находите число с минимальной разницей, условие abs <= diff позволяет вам возвращать самое последнее число (50 для 49 вместо 48) в отсортированном массиве. Если разница равна 0, это означает, что вы найдете точное число

var arr = new[] { 12, 48, 50, 100 };

int nearest = GetNearest(1, arr);
nearest = GetNearest(40, arr);
nearest = GetNearest(49, arr);
nearest = GetNearest(70, arr);
nearest = GetNearest(1005, arr);

int GetNearest(int number, int[] array)
{
    int diff = int.MaxValue;
    int result = 0;
    foreach (var item in array)
    {
        var abs = Math.Abs(item - number);
        if (abs == 0)
        {
            result = item;
            break;
        }

        if (abs <= diff)
        {
            diff = abs;
            result = item;
        }
    }

    return result;
}

Answer 5

Я подошел к этому так.

private static int nearest(int number, int[] numbers)
{
   int min = numbers[0];
   int max = numbers.OrderByDescending(a => a).FirstOrDefault();

   if (number> max)
   {
       return max;
   }

    for (int i = 0; i < numbers.Length; i++)
    {

    if (numbers[i]<number && numbers[i+1]>number)
    {
       int lower = Math.Abs(numbers[i])-Math.Abs(number);
       int upper = Math.Abs(numbers[i+1]) - Math.Abs(number);

       if (Math.Abs(upper)>Math.Abs(lower))
       {
         return numbers[i];
       }
       else
       {
         return numbers[i+1];
        }

     }
    }

return min;

}

Answer 6

Если вы знаете, что массив отсортирован, то вы можете найти ближайшее значение, подобное этому, за время O (log n).

public int GetNearest(int value, int[] sortedArray)
{
    var index = Array.BinarySearch(sortedArray, value);

    // If we found a match then the closest is equal to the value.
    if(index >= 0) return value;

    // Otherwise it's the bitwise compliment to the index of the value just larger.
    var largerIndex = ~index;

    // If the index is the length of the array then all numbers are smaller, 
    //so take the last.
    if(largerIndex == sortedArray.Length) return sortedArray[arr.Length - 1];

    // If the index is 0 then all numbers are greater so take the first.
    if(largerIndex == 0) return sortedArray[0];

    // Now get the number that is just larger and just smaller and calculate the 
    // difference to each.
    var larger = sortedArray[largerIndex];
    var smaller = sortedArray[largerIndex - 1];
    var largerDiff = larger - value;
    var smallerDiff = value - smaller;

    // If the diff to the smaller number is less then we take the smaller number  
    // otherwise the larger number is closer or the difference is the same in which
    // case we take the larger number.
    return smallerDiff < largerDiff ? smaller : larger;
}