Números primos em C++ - Como descobrir

Neste tutorial, vamos destrinchar os primos. Vamos aprender como verificar se um número é primo ou não, bem como exibir uma lista de quantos primos quisermos, usando laços e loopings, em C++.

Números Primos na Matemática

Um número é dito ser primo quando pode ser dividido somente por 1 e por ele mesmo.
O 7 é primo, você pode dividir só por 1 e por 7, por qualquer outro valor vai dar um resultado quebrado.

O 12 não é primo, pois pode ser dividido por 1, 2, 3, 4, 6 e 12.

Vejamos alguns números primos: 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997...

Os primos são uma classe muuuuito especial na Matemática, tendo utilidade em diversos ramos e áreas, como na criptografia.

Vale a pena pesquisar sobre eles, há todo um véu de mistério neles, pois tentam há milênios encontrar uma fórmula para gerar números primos e nada até hoje deu certo.

Será que um dia você consegue? Quem sabe...se ganhar o prêmio Nobel, não esquece de compartilhar a grana com a gente...

Simbora caçar uns primos?

Como Descobrir se um número é primo

Para verificar se um número num é primo, basta verificar seus divisores, de 1 até num.

Por exemplo, vamos testar se o 9 é primo. Basta analisar o resto da divisão por 1, 2, 3, 4, 5, 6, 7, 8, e 9.
Se for primo, somente vai ser divisível por 1 e por ele mesmo, logo vai ter 2 divisores. Mas o resto da divisão vai dar 0 quando fizermos 9%3, logo 3 também é divisor, totalizando 3 divisores, logo não é primo.

Agora o 11.
Podemos pegar o resto da divisão por 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 e 11, que só vai dar 0 pra 1 e pra 11.
Logo, ele é primo.

Ou seja, basta fazer o resto da divisão de num por 1, 2, 3, 4, 5, ..., até num, e contar na variável div (inicializada com 0), quantos divisores tem.

Se for 2, é primo.
Se for mais que 2, não é primo.

Veja o código:

#include <iostream>
using namespace std;

int main()
{
    int aux, num=479001599, div=0;

    for(aux=1 ; aux<=num ; aux++)
        if(num%aux==0)
            div++;

    if(div==2)
        cout<<"É primo"<<endl;
    else
        cout<<"Não é primo"<<endl;
    return 0;
}

Testamos com um número primo gigante, o 479001599.
Aqui levou 1.831s pra verificar, e na sua máquina?

Otimizando a busca por primos

Ora, todo número é divisível por 1.
Então não precisamos fazer o resto da divisão por 1, já é uma checagem a menos.

E também não precisamos testar até num.
Passou da metade, não vai ter mais nenhum divisor possível.

Dando uma enxugada no código, ele fica assim:

#include <iostream>
using namespace std;

int main()
{
    int aux, num=479001599, div=0;

    for(aux=2 ; aux<=num/2 ; aux++)
        if(num%aux==0)
            div++;

    if(div==0)
        cout<<"É primo"<<endl;
    else
        cout<<"Não é primo"<<endl;
    return 0;
}

Agora levou só 1.012s
E na sua máquina?

Podemos ir mais além e calcular até a raiz quadrada de num, ao invés de apenas até num/2 (pesquise o motivo disso):

#include <iostream>
#include <cmath>
using namespace std;

int main()
{
    int aux, num=479001599, div=0;

    for(aux=2 ; aux<=sqrt(num) ; aux++)
        if(num%aux==0)
            div++;

    if(div==0)
        cout<<"É primo"<<endl;
    else
        cout<<"Não é primo"<<endl;
    return 0;
}

0.004s ! Carai, maluco!

Achando primos num intervalo

Agora vamos imprimir todos os primos num determinado intervalo, de 1 até um valor Máximo, como 100.

Primeiro, uma variável pra testar todos os números de 2 até Max, é a aux.

Para cada número, vamos contar todos os divisores e armazenar na variável div, por isso ela deve começar zerada dentro do primeiro laço.

