Добавление суммы чисел с помощью оператора цикла - PullRequest
1 голос
/ 28 марта 2010

Мне нужна серьезная помощь, чтобы разделить положительные и отрицательные числа.

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

Данные должны выглядеть следующим образом:

-2,3 -1,9 -1,5 -1,1 -0,7 -0,3 0,1 0,5 0,9 1,3 1,7 2,1 2,5 2,9
Сумма отрицательных значений: -7,8 Сумма положительных
значения: 12

Пока у меня есть это:

int main () {

    int num, num2, num3, num4, num5, sum, count, sum1;
    int tempVariable = 0;
    int numCount = 100;
    int newlineCount = 0, newlineCount1 = 0;
    float numCount1 = -2.3;

    while (numCount <= 150)
    {
        cout << numCount << " ";

        numCount += 2;
        newlineCount ++; 
        if(newlineCount == 6)
        {
            cout<< " " << endl;
            newlineCount = 0;
        }
    }
    **cout << "" << endl;
    while (numCount1 <=2.9 ) 
    {
        cout << numCount1 << " ";
        numCount1 += 0.4;
        newlineCount1 ++;     
    } while (  newlineCount1  <= 0 && newlineCount >= -2.3 );

    cout << "The sum is " << newlineCount1 << endl;**

    return 0;   
}

Ответы [ 6 ]

2 голосов
/ 28 марта 2010

Я не знаю C / C ++, но вот общая идея цикла, предполагающего, что значения поступают из массива. (, поскольку я не знаю, как они поступают, т. Е. Пользовательский ввод и т. Д. )

Логика:

  • Используйте структуру цикла for, противоположную while, для цикла над каждым элементом массива.
  • Инициализируйте две переменные для подсчета, positiveSum и negativeSum.
  • На каждой итерации элемента проверяйте, больше ли оно 0. Вот как вы можете разделить положительные и отрицательные числа соответственно.
  • Если больше нуля, добавить элемент в текущий positiveSum, иначе добавить его к текущей сумме negativeSum.
  • Когда цикл завершится, positiveSum и negativeSum должны иметь рассчитанную сумму.

Если это домашняя работа, ( Я не помню, был ли тег домашней работы до вопроса или был добавлен позже ), этот псевдокод должен указывать вам правильное направление без явного выполнения вся работа для вас.

Псевдо-Java-код ( не тестировался и не компилировался )

 // as a good convention, I always initialize variables, 
 // for numbers I always use zero's.
double positiveSum, negativeSum = 0.0; 
 // assuming array holds the array of values.
for (i=0; i < array.length; i++) {
 // if positive, add it to the count
 if (array[i] > 0) positiveSum = positiveSum + array[i];
 // else negative
 else negativeSum = negativeSum + array[i];
}

После завершения оба параметра positiveSum и negativeSum должны содержать правильную рассчитанную сумму.

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

0 голосов
/ 10 апреля 2010

Я не программист, но я подумал, что лучше держать внутреннюю часть цикла как можно более скудной.Эта версия работает без каких-либо операторов if внутри цикла, просто добавление.Уже поздно ночью, и у меня было несколько виски, но я думаю, что этот алгоритм сработает (он работал, когда я пытался реализовать его на python).Это псевдо-код, поэтому вам придется написать его на любом языке:

neg_total =0
abs_total=0

loop with i in all_your_numbers
    total += i
    abs_total += abs(i)
end

neg_total=(total-abs_total)/2
pos_total=abs_Total+neg_Total

print "sum of negative values =", neg_total
print "sum of positive values =", pos_total

Я не уверен, что это хорошая практика программирования, я просто доволен, что она сработалаОчки, если вы можете объяснить, как.

0 голосов
/ 29 марта 2010

Это легко решается с помощью чистой математики:

