C# 检查数组元素是否连续且没有顺序

我有以下代码：

int[] arr = { 1, 2, 3, 4 };
int n = arr.Length;
bool result = areConsecutives(arr, n);
if (result == true)
    MessageBox.Show("Yes");
else
    MessageBox.Show("No"); 

static bool areConsecutives(int[] arr, int n)
{
    int first_term = int.MaxValue;

    for (int j = 0; j < n; j++)
    {
        if (arr[j] < first_term)
            first_term = arr[j];
    }

    int ap_sum = (n * (2 * first_term + (n - 1) * 1)) / 2;

    int arr_sum = 0;
    for (int i = 0; i < n; i++)
        arr_sum += arr[i];

    return ap_sum == arr_sum;
} 

问题是如何检查数组元素是否连续，例如是否有以下数组：

int[] arr = { 4, 8, 12, 16 }

它们是连续的/乘以4的倍数，阵列也可以采用以下方式：

int[] arr = { 16, 4, 8, 12 }

这里有一个方法：

var vals = new[] { 125, 25, 50, 75, 100 };
Array.Sort(vals);
bool arithmetic = vals.Zip(vals.Skip(1), (x, y) => y - x).Distinct().Count() == 1;

我们首先对数组进行排序。然后我们取每一对元素（取25和50，然后取50和75，等等），找出它们之间的差异。然后我们计算我们发现的不同差异的数量，看看是否是1：如果是，我们的元素是均匀分布的

---

还有一个：

var vals = new[] { 125, 50, 75, 100 };
Array.Sort(vals);
bool areArithmetic = true;
if (vals.Length > 1)
{
    int difference = vals[1] - vals[0]; 
    for (int i = 2; i < vals.Length; i++)
    {
        if (vals[i] != vals[0] + i * difference)
        {
            areArithmetic = false;
            break;
        }
    }
}

var-vals=new[]{125,50,75,100}；
数组.排序（VAL）；
布尔面积算术=真；
如果（vals.Length>1）
{
整数差=VAL[1]-VAL[0]；
对于（int i=2；i

---

在这里，我们再次对列表进行排序，然后循环遍历已排序的列表。我们找出前两个元素之间的差异，然后检查每个后续元素是否都是该差异的适当倍数。

我会这样做：确定需要哪些值，然后检查

arr

是否包含这些值

var min = arr.Min(); // This is also the expected "gap" between elements
var max = min * arr.Length;
var isOK = min > 0;
for (var i = min; i <= max && isOK; i += min)
{
    if (!arr.Contains(i))
        isOK = false;
}
Console.WriteLine(isOK ? "Consecutive" : "Not consecutive");

---

工作演示：

一个可能的解决方案，使用

数组。对
循环进行排序
和简单
，而不使用
系统。Linq

int[]arr={16,4,8,12}；
Array.Sort（arr）；
布尔结果=真；
对于（int i=1；i
如果你不是在寻找算术级数，只是想知道数字是否连续增长，那么你可以这样做。只需检查上一个值是否大于当前值

var isConsecutive = true;
var numbers = new[] { 1.3, -1, 0, 1.5 };
for (int i = 1; i < numbers.Length; i++)
{
    if (numbers[i - 1] > numbers[i])
    {
        isConsecutive = false;
        break;
    }
}

var isConsecutive=true；
变量数=新[]{1.3，-1,0,1.5}；
for（int i=1；i数字[i]）
{
isconsecuritive=false；
打破
}
}
你所说的“连续”到底是什么意思？数组中的每个元素都是另一个元素加上一个常数（最低的元素除外）？@canton7是连续的/倍数，我的意思是，例如1，2，3，它们是连续的1。3，6，9，12，它们是3或75，125，150，50，它们是25，等等，“连续”是否意味着“我们可以重新排序项目，使我们有一个算术级数”，例如，
3，5，11，9，7
可以放为
3，5，7，9，11
？或者（更严格地说）“连续”是指所有项目都可以表示为
const*k
，其中
k=1，2，…，n
？通过“连续”您是指元素在排序时是均匀分布的吗？@DmitryBychenko是，这样做的一种方法可能是将数组元素从最小值和最大值排序，然后检查它们是否是前两项差值的连续/倍数，在您的示例中，连续/倍数为2。这似乎很好，但如果使用负数或十进制数，我不确定这是否有效。例如int[]array={1.3，-1,0.1.5}。
{1.3，-1,0,1.5}
不是算术级数。。。它应该可以处理负数，但浮动是一个棘手的野兽，它将采取任何方法hard@User1899289003如果这真的是答案，你的问题表达得很糟糕…你最好使用哈希集，或者linq的，除了-，这将把这个从二次型转换成线性型，所以请注意，序列可能不必从它的最低值开始，这是您的代码所必需的assumes@canton7HashSet确实可以用作优化，但这样做不会以任何方式改变逻辑（算法）。关于您的第二条评论：不正确，如果您尝试演示，您将看到它们使用并适用于任何顺序的元素。可能我不清楚：我不是在谈论元素的顺序，我是在谈论例如
[4,6,8]
（这里的序列不是从
2
开始）。不过，您在编辑中通过不假设间距与最小元素相同，解决了这一问题。
var min = arr.Min();
var gap = arr.Where(x => x > min).Min() - min;
var max = min + gap * (arr.Length - 1);
var isOK = gap > 0;
for (var i = min; i <= max && isOK; i += gap)
{
    if (!arr.Contains(i))
        isOK = false;
}
Console.WriteLine(isOK ? "Consecutive" : "Not consecutive");

var isConsecutive = true;
var numbers = new[] { 1.3, -1, 0, 1.5 };
for (int i = 1; i < numbers.Length; i++)
{
    if (numbers[i - 1] > numbers[i])
    {
        isConsecutive = false;
        break;
    }
}