Обращение положительных последовательностей в массиве

Question

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

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
using namespace std;
int Arr[100];
int Arr2[100];
int main()
{
srand(time(NULL));
int n, x;
bool seq = false;
int ib = 0;
printf("Starting array\n");
for (n = 0; n < 100; Arr[n++] = (rand() % 101) - 50);
for (n = 0; n < 100; printf("%3d ", Arr[n++]));
putchar('\n');
for (n = 0; n < 100; n++) //sorting
{
    if (Arr[n] > 0) //check if the number is positive
    {
        if (seq == false) //if it isn't the part of a sequence
        {
            seq = true; ib = n; //declare it now is, and remember index     of sequence's beginning
        }
        else
            seq = true; //do nothing if it isn't first
    }
    else //if the number is negative
    {   
        if (seq==true) //if sequence isn't null
        for (x = n; ib <= n; ib++, x--) //new variable so that n will stay unchanged, 
          number of iterations = length of sequence
        {
            Arr2[x] = Arr[ib]; //assigning array's value to a new one,
            reversing it in the process
        }
        seq = false; //declaring sequence's end 
        Arr2[n + 1] = Arr[n + 1]; //assigning negative numbers at the same place of a new array
    }
}
printf("Modified array\n");
for (n = 0; n < 100; printf("%3d ", Arr2[n++]));
putchar('\n');
system('pause');
return 0;
}

Answer 1

Следуя тому, что мы обсуждали в комментариях, я перечислил здесь несколько правил, чтобы сформировать свой ответ вокруг него.

Правила:

• Последовательность элементов может быть различной.так что если в массиве есть 5 положительных чисел в строке, мы бы поменяли местами 5 элементов.например,

array[5] = {1,2,3,4,5} станет array[5]{5,4,3,2,1}

• , если одно положительное число соседствует с отрицательными значениями, обратного хода не произойдет array[4] = {-1,0,-2,1} приведет к тому жемассив

• при обнаружении отрицательного числа обработка не происходит.

на основе этих правил.вот что я считаю неправильным в вашем коде.

Проблемы:

1 - учтите это array = {1,2,-1}.обратите внимание, что последнее значение является отрицательным.из-за этого.следующий код будет выполняться при обработке 3-го индекса массива:

` Arr2[n + 1] = Arr[n + 1]; //assigning negative numbers at the same place of a new array`

- это нет-нет.поскольку вы уже в конце Arr2 n + 1, это означает, что в массиве есть 4-й элемент. (в вашем случае элемент 101h массива) это может привести к неопределенному поведению.

2 - рассмотрите тот же массив, упомянутый выше.когда этот массив зациклен, результат будет array = {-1,2,1}.-1 и 1 меняются местами вместо 1 и 2.

3 - вы назначаете ib = n каждый раз, когда обнаруживается отрицательное число.потому что всякий раз, когда удаляется отрицательное значение, seq=false принудительно.Но ib никогда не использовался, пока не будет найдено следующее отрицательное число.вот пример;

array = {...2, 6}

в таком сценарии 2 и 6 никогда не будут обращены вспять, потому что за этой положительной последовательностью нет отрицательного значения.

4 - рассмотримэтот сценарий arr = {-10,-1,....} приведет к arr = {0,-1,....}.Это происходит из-за того же кода, вызывающего неопределенную проблему поведения, упомянутую выше.

 `Arr2[n + 1] = Arr[n + 1];`

Предложение
Большинство проблем, упомянутых выше, возникает из-за того, что вы пытаетесьвыяснить последовательность положительных чисел при обнаружении отрицательного числа.

 else //if the number is negative
    {   
        if (seq==true) //if sequence isn't null
        for (x = n; ib <= n; ib++, x--) //new variable so that n will stay unchanged, 
          number of iterations = length of sequence
        {
            Arr2[x] = Arr[ib]; //assigning array's value to a new one,
            reversing it in the process
        }

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

• запустите цикл for как обычно.
  

  for (n = 0; n < 100; n++) //sorting {

• не пытайтесь ничего делать, если элемент в массиве имеет отрицательное значение.
  if (Arr[n] > 0) //check if the number is positive

• , если число положительное.создать запись индексов последовательности.во-первых, мы знаем, что последовательность будет начинаться с n, если `if (Arr [n]> 0) true.поэтому мы можем сделать что-то вроде этого;
  

  int sequenceStart = n;

• нам также нужно знать, когда заканчивается последовательность положительных чисел.
  

  int sequenceEnd = sequenceStart;

• причина int sequenceEnd = sequenceStart; в том, что мы собираемся начать использовать то же значение n для начала.Теперь мы можем перебрать массив и увеличивать sequenceEnd, пока не достигнем отрицательного числа или конца массива.
  

      while (currentElement > 0)
      {
          n++;//increment n
          if(n < arraySiz) //make sure we still in the range
          {
              currentElement = Arr[n]; // get the new elemnet
              if (currentElement > 0)
              {
                  sequenceEnd++;
              }
  
          }
          else
              break;     // we hit to a negative value so stop the while loop.
  
      }
  

• обратите внимание на n++;//increment n это будет увеличивать n ++, пока мы не достигнем отрицательного числа.это здорово, потому что в конце последовательности цикл for продолжится с обновленного n

• после цикла while, вы можете создать массив такого же размера, какколичество последовательностей, которые вы повторяли.затем вы можете сохранить элементы начиная с arr[sequenceStart] и arr[sequenceEnd], что упростит обратную последовательность в массиве.