No segundo FOR, vamos verificar cada número aux, fazendo o resto da divisão deles por 2 até raiz quadrada do número, para verificar se tem divisores.

Se tiver, cai no IF (IF dentro de um FOR que está dentro de outro FOR, que loucura!), que incrementa div.

Após toda essa verificação interna, ele é primo se div tiver 0 como valor, se tiver, então imprimimos o valor de aux, pois é um primo.

Veja como fica o código:

#include <iostream>
#include <cmath>
using namespace std;

int main()
{
    int aux, coun, Max=100, div;

    for(aux=2 ; aux<=Max ; aux++){
        div=0;

        for(coun=2 ; coun<=sqrt(aux) ; coun++)
            if(aux%coun==0)
                div++;

        if(!div)
            cout<<aux<<" ";
    }

    cout<<endl;

    return 0;
}

Teste com mil, 10 mil, 1 milhão...só agora você tem real noção do poder e capacidade de calcular que tem sua máquina

As instruções BREAK e CONTINUE do C++

Neste tutorial, vamos aprender duas instruções, ou comandos, muito importantes: o break e o continue, em C++.

Instrução BREAK em C++

Se você fez direitinho e na ordem, o curso C++ Progressivo, já deve conhecer este comando break, pois usamos no tutorial:
Switch, case e break

Lá, quando esse comando era executado, ele simplesmente encerrava o teste condicional SWITCH.
Aqui, ele faz a mesma coisa, mas no caso ele serve para interromper um laço, a qualquer instante.

No código abaixo, o C++ fica pedindo um número ao usuário e calculando seu quadrado.
Se em algum momento o usuário digitar 0, o IF se torna verdadeiro e o comando break é acionado, interrompendo sumariamente o laço WHILE:

#include <iostream>
using namespace std;

int main()
{
    int num;

    while(true){
        cout<<"Numero: ";
        cin >>num;

        if(num==0)
            break;

        cout<<num*num<<endl;
    }

    return 0;
}

Ou seja, quando queremos, em algum momento, interromper um laço, usamos a instrução BREAK, que geralmente vem dentro de um teste condicional, dentro de algum looping.

Se tivermos um laço dentro de outro, e dentro deste estiver uma instrução BREAK, somente esse laço mais interno que será interrompido, ok?

O seguinte código fica pedindo notas para o usuário, para calcular a média.
Caso o usuário digite uma nota que não é válida (abaixo de 0 ou acima de 10), o laço WHILE é encerrado e fornecemos a média dos números digitados dessa nota inválida:

#include <iostream>
using namespace std;

int main()
{
    int aux=0;
    float num, sum=0;

    while(true){
        cout<<"Nota: ";
        cin >> num;

        if(num<0 || num>10)
            break;

        sum+=num;
        aux++;
    }

    cout<<"Média: "<<(sum/aux)<<endl;
    return 0;
}

Note que garantimos que os números fornecidos sejam corretos (entre 0 e 10), pois caso contrário o laço é encerrado.

O comando CONTINUE em C++

Se o BREAK encerra o teste condicional ou estrutura de controle, o comando CONTINUE encerra apenas a iteração.

Ou seja, pula pra próxima iteração.

Vamos somar todos os números de 1 até 100, exceto os múltiplos de 4:

#include <iostream>
using namespace std;

int main()
{
    int num, sum=0;

    for(num=1; num<=10 ; num++){
        if(num%4==0)
            continue;
        sum += num;
    }

    cout<<"Total: "<<sum<<endl;
    return 0;
}

Dentro do laço verificamos se o número é divisível por 4, se for, essa iteração é pulada, não rodando o código seguinte ao CONTINUE, vai pra próxima iteração normalmente.

Assim como o BREAK, o comando CONTINUE geralmente ocorre sob determinado teste condicional, quando você quer excluir uma iteração específica do looping.

Vamos refazer o código que calcula a média.
Agora, ao invés de parar a execução, ele pula a iteração, não somando aquela nota inválida na soma:

