C# 将整数舍入到数组中最近的高位_C#_Arrays

C# 将整数舍入到数组中最近的高位

c# arrays

C# 将整数舍入到数组中最近的高位,c#,arrays,C#,Arrays,我有这样一个整数数组：[32128102420484096] 给定一个特定的值，我需要得到数组中最接近的值，该值等于或大于该值我有以下代码 private int GetNextValidSize(int size, int[] validSizes) { int returnValue = size; for (int i = 0; i < validSizes.Length; i++) { if (validSize

我有这样一个整数数组：[32128102420484096]

给定一个特定的值，我需要得到数组中最接近的值，该值等于或大于该值

我有以下代码

  private int GetNextValidSize(int size, int[] validSizes)
  {

      int returnValue = size;

      for (int i = 0; i < validSizes.Length; i++)
      {
          if (validSizes[i] >= size)
          {
              returnValue = validSizes[i];
              break;
          }
      }

      return returnValue;
  }

private int GetNextValidSize（int size，int[]validSize）
{
返回值=大小；
for（int i=0；i=大小）
{
returnValue=有效化[i]；
打破
}
}
返回值；
}

这是可行的，但是有更好/更快的方法吗？数组包含的元素永远不会超过5-10个

澄清：如果原始值/大小大于任何有效大小，我实际上希望返回原始值/大小。validSizes数组可以被视为总是被排序的，并且它总是至少包含一个值。

如果您的数组被排序，您可以使用二进制搜索算法来加快排序速度

请参见此处：

如果您的数组已排序，则可以使用二进制搜索算法加快排序速度

鉴于你只有5-10个元素，我认为这是可以的。

< P>鉴于你只有5-10个元素，我认为这是可以的。

< P>只有5-10个元素，绝对可以用最简单的方法。让二进制切分正常工作将有助于更大的数组，但它至少有可能出现一对一的错误

但是，我不会中断，而是直接从循环返回，使其更加简单，并使用foreach：

  private int GetNextValidSize(int size, int[] validSizes)
  {    
      int returnValue = size;

      foreach (int validSize in validSizes)
      {
          if (validSize >= size)
          {
              return validSizes;
          }
      }

      // Nothing valid    
      return size;
  }

使用LINQ，您可以使这一点更加简单：

// Make sure we return "size" if none of the valid sizes are greater
return validSizes.Concat(new[] { size })
                 .First(validSize => validSize >= size);

如果没有

Concat

步骤，它会更简单。。。或者如果有一个

Concat

方法只需要一个元素。诚然，这很容易写：

public static IEnumerable<T> Concat(this IEnumerable<T> source,
                                    T tail)
{
    foreach (T element in source)
    {
        yield return element;
    }
    yield return tail;
}

或者（我意识到我提供的选项比这里真正需要的多得多！）使用默认值返回的

FirstOrDefault

重载：

public static T FirstOrDefault(this IEnumerable<T> source,
                               Func<T, bool> predicate,
                               T defaultValue)
{
    foreach (T element in source)
    {
        if (predicate(element))
        {
            return element;
        }
    }
    return defaultValue;
}

这两种方法对于单次使用来说都是多余的，但是如果您已经建立了一个额外的LINQ操作符库，那么它可能会很有用。

只有5-10个元素，一定要使用最简单的解决方案。让二进制切分正常工作将有助于更大的数组，但它至少有可能出现一对一的错误

int[] validSizes = new int[] { 32, 128, 1024, 2048, 4096 };

int sizeICareAbout = 4096;

Console.Write(validSizes.Max(i => i < sizeICareAbout ? i : Int32.MinValue));