lowerBound = -2.3
upperBound = 2.9
incAmount = 0.4
signChange = lowerBound % incAmount
numBelowChange = -(lowerBound-signChange)/incAmount
avgNegValue = -(numBelowChange+1)/2.0*incAmount + signChange
sumOfNegative = numBelowChange*avgNegValue
numAboveChange = (upperBound-signChange)/incAmount
avgPosValue = (numAboveChange+1)/2.0*incAmount + signChange
sumOfPositive = numAboveChange*avgPosValue + signChange

Это точнее и эффективнее, чем зацикливание и сложение.

С предоставленными вами константами,

signChange     =  0.1
numBelowChange =  6.0
avgNegValue    = -1.3
sumOfNegative  = -7.8
numAboveChange =  7.0
avgPosValue    =  1.7
sumOfPositive  =  12.0

Если вы не знакомы с оператором %, x%y означает «разделить x на y и вернуть остаток». Итак 5%2=1

http://en.wikipedia.org/wiki/Modulo_operator

0 голосов
/ 28 марта 2010

Вы явно усложняете проблему. Прежде всего вам не нужны два отдельных цикла для чисел, поскольку между ними существует постоянная разница в 0,4, даже между -0.3 и 0.1. Вам нужно только проверить, отрицателен ли он, или не знать, как их суммировать.

Циклы проще, если вы используете целое число в качестве счетчика. Если вам нужно 14 чисел, вы можете просто считать от 0 до 13, и из этого вы можете легко вычислить соответствующее значение с плавающей запятой.

Пример кода C #:

double negSum = 0.0, posSum = 0.0;
for (int i = 0; i < 14; i++) {
  double number = -2.3 + (double)i * 0.4;
  if (number < 0) {
    negSum += number;
  } else {
    posSum += number;
  }
}

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

double negSum = 0.0, posSum = 0.0;
for (double number = -2.3; number < 3.1; number += 0.4) {
  if (number < 0) {
    negSum += number;
  } else {
    posSum += number;
  }
}

Кроме того, при многократном накоплении чисел с плавающей запятой (например, добавление 0,4 снова и снова) вы также накапливаете ошибки округления. Большинство чисел не могут быть представлены точно как числа с плавающей запятой, поэтому, скорее всего, вы добавляете что-то вроде 0.3999999999999994225 вместо 0,4 на каждую итерацию. Маловероятно, что в этом небольшом примере сложится что-то, чего достаточно, но вы должны знать об этом эффекте, чтобы можно было ожидать его в ситуациях с большим количеством цифр.

0 голосов
/ 28 марта 2010

У вас есть несколько магических чисел, в назначении которых я не уверен, например, numcount1 = -2.3 В общем, вы хотите избежать магических чисел.

Возможно, вы захотите дать своим переменным более описательные имена, чем num1, num2 и т. Д.

Не могли бы вы более точно объяснить, каковы параметры для вашего задания?

EDIT:

Я заметил, что вы используете очень странные условия для управления вашим циклом. Вы продолжаете, пока numcount1 не станет = 2.9, что является очень хрупкой установкой. Первое, что я хотел бы сделать на вашем месте, это переписать вашу программу так, чтобы цикл завершался, когда больше нет чисел, которые нужно добавить. (В качестве альтернативы вы можете просто остановить его, скажем, после 12 значений.)

ИЗМЕНИТЬ СНОВА:

ОК, как на счет этого

int sumOfPos = 0, sumOfNeg = 0, currentValue = -2.3, terminationValue = 2.9;

while (currentValue <= terminationValue) {
    if (  /* there is a missing condition here */ ) {
                // need a statement here to increment your negative counter
    } else {
                // need a statement here to increment your positive counter
    }
}
        // put some statements here to do output
0 голосов
/ 28 марта 2010

Я бы перебрал каждый номер по отдельности, назовем его currentValue

если число отрицательное, absoluteNumberTotal + = currentValue

иначе, если положительный, positiveNumberTotal + = currentValue

Таким образом, вы получите свои индивидуальные итоги. Очень просто.

Добро пожаловать на сайт PullRequest, где вы можете задавать вопросы и получать ответы от других членов сообщества.
...