#include <iostream>
using namespace std;

int main()
{
    int aux=0;
    float num, sum=0;

    while(true){
        cout<<"Nota: ";
        cin >> num;

        if(num>10){
            cout<<"Nota acima de 10 são inválidas"<<endl;
            continue;
        }
        if(num<0){
            cout<<"Nota negativa, encerrando cálculos e exibindo a média: ";
            break;
        }

        sum+=num;
        aux++;
    }

    cout<<(sum/aux)<<endl;
    return 0;
}

Note que a média é calculada apenas para números válidos. Para encerrar o looping, você precisa digitar um valor negativo.

Mega-Sena com C++

Neste tutorial de C++, vamos aprender como contar todas os possíveis palpites da Mega-Sena, bem como vamos ver como exibir todos esses números, usando a técnica de estruturas de repetição aninhadas.

A loteria da Mega-Sena

Muito provavelmente você já jogou na Mega Sena, não é?

Ela funciona assim: você deve escolher 6 dezenas (sena), de um universo de 60 números, de 1 até 60.

No sorteio, tem um globo com 60 bolas e as moças bonitas lá vão tirando bolinha por bolinha...então, obviamente, as dezenas não se repetem, concorda?

No final, eles exibem o resultado na ordem crescente dos valores, ou seja, da dezena menor pra maior.

O 'menor' palpite é:
1 2 3 4 5 6

Já o 'maior' palpite é:
55 56 57 58 59 60

Aqui vem o segredo:

1. A primeira dezena vai de 1 até 55
2. A segunda dezena vai de 2 até 56
3. A terceira dezena vai de 3 até 57
4. A quarta dezena vai de 4 até 58
5. A quinta dezena vai de 5 até 59
6. A sexta dezena vai de 6 até 60

Quantos palpites são possíveis na Mega Sena

Então, vamos lá.

Vamos usar 6 variáveis para as dezenas: dez1, dez2, dez3, dez4, dez5 e a dez6.

A variável acumuladora, para contar quantas iterações (consequentemente, quantos palpites são possíveis na Mega Sena), é a sum.

Agora basta fazer FOR aninhado com FOR e contar quantas possibilidades existem, sempre tendo cuidado com o intervalo que cada dezena pode assumir.

Outro segredo, importante, é que a variável dez1 começa do 1, e as seguintes começam a partir da dezena anterior somado de 1, pois as dezenas são maiores que as outras, já que estamos assumindo que estejam em ordem crescente.

O código:

#include <iostream>
using namespace std;

int main()
{
    int dez1, dez2, dez3, dez4,
        dez5, dez6, sum=0;

    for(dez1=1; dez1<=55 ; dez1++)
        for(dez2=dez1+1; dez2<=56 ; dez2++)
            for(dez3=dez2+1; dez3<=57 ; dez3++)
                for(dez4=dez3+1; dez4<=58 ; dez4++)
                    for(dez5=dez4+1; dez5<=59 ; dez5++)
                        for(dez6=dez5+1; dez6<=60 ; dez6++)
                            sum++;
    cout << "Total : " << sum << endl;

    return 0;
}

E o resultado é:

Se ainda se lembrar das aulas de análise combinatória, basta calcular (60 seis a seis).

Aqui levou 0.167s pra rodar mais de 50 milhões de iterações, e aí na sua máquina?

Exibindo todos os palpites da Mega-Sena

Agora vamos imprimir na tela todos os possíveis resultados:

#include <iostream>
using namespace std;

int main()
{
    int dez1, dez2, dez3, dez4,
        dez5, dez6;

    for(dez1=1; dez1<=55 ; dez1++)
        for(dez2=dez1+1; dez2<=56 ; dez2++)
            for(dez3=dez2+1; dez3<=57 ; dez3++)
                for(dez4=dez3+1; dez4<=58 ; dez4++)
                    for(dez5=dez4+1; dez5<=59 ; dez5++)
                        for(dez6=dez5+1; dez6<=60 ; dez6++)
                            cout<<dez1<<"-"<<dez2<<"-"<<dez3<<"-"
                                <<dez4<<"-"<<dez5<<"-"<<dez6<<endl;

    return 0;
}

