C# 数组中最接近x的数字的索引，不能大于x

如何编写一个函数来接受整数数组和整数x，并返回数组中最接近x参数的整数的索引而不大于x。如果所有值都高于x，则函数将返回负1。假设两个或多个数字在数组中不能相同。

假设这些数字是唯一的，您可以使用

public static int GetClosestIndex(int[] arr, int value)
{
    var result = arr.Where(x => x < value).OrderByDescending(x => x);
    return result.Any() ? Array.IndexOf(arr, result.FirstOrDefault()) : -1;
}

公共静态int GetClosestIndex（int[]arr，int-value）
{
var result=arr.Where（x=>xx）；
返回result.Any（）？Array.IndexOf（arr，result.FirstOrDefault（））：-1；
}

更新：（适用于Zastai）

这里有一个性能更好的方法

public static int GetClosestIndex(int[] arr, int value)
{
    int result = -1;
    for (int i = 0; i < arr.Length; i++)
    {
        if (arr[i] < value)
        {
            if (result == -1 || arr[i] > arr[result])
            {
                result = i;
            }
        }
    }
    return result;
}

公共静态int GetClosestIndex（int[]arr，int-value）
{
int结果=-1；
对于（int i=0；iarr[result]）
{
结果=i；
}
}
}
返回结果；
}

假设数字是唯一的，您可以使用

public static int GetClosestIndex(int[] arr, int value)
{
    var result = arr.Where(x => x < value).OrderByDescending(x => x);
    return result.Any() ? Array.IndexOf(arr, result.FirstOrDefault()) : -1;
}

公共静态int GetClosestIndex（int[]arr，int-value）
{
var result=arr.Where（x=>xx）；
返回result.Any（）？Array.IndexOf（arr，result.FirstOrDefault（））：-1；
}

更新：（适用于Zastai）

这里有一个性能更好的方法

public static int GetClosestIndex(int[] arr, int value)
{
    int result = -1;
    for (int i = 0; i < arr.Length; i++)
    {
        if (arr[i] < value)
        {
            if (result == -1 || arr[i] > arr[result])
            {
                result = i;
            }
        }
    }
    return result;
}

公共静态int GetClosestIndex（int[]arr，int-value）
{
int结果=-1；
对于（int i=0；iarr[result]）
{
结果=i；
}
}
}
返回结果；
}

我同意

public static class StackOverflow {

public static int IndexOfValueClosestTo<T>(this IList<T> list, T x) where T : IComparable<T> {
  var closestValue = default(T);
  var closestIndex = -1;
  var idx = -1;
  foreach (var v in list) {
    ++idx;
    if (v.CompareTo(x) < 0 && (closestIndex == -1 || closestValue.CompareTo(v) < 0)) {
      closestIndex = idx;
      closestValue = v;
    }
  }
  return closestIndex;
}

}

这将在大约0.33秒内运行100次迭代，因此速度大约是上述通用版本的3倍。请注意，您可以将两者都定义为重载，因此您仍然有一个有效的实现，例如，一个double列表。

我同意

public static class StackOverflow {

public static int IndexOfValueClosestTo<T>(this IList<T> list, T x) where T : IComparable<T> {
  var closestValue = default(T);
  var closestIndex = -1;
  var idx = -1;
  foreach (var v in list) {
    ++idx;
    if (v.CompareTo(x) < 0 && (closestIndex == -1 || closestValue.CompareTo(v) < 0)) {
      closestIndex = idx;
      closestValue = v;
    }
  }
  return closestIndex;
}

}

---

这将在大约0.33秒内运行100次迭代，因此速度大约是上述通用版本的3倍。请注意，您可以将这两种方法都定义为重载，因此您仍然有一个有效的实现，例如，一个double列表。

如果有多个结果怎么办？不会有多个解决方案。它说返回最近的一个，并假设数组中没有重复项。不会有重复项。数组中的所有数字在函数的性能关键性方面是不同的。我可能只是对它进行排序，然后进行二进制搜索。但我会远离linq——以我的经验，它的性能非常糟糕。如果有多个结果呢？不会有多个解决方案。它说返回最近的一个，并假设数组中没有重复项。不会有重复项。数组中的所有数字在函数的性能关键性方面是不同的。我可能只是对它进行排序，然后进行二进制搜索。但我会远离linq——以我的经验来看，它的性能非常糟糕。虽然在代码中功能正确且相当优雅，但这几乎肯定会表现得非常糟糕。虽然在代码中功能正确且相当优雅，但这几乎肯定会表现得非常糟糕。