正在检查数组中的直序列

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ArrayChecker
{
    class Program
    {
        /// The program's main entry point.
        static void Main(string[] args)
        {
            // Input arrays are assumed to be in non-decreasing order.
            int[] myArr1 = new int[] { 1, 1, 2, 3, 3 };
            int[] myArr2 = new int[] { 1, 1, 3 };
            int[] myArr3 = new int[] { 1, 1, 1, 2, 3, 4, 5, 6, 1 };
            // Printing to console True & False respectively.
            Console.WriteLine( Seq_Check(myArr1, 3) );
            Console.WriteLine( Seq_Check(myArr2, 2) );
            Console.WriteLine( Seq_Check(myArr3, 6) );
            // Prevent the console window from closing.
            Console.ReadLine();
        }

        /// This method checks whether array A contains numbers 1,2,...,k
        /// (every number from 1 to k exactly once) and no other numbers.
        public static bool Seq_Check(int[] A, int k)
        {
            int n = A.Length;
            for (int i = 0; i < n-1; i++)
            {
                if ( A[i]+1 < A[i+1] )
                    return false;
            }
            if ( A[0] != 1 && A[n-1] != k )
                return false;
            else
                return true;
        }
    }
}

试试这个。

        public static bool Seq_Check(int[] A, int k)
        {
            int n = A.Length;
            if (A[0] != 1 || A[n - 1] != k)//no need to go through array if it is already bad
                return false;
            for (int i = 0; i < n - 1; i++)
            {
                if (A[i] + 1 < A[i + 1])
                    return false;
            }
            return true;
        }

您正在使用&amp；而不是在检查A[0]是否为1并且A[n-1]是否为k时||。这意味着，只要其中一个条件为true，函数就会返回true。如果其中一个条件为true，则函数应返回false。

如果使用Linq，则可以使用Range（）、Distinct（）和Exclude（）来完成任务。。。让林替你做这项工作。

for循环中的主检查需要更改：

if (A[i] + 1 < A[i+1] )
    return false;

首先，你需要检查订单，所以你需要检查索引更高的元素是否比前一个更大：

if (A[i] >= A[i+1])
    return false;

由于您不介意元素在系列的开头或结尾是相等的，因此需要添加另一个检查以避免在这些情况下返回false：

bool inSequence = A[i] != 1 || A[i] == k;
if (A[i] > A[i+1] || (A[i] == A[i+1] && inSequence))
  return false;

在这里，我们检查我们开始/结束的系列是否通过了重复项，如果我们仍在序列中，则不允许重复项，因此A[i+1]==A[i]应返回false。

public static bool Seq_Check(int[] A, int k)
{
    int n = A.Length;
    for (int i = 0; i < n - 1; i++)
    {
        bool inSequence = A[i] != 1 || A[i] == k;
        if (A[i] > A[i+1] || (A[i] == A[i+1] && inSequence))
            return false;
        }
    }
    if ( A[0] != 1 && A[n-1] != k )
        return false;
    else
        return true;     
 }

它为第三个数组返回true的原因是因为A[0] != 1 && A[n-1] != k是false。

我要把它打散。

A[0]！=1我们称之为X

数组中的第一个位置实际上是1，因此返回true。

A[n-1]！=k我们称之为Y

最后一位不是6，所以返回false。

埃尔戈，X && Y就是false。

应该是A[0] != 1 || A[n-1] != k吗？？

据我所知，您想看看是否存在从1到K的连续范围，重复的数字无关紧要，除非数字位于该范围的中间。

因此，对于[ 1, 1, 1, 2, 3, 4, 4, 5, 6, 1]，K为[2,3,4]的情况会通过，但[5, 6]会失败，因为重复4会破坏连续范围的链。

为此，我将向后开始并查找K的实例，从那里开始向后计数，如果我能够到达1，则返回true

public bool Seq_Check(int[] elems, int k)
{
    for(int i=elems.Length;i>0;i--)
    {
       //we found the first element we are looking for
       //so need to start looking for the rest of the sequence
       if(elems[i]==k)
       {
            // don't create a new index, we can reuse i
            int curr = k-1;
            for(;i>0 && curr>0;i--)
            {
                if(elems[i]!=curr) 
                {
                     if(elems[i]==k)
                     {
                         //reinitialize if we found K again
                         curr=k-1;
                         continue;
                     }
                     break;
                }
                curr--;
            }
            // if the curr value is 0 then 
            // we found all the elements
            if(curr == 0)
            {
                return true;
            }
       }
    }
    //no matching sequence was found so return false
    return false;
}

这段代码给我的结果与您的相同。第三个数组是[1，1，1，2，3，4，5，6，1]，排序后的版本是[1,1,1,2,3,4,5,6]。它实际上包含了[1,6]范围内的所有数字。怎么了？：

namespace SequenceCheck
{
    using System;
    public class Program
    {
        public static void Main()
        {
            int[] myArr1 = new int[] { 1, 1, 2, 3, 3};
            int[] myArr2 = new int[] { 1, 1, 3 };
            int[] myArr3 = new int[] { 1, 1, 1, 2, 3, 4, 5, 6, 1 };
            // Printing to console True & False respectively.
            Console.WriteLine(Seq_Check(myArr1, 3));
            Console.WriteLine(Seq_Check(myArr2, 2));
            Console.WriteLine(Seq_Check(myArr3, 6));
        }
        public static bool Seq_Check(int[] A, int k)
        {
            // TODO Check for corner cases!
            // Let's at first sort the numbers
            Array.Sort(A);
            int start = 1, end = k;
            // If the first element is not equal to start, something wrong with sequence
            if (A[0] != start) return false;
            // If we here it means we checked 1, let go further
            int expected = start + 1;
            int currUnique = A[0];
            for (int i = 1; i < A.Length; i++)
            {
                // Is it new unique number?
                if (A[i] != A[i - 1])
                {
                    currUnique = A[i];
                    // Compare with expected and check is there any other numbers?
                    if (currUnique != expected || expected > end)
                        return false;
                    expected++;
                }
            }
            return true;
        }
    }
}