C# 找到其值减去前一个索引值小于给定x的最小索引的最有效方法？

我有五个长整数p，q，s，m和x。数组编号[]由以下公式创建

numbers[0] = s;
for(int i=1; i<numbers.Length;i++){
    numbers[i] = (p * numbers[i-1] + q) % m;
}

number[0]=s；
对于（inti=1；i为i
您可以做两个嵌套循环，外部循环的范围从j=1到numbers.Length-1（允许可能的解是最小的j）到i=0到i
然后根据规格比较两个位置。如果为真，则返回j。如果它完成了两个循环，则没有解决方案

编辑：代码示例

public int GetSmallestIndex(long[] numbers, long x, long m)
{
    if (numbers.Length >= 2)
    {
        for (int j = 1; j < numbers.Length; j++)
        {
            for (int i = 0; i < j; i++)
            {
                long diff = Math.Abs(numbers[j] - numbers[i]); 
                if (diff <= x || diff >= m - x)
                    return j;
            }
        }
    }

    return -1; //If no solution is found, return -1 as convention
}

public int GetSmallestIndex（长[]个数字，长x，长m）
{
如果（number.Length>=2）
{
对于（int j=1；j
确定某项功能是否更有效的唯一方法是使用
System.Diagnostics
中的
秒表对其进行基准测试

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;

namespace ConsoleApplication1
{
    class Program
    {
        public static void Main()
        {
            var stopWatch = new Stopwatch();
            stopWatch.Start();
            const long x = 1;
            var numbers = new long[] {3, 7, 1, 29};
            var theSmallestIndex = SmallestIndex(x, numbers);
            stopWatch.Stop();
            Console.WriteLine("Elapsed Time: {0}", stopWatch.Elapsed);
            Console.WriteLine("Smallest Index: {0}", theSmallestIndex);
            Console.ReadKey();
        }

        public static long SmallestIndex(long x, long[] numbers)
        {
            var values = ValuesMinusTheValueOfPreviousIndex(x, numbers.ToList());
            var smallest = values.Values.OrderBy(n => n).FirstOrDefault();
            var result = values.Where(n => n.Value.Equals(smallest));
            return result.FirstOrDefault().Key;
        }

        public static Dictionary<int, long> ValuesMinusTheValueOfPreviousIndex(long x, List<long> numbers)
        {
            var results = new Dictionary<int, long>();
            foreach (var number in numbers)
            {
                var index = numbers.IndexOf(number);
                var previousNumber = index > 0 ? numbers.ElementAt(index - 1) : 0;
                var result = number - previousNumber;
                results.Add(index, result);
            }

            return results;
        }
    }
}

使用系统；
使用System.Collections.Generic；
使用系统诊断；
使用System.Linq；
命名空间控制台应用程序1
{
班级计划
{
公共静态void Main（）
{
var stopWatch=新秒表（）；
秒表。开始（）；
常数长x=1；
var数=新长[]{3,7,1,29}；
var theSmallestIndex=最小索引（x，数字）；
秒表；
WriteLine（“运行时间：{0}”，stopWatch.appeased）；
WriteLine（“最小索引：{0}”，最小索引）；
Console.ReadKey（）；
}
公共静态长SmallestIndex（长x，长[]个数字）
{
var values=值使用前一个索引的值（x，numbers.ToList（））；
var minimate=values.values.OrderBy（n=>n.FirstOrDefault（）；
var结果=值，其中（n=>n.Value.Equals（最小））；
返回result.FirstOrDefault（）.Key；
}
公共静态字典值使用前一索引的值（长x，列表编号）
{
var results=newdictionary（）；
foreach（数值中的变量编号）
{
var指数=数字。IndexOf（数字）；
var previousNumber=指数>0？数字。元素（指数-1）：0；
var结果=编号-以前的编号；
结果。添加（索引、结果）；
}
返回结果；
}
}
}
编辑：根据您在评论中的要求添加了Math.Abs

        long p = 3, q = 7, s = 1, m = 29, x = 1;
        long[] numbers = new long[10];

        numbers[0] = s;
        for (int i = 1; i < numbers.Length; i++)
        {
            numbers[i] = (p * numbers[i - 1] + q) % m;
        }

        // Find the smallest index j in numbers, where i < j && 
        //    (numbers[j] - numbers[i] <= x    ||     numbers[j] - numbers[i] >= m-x)
        int smallestIndex = 0;
        long comparison;
        for (int j = 1; j < numbers.Length; j++)
        {
            for (int i = 0; i < j; i++)
            {
                comparison = Math.Abs(numbers[j] - numbers[i]);
                if (comparison <= x || comparison >= m - x)
                {
                    smallestIndex = j;
                    break;
                }
            }
            if (smallestIndex != 0) break;
        }

        if (smallestIndex == 0)
        {
            // No result matches the conditions
        }
        else
        {
            // j is the smallest index matching the conditions
            // Before using Abs, in the example j is 2, because 8 - 10 = -2, lesser than x
            // Now using absolute values, In the example j is 3
        }

长p=3，q=7，s=1，m=29，x=1；
长[]个数=新长[10]；
数字[0]=s；
for（int i=1；i
谢谢Gabriel！你认为这对长数字足够有效吗？是的，比较量最少的大数组和长整数在我的回答中还有一个更正：比较的值必须是绝对值，所以数字[j]-numbers[i]应该是| numbers[j]-numbers[i]|长整数在计算比较上没有区别。对于长数组，这是一个最坏情况复杂性O（n^2）的问题，如中所示，您必须在两个数组上进行迭代。因此，是的，我认为这是非常有效的。虽然需要比n^2更快的速度，但更正程序会给我运行时异常。我的回答中还有一个更正：比较的值必须是绝对值，所以数字[j]-numbers[I]应该是| numbers[j]-numbers[I]|