Note que agora é beeeem mais demorado, e isso se deve ao fato da função cout ser mais lenta, demora pra exibir as coisas na sua tela, se a máquina ficasse só fazendo os cálculos, como no exemplo anterior, seria bem mais rápido. Mas aqui temos que mostrar os resultados das iterações, então a coisa é mais morosa mesmo.

Laços aninhados em C++ - Laço dentro de laço

Agora que já treinamos bastante o conceito de laços e loopings, aprendendo a fazer, vamos aprender outro conceito importante, o de laços aninhados, ou laços dentro de laços.

Estruturas de Repetição aninhadas em C++

Veja nos tutoriais anteriores, onde usamos exercícios famosos para fixar nossos conhecimentos em estruturas de repetição, especificamente, nos códigos do laço DO WHILE:

• Tabuada
• Somatório e fatorial
• Sequência de Fibonacci
• Exponencianção

Colocamos um laço FOR dentro do laço DO WHILE.
Ou seja, existe um looping maior, um laço pai, o DO WHILE, que vai ficar repetindo uma estrutura base.

Dentro de cada iteração dessa, um laço FOR é executado.
Esse laço de dentro está aninhado ao laço de fora.

Consegue ver e entender sua função, por que ele funciona?
É bem simples, mas é uma técnica muito poderosa.

Usando laços aninhados em C++

Vamos usar a técnica das estruturas de repetição aninhadas para imprimir um tabuleiro N x N, ou seja, de N linhas e N colunas. Veja um exemplo de tabuleiro 3x3, pra jogar jogo da velha:
-   -   -
-   -   -
-   -   -

O segredo aqui é usar um laço pras linhas e outro, interno ao primeiro, para cuidar das colunas em cada linha.

O primeiro FOR vai de 1 até N, é o responsável pelas linhas.
Note que ao final dele tem uma quebra de linha, para imprimir a próxima iteração na linha de baixo.

Dentro do FOR de linha, vamos imprimir N tracinhos.

Veja como fica nosso código:

#include <iostream>
#include <iomanip>
using namespace std;

int main()
{
    int lin, col, N;

    cout<<"Tamanho do tabuleiro N x N: ";
    cin >> N;

    for(lin=1 ; lin<=N ; lin++){
        for(col=1 ; col<=N ; col++)
            cout<<" - ";

        cout <<endl;
    }

    return 0;
}

Como usar laços aninhados em C++

Vamos criar um programa para imprimir a seguinte tabela da imagem:

Veja que tabela bonita, que tabela formosa, que tabela bem feita.
Vamos aprender como fazer ela?

Primeiro, note duas duas, ela tem:

• 4 linhas
• 4 colunas

Vamos usar dois laços, um para cuidar das linhas e outro para cuidar das colunas.
Para controlar esses laços, vamos usar as variáveis lin e col, bem como uma variável que vai receber os números de 1 até 16, a num.

Vamos, de início, trabalhar nas linhas:
    for(lin=1 ; lin<=4 ; lin++){
        // alguma coisa
        cout <<endl;
    }

Note que ao término de cada iteração, temos que dar uma quebra de linha, para ir para a linha de baixo.

Dentro de cada iteração desta, precisamos imprimir as colunas, que são 4 por linhas.
Então vamos usar outro laço aninhado:
    for(lin=1 ; lin<=4 ; lin++){
        for(col=1 ; col<=4 ; col++){
            // alguma coisa
        }
        cout <<endl;
    }

Dentro desse for aninhado, tamos imprimir os números.
Como a variável col vai de 1 até 4, ele imprime quatro números em cada linha.

Vamos usar a variável num, inicialmente com valor 1, para imprimir esses valores.
Após a iteração interna, temos que incrementar essa variável.

