C для алгоритма цикла

#c #arrays #algorithm

#c #массивы #алгоритм

Вопрос:

Я новичок в c , и мне нужна помощь с алгоритмом цикла for в моей функции удвоения. Цель функции удвоения состоит в том, что если массив имеет одинаковые последовательные значения, то каждое число будет удвоено. Примером может служить массив, содержащий элементы 4, 4, 4 и 4. При использовании функции удвоения новый массив будет равен 8, 8, 8, 8. Еще раз спасибо, ребята! : D

 #include <iostream>
using namespace std;

void collectScores(double scores[], int SIZE);
void printScores(double scores[], int stopPlace);
void doubleUp(double scores[], int SIZE);

void collectScores(double scores[], int SIZE)
{
    for (int n = 0; n < SIZE; n  )
    {
        cout << "Please enter a value for element " <<  (n) << " : ";
        cin >> scores[n];
    }
    cout << endl;
}

void printScores(double scores[], int stopPlace)
{
    for (int n = 0; n < stopPlace; n  )
    {
        cout << "The value of element " << (n) << " : " << scores[n] << endl;
    }
}

void doubleUp(double scores[], int SIZE)
{
    for (int n = 0; n < SIZE; n  )
    {
        if (scores[n] == scores[n   1])
        {
            scores[n] *= 2;
        }
    }
}

int main()
{
    double r;
    const int SIZE = 4;
    double scores[SIZE];

    collectScores(scores, SIZE);
    printScores(scores, SIZE);

    cout << endl;

    doubleUp(scores, SIZE);
    printScores(scores, SIZE);


    system("pause");
    return 0;
}

1. Пожалуйста, объясните, в чем ваша проблема и вопрос. Bow вы сказали только то, что хотите сделать, но не то, что не так с вашим кодом.

2. Отладка резиновой утки . Я вижу, не пытаясь: запуск конца массива (неопределенное поведение), и вы никогда не удвоите последний в группе.

Ответ №1:

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

 void doubleUp(double scores[], int SIZE)
{
    if (SIZE < 2) return;        // 0 or 1 element just return
    bool isDouble = false;

    for (int n = 1; n < SIZE; n  )
    {
        if (scores[n] == scores[n - 1])
        {
            isDouble = true;
            scores[n - 1] = 2*scores[n - 1];
        }
        else if (isDouble)
        {
            isDouble = false;
            scores[n - 1] = 2*scores[n - 1];
        }
    }

    // edge case: possibly double the last element in the array
    //            if it be identical to the second to last element
    if (isDouble) scores[SIZE-1] = 2*scores[SIZE-1];
}

Ответ №2:

Как указывали люди, ошибка в вашем коде заключается в том, что ваш последний элемент не удваивается.Это связано с тем, что для последнего элемента в вашем массиве нет следующего элемента, и именно здесь происходит сбой части вашего кода «n 1». Существует довольно много способов решить эту проблему. Я использовал два цикла for — один для всех элементов, кроме последних двух элементов, а другой для последних двух элементов.

 void doubleUp(double scores[], int SIZE)
{
    for (int n = 0; n < SIZE-2; n  )
    {
        if (scores[n] == scores[n   1])
        {
            scores[n] *= 2;
        }
    }
    for (int n = SIZE-2; n <SIZE; n  )
    {
        if (scores[n] == scores[n   1])
        {
            scores[n] *= 2;
            scores[n 1] *= 2;
        }
    }  
}

Ответ №3:

Я считаю, что ваша функция удвоения должна быть слегка отредактирована:

 void doubleUp(double scores[], int SIZE)
{
    for (int n = 0; n < SIZE; n  )
    {
        if (n < SIZE-2)
        {    
            if (scores[n] == scores[n   1])
            {
                scores[n] *= 2;               
            }
        }
        else
        {
            if (scores[n] == scores[n   1])
            {
                scores[n] *= 2;
                scores[n 1] *= 2;   
                n  ;             
            }
        }
    }
}

Добавленный раздел, по сути, позволяет удвоить последний элемент в массиве, чего не было в исходном коде (после последнего элемента в массиве нет индекса n 1).