Le calcul d'une Somme avec C++

J'ai écrit le code suivant à la somme de la série (-1)^i*(i/(i+1)). Mais quand je le lance j'obtiens -1 pour toute valeur de n.

Certains une, merci de signaler ce que je fais de mal? Je vous remercie à l'avance!

#include <iostream>
using namespace std;

int main()
{
    int sum = 0;
    int i = 1.0;
    int n = 5.0;

    for(i=1;i<=n;i++)
        sum = (-1)^i*(i/(i+1));

    cout << "Sum" <<" = "<< sum << endl;
    return 0;
}

Que pensez-vous de la ^ opérateur? Vous cherchez à effectuer un ou exclusif de l'opération, ou essayez-vous d'effectuer l'exponentiation?
Et pourquoi avez-vous attribuer à virgule flottante d'un entier? (int i = 1.0)
eh bien d'abord, votre réglage de la somme à chaque passage de la boucle et de ne pas ajouter à la valeur précédente. deuxième ^ ne soulèvent pas un pouvoir, comme vous ne le pensez. admirez la c de la bibliothèque math. et attention aux conversions implicites qui se passe quand vous divisez-la en une fraction.

OriginalL'auteur Surfcast23 | 2012-02-03

c++series sum

14

Le problème n ° 1: Le C++ ^ opérateur n'est pas le calcul de la puissance de l'opérateur. C'est un XOR au niveau du bit.

Vous devez utiliser pow() à la place.

Problème n ° 2:
Vous stockez les types à virgule flottante dans un type entier. Donc la suite sera résultat en division entière (tronquée)de la division:
```
i/(i+1)
```
Problème #3:
Vous n'êtes pas réellement en additionnant rien:
```
sum = ...
```
devrait être:
```
sum += ...
```
Une version corrigée du code est comme suit:
```
double sum = 0;
int i = 1;
int n = 5;

for(i = 1; i <= n; i++)
    sum += pow(-1.,(double)i) * ((double)i / (i + 1));
```
Bien que vous n'avez vraiment pas besoin d'utiliser pow dans ce cas. Un test simple pour la pair/impair fera.
```
double sum = 0;
int i = 1;
int n = 5;

for(i = 1; i <= n; i++){
    double val = (double)i / (i + 1);
    if (i % 2 != 0){
        val *= -1.;
    }
    sum += val;
}
```
1 erreur vers le bas, 2 de plus pour y aller.
En outre, puisque toutes ses variables sont ints, il va faire des math entier, et i/(i+1) toujours évaluer à 1, à moins que i == 0 ou i==1
pour 0 en fait.
n'oubliez pas de somme +=
Que l'on a été étonnamment difficile à rattraper... m'a fallu quelques min.

OriginalL'auteur Mysticial
4

Vous aurez besoin de trop mettre de somme += pow(-1,i)*(i/(i+1));

Sinon vous perdez précédent résultat à chaque fois.

Utiliser la fonction pow pour pow opération.

edit : comme dit dans d'autres post, double ou float au lieu de int pour éviter tronquée de la division.

OriginalL'auteur ClemPi

Comment à ce sujet

((i % 2) == 0 ? 1 : -1)

au lieu de

std::pow(-1, i)

Réponse complète:

double sum = 0;
int i = 1.0;
int n = 5.0;
for (i = 1; i <= n; ++i) {
    signed char sign = ((i % 2) == 0 ? 1 : -1);
    sum += sign * (i / (i+1));
}

OriginalL'auteur Sergey Brunov

2

Quelques problèmes:
1. ^ est le bit à bit ou exclusif en c++ pas "élevé à la puissance". Utiliser pow() la méthode.
2. Supprimer le balançant de l'ouverture du support de la dernière ligne
3. Utilisation ints pas flotteurs lors de l'attribution d'ints.
OriginalL'auteur Sid
2

Vous semblez avoir quelques choses de mal avec votre code:
```
using namespace std;
```
Ce n'est pas directement liée à votre problème à portée de main, mais ne jamais dire using namespace std; Il introduit bogues subtils.
```
int i = 1.0;
int n = 5.0;
```
Vous initializaing partie intégrante des variables avec les constantes en virgule flottante. Essayez
```
int i = 1;
int n = 5;
```
```
sum = (-1)^i*(i/(i+1));
```
Vous avez deux problèmes avec cette expression. Tout d'abord, la quantité (i/(i+1)) est toujours à zéro. Rappelez-vous la division de deux ints arrondit le résultat. Deuxièmement, ^ ne fait pas ce que vous pensez que cela fonctionne. C'est l'opérateur ou exclusif, non pas l'opérateur exponentiel. Troisièmement, ^ se lie moins serré que *, de sorte que votre expression est:
```
-1 xor (i * (i/(i+1)))

-1 xor (i * 0)
-1 xor 0
-1
```
quels sont les bugs qui ne using namespace std cause, le lien?
Discussion ici et here.
Merci pour les liens concernant l'utilisation de l'espace de noms std.

OriginalL'auteur Robᵩ
1

^ ne fait pas ce que vous pensez que cela fonctionne. Il y a aussi quelques autres erreurs dans votre code.

Ce qu'elle devrait être:
```
#include <iostream>
#include <cmath>

int main( )
{
    long sum = 0;
    int i = 1;
    int n = 5;

    for( i = 1; i <= n; i++ )
        sum += std::pow( -1.f, i ) * ( i / ( i + 1 ) );

    std::cout << "Sum = " << sum << std::endl;

    return 0;
}
```
De prendre un pouvoir de valeur, l'utilisation std::pow (voir ici). Aussi, vous ne pouvez pas affecter int à une valeur décimale. Pour cela, vous devez utiliser float ou double.

Ladite ^ est un bit à bit-XOR, pas une marque pour un exposant.

Également être prudent de L'Arithmétique Des Nombres Entiers que vous pouvez obtenir des résultats inattendus. Probablement vous voulez changer vos variables, soit float ou double.

Merci à tous ceux qui ont répondu!

OriginalL'auteur ssell
1

Il existe quelques problèmes avec le code:
```
int sum = 0;
```
Les résultats intermédiaires ne sont pas des entiers, ce devrait être un double
```
int i = 1.0;
```
Puisque vous l'utiliserez dans une division, il devrait être un double, 1/2 est 0 si le calcul en nombres entiers.
```
int n = 5.0;
```
C'est un int, pas une valeur en virgule flottante, pas .0 est nécessaire.
```
    for(i=1;i<=n;i++)
```
Vous avez déjà initialisé i 1, pourquoi le faire à nouveau?
```
sum = (-1)^i*(i/(i+1));
```
Chaque itération, vous perdez la valeur précédente, vous devez utiliser sum+= "nouvelles valeurs"

Aussi, vous n'avez pas besoin de pow pour calculer (-1)^i, tout cela n'est basculer entre +1 et -1 en fonction du pair/impair statut de i. Vous pouvez le faire plus facilement avec un if déclaration de confidentialité ou 2 for's, l'une pour les i pour encore... Beaucoup de choix, vraiment.

OriginalL'auteur Andrei

Vous devez vous connecter pour publier un commentaire.