Para a tabela sair bonitinha e formatada, vamos usar o comando setw, para definir como tamanho de 4 espaçamentos (você precisa incluir a biblioteca iomanip, pra usar esse comando).

Veja como ficou nosso código:

#include <iostream>
#include <iomanip>
using namespace std;

int main()
{
    int lin, col, num=1;

    for(lin=1 ; lin<=4 ; lin++){
        for(col=1 ; col<=4 ; col++){
            cout<<setw(4) << num;
            num++;
        }
        cout <<endl;
    }

    return 0;
}

Bacana, né?

Exemplo de uso de laços aninhados

Vamos agora imprimir um triângulo de asteriscos, do tamanho que o usuário quiser.
Por exemplo, um triângulo de tamanho 5:
*
**
***
****
*****

Note que vai ter 5 linhas.
Na primeira linha, tem 1 coluna.
Na segunda linha, tem 2 colunas.
...
Na quinta coluna, tem 5 colunas.

O primeiro FOR, a variável de controle lin vai de 1 até N, onde N é o tamanho do triângulo que o usuário quiser.
Dentro de cada FOR, vamos usar outro FOR para imprimir os asteriscos. Eles devem imprimir de 1
até lin, consegue captar essa ideia?

Na primeira linha, imprime 1 asterisco.
Na segunda linha, imprime 2 asteriscos.
...
Na N-ésima linha, imprime N asteriscos.

Veja como fica nosso código:

#include <iostream>
#include <iomanip>
using namespace std;

int main()
{
    int lin, col, N;

    cout<<"Tamanho do triângulo: ";
    cin >> N;

    for(lin=1 ; lin<=N ; lin++){
        for(col=1 ; col<=lin ; col++)
            cout<<"*";

        cout <<endl;
    }

    return 0;
}

Note que o FOR de fora, usa chaves, pois tem mais de uma linha de comando abaixo dele.
Já o FOR de dentro, não precisa, pois ele só tem uma linha de comando.
Cuidado para não confundir as chaves! Faça sempre um espaçamento e uma indentação correta, para não errar.

Laço dentro de laço de laço dentro de laço...

Ok, já vimos como aninhar estruturas de repetição, colocamos um FOR dentro de outro.
E que tal agora colocar mais um FOR, aninhado aos outros dois?

Vamos mostrar todos os horários possíveis de um relógio, durante o dia, no formato:
hour:min:sec

Ou seja, vai de : 00:00:00
Até o : 23:59:59

Vamos usar três variáveis: h, m e s
h vai de 0 até 23, tanto m como s vão de 0 até 59, pois representam os minutos e segundos.

Nosso código fica assim:

#include <iostream>
#include <iomanip>
using namespace std;

int main()
{
    cout.fill('0');
    for(int h=0 ; h < 24 ; h++)
        for(int m=0 ; m < 60 ; m++)
            for(int s=0; s<60 ; s++){
                cout<<setw(2)<<h<<":";
                cout<<setw(2)<<m<<":";
                cout<<setw(2)<<s<<endl;
            }

    return 0;
}

Usamos o setw(2) para definir 2 caracteres de espaçamento.
Quando não tiver nada pra aparecer nesse espaçamento, vai aparecer 0, pois usamos cout.fill('0')

Exponenciação usando laços em C++

Neste tutorial de nosso curso de C++, vamos aprender como usar laços para criar a operação matemática de exponenciação.

Exponenciação na Matemática

Chamamos de exponenciação, a operação matemática que tem dois números: a base e o expoente.
É o famoso 'x elevado a y'.

Por exemplo:
3² (3 elevado a 2, ou 3 elevado ao quadrado) - 3 é base e 2 o expoente
4³ (4 elevado a 3, ou 4 ao cubo) - 4 é a base e 3 o expoente.

Agora calculando essas operações:
3² = 3 * 3 = 9
4³ = 4 * 4 * 4 = 64
5⁴ = 5 * 5 * 5 * 5 = 625

