Как записать самую длинную постоянную последовательность (увеличение или уменьшение) в C ++?

Question

Я должен сделать программу на C ++, которая может опционально управлять последовательностью от 2 до 1000 элементов. В конце программа должна отследить самые длинные увеличивающиеся или уменьшающиеся порядковые номера элемента.

Примеры:

6; 1; 2; 3; 2; 4; 1;выход: 3; (потому что: 1; 2; 3 самый длинный с 3 элементами)

6; 4; 3; 1; 5; 2; 1;вывод: 4; (потому что: 6; 4; 3; 1 самый длинный с 4 элементами)

Я устал от следующего кода и вида работы. Проблема в том, что он не может дать самый длинный, он дает номер последней последовательности каждый раз.

К сожалению, я не могу найти ошибку или проблему. Может ли кто-нибудь помочь, пожалуйста?

int counting = 1;
int counting_max = 0, counting_min = 0;

for (int i = 1; i < n; ++i) {
        if(block[i] < block[i+1]) {
            if(block[i]-block[i-1]>0) {
                counting++;
                    if(counting>counting_max) {
                    counting_max = counting;
                }}
                else {
                    counting = 1;
                }
            }

        if(block[i] > block[i+1]) {
            if(block[i]-block[i-1]<0) {
                counting++;
                    if(counting>counting_min) {
                    counting_min = counting;
                }}
                else {
                    counting = 1;
                }
            }
}
        if(counting_max >= counting_min) {
            cout<< counting_max;
        }
        else {
            cout<< counting_min;
        }


return 0;}

В моем коде я не поделился первой частью, потому что я думаю, что она работает правильно. Первый - это просто время и функция для вызова номера элемента и после точных чисел в блоке. Так что в моем коде блок содержит цифры.

Answer 1

В коде, который вы опубликовали, ваш внешний цикл создает доступ за пределы массива block, так как вы получаете доступ к block[i+1] в цикле. Вероятно, это причина того, что ваш код выдает правильные ответы в одном направлении, а не в другом.

Помимо этого, есть некоторые другие проблемы, с которыми вы можете столкнуться при таком подходе:

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

Вот пересмотренная версия, которая охватывает эти пункты:

int counting = std::min(n, 1);
int counting_max = counting;

for (int i = 0; i < n - 1; ++i) {
    if (
        block[i] < block[i + 1] &&
        (counting < 2 || block[i] > block[i - 1])
    ) {
        counting++;
    } else if (
        block[i] > block[i + 1] &&
        (counting < 2 || block[i] < block[i - 1])
    ) {
        counting++;
    } else if (block[i] == block[i + 1]) {
        counting = 1;
    } else {
        counting = 2;
    }

    if (counting > counting_max) {
        counting_max = counting;
    }
}

cout << counting_max << "\n";

Answer 2

Попробуйте этот альтернативный код: counting_max находит самую длинную восходящую последовательность, а counting_min находит самую длинную нисходящую последовательность (уменьшая ее счетчик цикла), и в конце мы сравниваем их, чтобы найти окончательный самый длинный (предположим, у нас есть n-1 элементов,если не измените его соответственно)

for (int i=1,j=n-2; i<n && j>=0; ++i,--j) {
    if (block[i] - block[i - 1]>0) {
        counting++;
        if (counting>counting_max)
        counting_max = counting;
    }
    else
    counting = 1;
    if (block[j] - block[j + 1]>0) {
        counting_back++;
        if (counting_back>counting_min)
        counting_min = counting_back;
    }
    else
    counting_back = 1;
    }

if (counting_max >= counting_min)
cout << counting_max;
else
cout << counting_min;