Найти все последовательные числа в int []

Question

Я хочу найти все последовательные числа в упорядоченном int [8] случайных чисел от 0 до 31. Последовательные числа должны быть длиной не менее 3 и не более 5 чисел.

В последнем примере я получаю очень реальную проблему.

ex:

int[] = new int[] { 3,7,14,16,23, 28, 29 ,30 } // no  result (28,29 is length of 2 numbers)

int[] = new int[] { 4,5,6,7,18, 19, 20 ,21 }  // 4,5,6,7 (yes! length of 4!!)

int[] = new int[] { 2.3.4.5.6.7.8.9 } // two results : 2,3,4 and 5,6,7,8,9  

Я не хочу решение , но просто пример того, как подойти к вопросупотому что я пытаюсь использовать генералов, и я действительно застрял!

Очень спасибо за помощь!

Кристиан

- это код, с которого я начал (не супс моей кухни)

public partial class Test2 : Form
{
    public Test2()
    {
        InitializeComponent();
    }

    private void Test2_Load(object sender, EventArgs e)
    {          

         int[] numbers = new[] { 21, 4, 5, 22, 17, 6, 20, 23 };

      //  int[] numbers = new[] { 1, 2, 3, 4, 5, 6, 7, 8 };

        foreach (Campo r in FindRanges(numbers, 3))
        {
            listBox1.Items.Add(string.Join(", ", r.Select(x => x.ToString()).ToArray()));
        }



    }


    struct Campo : IEnumerable<int>
    {
        readonly int _start;
        readonly int _count;

        public Campo(int start, int count)
        {
            _start = start;
            _count = count;
        }

        public int Start
        {
            get { return _start; }
        }

        public int Count
        {
            get { return _count; }
        }

        public int End
        {
            get { return _start + _count - 1; }

        }

        public IEnumerator<int> GetEnumerator()
        {
            for (int i = 0; i < _count; ++i)
            {
                yield return _start + i;
            }
        }

        IEnumerator IEnumerable.GetEnumerator()
        {

            return this.GetEnumerator();

        }


        public static Campo operator +(Campo x, int y)
        {
            return new Campo(x.Start, x.Count + y);
        }

        public Campo removefirst()
        {
            return new Campo(this.Start + 3, this.Count);
        }

        public Campo removelast()
        {
            return new Campo(this.Start, this.Count - 1);
        }
    }

    static IEnumerable<Campo> FindRanges(IEnumerable<int> source, int minCount)
    {


        var ordered = source.OrderBy(x => x);

        Campo r = default(Campo);

        foreach (int value in ordered)
        {

            if (r.Count == 0)
            {
                r = new Campo(value, 1);
                continue;
            }


            if (r.Count == 5)
            {
                r = r.removefirst();

                continue;
            }

            if (value == r.End)
            {
               continue;
            }


            if ((value == 0 || value == 8 || value == 16 || value == 24) && (r.Count > minCount))
            {
                continue;
            }

            if ((value == 7 || value == 15 || value == 23 || value == 31) && (r.Count == 1))
            {
                continue;
            }

            else if (value == r.End + 1)
            {
               r += 1;
            }
            else
            {

                if (r.Count >= minCount)
                {
                    yield return r;
                }


                r = new Campo(value, 1);
            }
        }


        if (r.Count >= minCount)
        {
            yield return r;
        }
    }

}

Answer 1

Предлагаю вам взять несколько примеров и выписать их на бумаге.Тщательно отрабатывайте то, что вы делаете интуитивно, когда вы пытаетесь решить их вручную, и конвертируйте это в код.последовательность, и какое предыдущее значение было ...

Answer 2

извините за позднее обновление, но время очень угнетает ....

Это мое окончательное решение со всеми необходимыми ограничениями (для моих нужд) для serier.Спасибо всем

static IEnumerable<IEnumerable<int>> Sequences(IEnumerable<int> input, bool ascen = false, int min = 3)
    {
        int ord = ascen == false ? -1 : 1;

        input = ord == -1 ? input.OrderByDescending(x => x) : input.OrderBy(x => x);

        var seq = new List<List<int>>();
        foreach (var i in input)
        {
            var existing = seq.FirstOrDefault(lst => lst.Last() + ord == i);
            if ((existing == null) || (seq.Last().Count == 5) || i == 7 || i == 15 || i == 23)

                seq.Add(new List<int> { i });
            else
                existing.Add(i);
        }
        return min <= 1 ? seq : seq.Where(lst => lst.Count >= min);
    }

Answer 3

Конечно, это зависит от того, ограничена ли ваша проблема этими ограничениями, я имею в виду массив int [8], 0-31 и 3-5, но если это не так, я думаю, что ваша проблема не может быть решена по наивному алгоритму.

Я имею в виду, скажем, у нас есть этот массив:

int[] = new int[] { 2,3,4,5,6,7,8,9,10,11,12 };

и ограничение вашего подмножества, т. Е. "наборы последовательных номеров должны иметь длину не менее 3 и не более 5 номеров" .

Наивный алгоритм, который начинается с первого элемента до последнего и заполняет максимально возможное последовательное подмножество, даст следующие два подмножества:

[2,3,4,5,6] [7,8,9,10,11]

В этом решении 12 нет разделов, но, очевидно, существует другое возможное решение (на самом деле более одного), которое включает в себя все числа, например:

[2,3,4,5] [6,7,8,9] [10,11,12]

Следовательно, у вас может быть несколько возможностей:

1. 1-е решение в порядке, вам не нужно как можно больше покрывать найденный последовательный набор
2. Второе решение в порядке, вам нужно как можно больше покрыть найденный последовательный набор
3. Второе решение в порядке, вам нужно покрыть как можно больше найденного последовательного набора и, возможно, с наименьшим возможным числом подмножества

В первом случае вы можете сделать, как указал другой ответчик (привет, Джон Скит, ответил тебе!: P).
И наоборот, во 2-м и 3-м случаях это намного сложнее, потому что это проблема типа рюкзака , т. Е. Проблема завершения NP, (в частности, 3-й случай звучит как проблема создания изменений ).

Это мои два цента, очевидно, повторяю, проблема не существует, если у вас всегда один и тот же размер массива, ограничения по диапазону и подмножеству ...

Answer 4

псевдокод:

1-сортировка массива в порядке возрастания 2-

int count = 0
for i = 0 to array.length - 2
    if  {array[i + 1] - array[i] = 1 then
        count+=1
    else count=0}
    if { count >= 3 and count <= 5 then found}

Answer 5

1) Разделить указанный массив в списке последовательных чисел (вы сказали, что массив уже упорядочен)

2) При добавлении в список, если в списке уже есть 5 элементов, добавить в новый список

3) Списки граф> 2 - ваши результаты