Note como o valor da base se repete o tanto de vezes o valor do expoente...se repete...huuuum...repetição...lembra o quê? Huuum, laços!

Exponenciação com laços no C++

Se temos um valor:
a^b (a elevado a b), isso significa que o valor de a vai se repetir b vezes:

Vamos pedir ao usuário as variáveis base e expo.
O resultado, vamos armazenar em res, esse valor é inicializado com 1, pois vamos fazer uma série de multiplicações nessa variável.

Dentro do laço FOR, temos uma variável auxiliar aux que vai contar de 1 até expo, para realizar expo repetições, concorda?

Veja como fica nosso código usando laço FOR:

#include <iostream>
using namespace std;

int main()
{
    int base, expo, res=1, aux;

    cout << "Base: ";
    cin >> base;

    cout << "Expoente: ";
    cin >> expo;

    for(aux=1 ; aux<=expo ; aux++)
        res *= base;

    cout <<base<<"^"<<expo<<" = "<<res<<endl;

    return 0;
}

Agora com laço WHILE:

#include <iostream>
using namespace std;

int main()
{
    int base, expo, res=1, aux=1;

    cout << "Base: ";
    cin >> base;

    cout << "Expoente: ";
    cin >> expo;

    while(aux<=expo){
        res *= base;
        aux++;
    }

    cout <<base<<"^"<<expo<<" = "<<res<<endl;

    return 0;
}

E por fim, com a estrutura de repetição DO WHILE (basta digitar 0 e/ou 0 para encerrar os cálculos):

#include <iostream>
using namespace std;

int main()
{
    int base, expo, res, aux;

    do{
        cout << "Base: ";
        cin >> base;

        cout << "Expoente: ";
        cin >> expo;

        res=1;
        for(aux=1 ; aux<=expo ; aux++)
            res *= base;

        cout <<base<<"^"<<expo<<" = "<<res<<endl;
        cout<<endl;
    }while(base || expo);

    return 0;
}

Obviamente, esse algoritmo funciona apenas para expoentes inteiros, para decimais, o buraco é mais embaixo.

Mas vejam que bacana, a utilidade e versalidade das estruturas de repetição, nossos amados laços, servem até para fazer operações matemáticas.

Fibonacci com Laços em C++

Neste tutorial de nosso curso de C++, vamos aprender como exibir os termos da série de Fibonacci, usando apenas laços!

Fibonacci em C++ com laço FOR

Os dois primeiros termos da série são: 0 e 1.
Então, vamos pedir números inteiros acima de 2.

Vamos armazenar nas variáveis ult e penult o último número da sequência e o penúltimo, assim inicialmente:
ult = 1
penult = 0

Pedimos o número ao usuário e armazenamos em n.
Vamos para a nossa estrutura de repetição, o FOR.

Como já exibimos os dois primeiros termos da sequência: 0 e 1
Nossa contagem começa no terceiro membro da sequência: aux = 3
E ele vai até percorrer n iterações: aux <= n
Isso garante que n elementos da sequência sejam exibidos.

Dentro do FOR, primeiro, imprimimos o próximo termo: ult + penult

Agora vem o pulo do gato.
O novo valor de ult será a soma dele mesmo com o número anterior, penult.
E o valor novo de penult será ult.

Queremos fazer isso:
penult = ult = 1
ult = 1 + 0 = 1

O problema é que quando fazemos: penult = ult, o valor original de penult é perdido, que é o valor antigo que iríamos utilizar para calcular o novo valor de ult.

A solução pra isso é armazenar o valor antigo de penult na variável temporária temp.
Então é só fazer:
temp = penult;
penult = ult;
ult = ult + temp;

Pronto, agora a sequência 'andou', e está pronta para exibir o próximo termo.
Veja como fica nosso código:

#include <iostream>
using namespace std;

int main()
{
    int n, aux, temp, ult=1, penult=0;

    cout << "Exibir quantos termos: ";
    cin >> n;

    cout << penult << endl << ult << endl;

    for(aux=3 ; aux<=n ; aux++){
        cout << (ult+penult) << endl;

        temp = penult;
        penult = ult;
        ult = ult + temp;
    }

    return 0;
}

Fibonacci com laço WHILE em C++

#include <iostream>
using namespace std;

int main()
{
    int n, aux=3, temp, ult=1, penult=0;

    cout << "Exibir quantos termos: ";
    cin >> n;

    cout << penult << endl << ult << endl;

    while(aux<=n){
        cout << (ult+penult) << endl;

        temp = penult;
        penult = ult;
        ult = ult + temp;

        aux++;
    }

    return 0;
}

Você consegue fazer com laço DO WHILE, que fica calculando quantos termos quiser, em um looping que só acaba quando o usuário digita 0?

Escreva nos comentários.

Somatório e Fatorial com laços em C++

Neste tutorial, vamos resolver duas questões de nossa lista de exercícios de laços, vamos aprender como calcular o somatório e fatorial de um número, usando apenas laços FOR ou WHILE, em C++.

Somatório usando laços em C++

O somatório de um número n nada mais é que a soma dos números de 1 até n.

Então, primeiro pedimos ao usuário um inteiro positivo e armazenamos na variável n.
Vamos usar também uma variável auxiliar aux, que vai percorrer os valores de 1 até n, dentro do looping.

Também vamos usar a variável sum, que vai armazenar a soma de todos esses números. Obviamente, devemos inicializar ela com valor 0.

Veja como fica nosso código usando laço FOR:

#include <iostream>

using namespace std;

int main()
{
    int n, aux, sum=0;

    cout << "Somatório de: ";
    cin >> n;

    for(aux=1 ; aux<=n ; aux++)
        sum += aux;

    cout << "Somatório: " << sum << endl;

    return 0;
}

Agora com laço WHILE:

#include <iostream>

using namespace std;

int main()
{
    int n, aux=1, sum=0;

    cout << "Somatório de: ";
    cin >> n;

    while(aux<=n){
        sum += aux;
        aux++;
    }

    cout << "Somatório: " << sum << endl;

    return 0;
}

Com looping DO WHILE, podendo ser calculada várias vezes e digitando 0 pra terminar o laço:

#include <iostream>
using namespace std;

int main()
{
    int n, aux, sum;

    do{
        cout << "Somatório de: ";
        cin >> n;
        sum = 0;

        for(aux=1 ; aux<=n ; aux++)
            sum += aux;

        cout << "Somatório: " << sum << endl;
        cout<<endl;
    }while(n);

    return 0;
}

Fatorial usando loopings em C++

Se o somatório soma todos os números de 1 até n, o fatorial multiplica todos os números de 1 até n.
O símbolo do fatorial de um número é !.

Por exemplo:
4! = 1 x 2 x 3 x 4 = 24
5! = 1 x 2 x 3 x 4 x 5 = 120

Em vez de sum vamos usar prod pra armazenar o produto.
E ao invés de somar (+=), vamos multiplicar ( *= ).

Usando laço FOR:

#include <iostream>

using namespace std;

int main()
{
    int n, aux, prod=1;

    cout << "Fatorial de: ";
    cin >> n;

    for(aux=1 ; aux<=n ; aux++)
        prod *= aux;

    cout << "Fatorial: " << prod << endl;

    return 0;
}

WHILE:

#include <iostream>
using namespace std;

int main()
{
    int n, aux=1, prod=1;

    cout << "Fatorial de: ";
    cin >> n;

    while(aux<=n){
        prod *= aux;
        aux++;
    }

    cout << "Fatorial: " << prod << endl;

    return 0;
}

DO WHILE:

#include <iostream>
using namespace std;

int main()
{
    int n, aux, prod;

    do{
        cout << "Fatorial de: ";
        cin >> n;
        prod = 1;

        for(aux=1 ; aux<=n ; aux++)
            prod *= aux;

        cout << "Fatorial: " << prod << endl;
        cout<<endl;
    }while(n);

    return 0;
}

Simples, né?