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

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.

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é?

Tabuada com laços em C++

Vamos resolver o exercício da lista de estruturas de repetição:

• Faça um programa em C++ que peça um inteiro ao usuário, e exiba sua tabuada.

Tabuada em C++ com FOR

Primeiro, pedimos ao usuário um número e armazenamos na variável num.
Vamos usar também uma variável de controle aux.

Essa variável, dentro do laço FOR, vai de 1 até 10, pra montarmos a tabuada.
Em seguida, é só multiplicar num por aux, em cada iteração e exibir o resultado.

Veja como ficou nosso código:

#include <iostream>

using namespace std;

int main()
{
    int num, aux;

    cout << "Tabuada do numero: ";
    cin >> num;

    for(aux=1 ; aux<=10 ; aux++)
        cout<<num<<" * "<<aux<<" = " << num*aux <<endl;

    return 0;
}

Tabuada em C++ com WHILE e DO WHILE

Também é possível fazer o mesmo com o looping WHILE, veja:

#include <iostream>

using namespace std;

int main()
{
    int num, aux=1;

    cout << "Tabuada do numero: ";
    cin >> num;

    while(aux<=10){
        cout<<num<<" * "<<aux<<" = " << num*aux <<endl;
        aux++;
    }

    return 0;
}

Note que temos que inicializar antes a variável aux e incrementar ela dentro do WHILE, igual como fazemos no cabeçalho da estrutura FOR.

Podemos também incrementar nosso código e usar do while, para ficar exibindo quantas tabuadas o usuário quiser, só para quando ele digitar 0:

#include <iostream>

using namespace std;

int main()
{
    int num, aux;

    do{
        cout << "Tabuada do numero: ";
        cin >> num;

        for(aux=1; aux<=10 ; aux++)
            cout<<num<<" * "<<aux<<" = " << num*aux <<endl;
        cout<<endl;
    }while(num);

    return 0;
}

Estrutura de Repetição FOR - Laço controlado em C++

Finalizando a apresentação das estruturas de repetição de nosso Curso de C++, vamos apresentar o laço FOR, o looping controlado.

Estrutura de repetição FOR em C++

A instrução de repetição FOR tem a seguinte sintaxe:

for(inicialização ; teste_condicional ; atualização){
   // código que executa enquanto
   // o teste condicional
   // for verdadeiro
}

Vamos lá.
A estrutura de repetição FOR tem três expressões dentro dela, separadas por ponto e vírgula.

O laço começa com algum tipo de inicialização, geralmente uma variável de contagem, com algum valor inicial.

Após essa inicialização, ocorre o teste condicional. Se for verdadeiro, o código dentro das chaves do laço FOR é executado.

Após cada iteração, ocorre a 'atualização', onde geralmente atualizamos o valor do contador, muito comumente é uma variável que vai se incrementar ou decrementar.

Então, novamente o teste condicional é realizado, em caso de ser verdadeiro, novamente o código do FOR é executado. Após essa iteração, ocorre mais uma vez a atualização.

Exemplo de uso do laço FOR

Em programação, um exemplo vale mais que mil palavras.
Vamos contar de 1 até 10, usando o laço for, o código é o seguinte:

#include <iostream>
using namespace std;

int main()
{
    int count;

    for(count=1; count<=10 ; count++){
        cout << count << endl;
    }

    return 0;
}

A nossa variável de controle é a count, que vai iniciar valendo 1.
Vamos printar ela na tela enquanto seu valor for menor ou igual a 10.
A cada iteração, incrementamos ela em uma unidade (count++), pois queremos que ela vá de 1 até 10.

Note que já fazíamos isso no laço WHILE, mas inicializávamos as variáveis antes do laço, dentro dele a gente atualizava a variável a cada loop e ocorria o teste condicional dentro dos parêntesis do WHILE.

Ocorre a mesma maneira no laço FOR, mas de maneira mais organizado.

Como usar a estrutura de repetição FOR

Vamos fazer o contrário agora, uma contagem regressiva, que conta de 100 até 1.
Para isso, inicializamos nossa variável de controle como 100.

O teste a ser realizado é: count > 0
Ou seja, enquanto a variável tiver um valor acima de 0, as iterações do laço FOR vão ocorrer.

E a cada iteração temos que decrementar o count, pois ele vai de 100 pra 1, de um em um.
Veja como ficou nosso código:

#include <iostream>
using namespace std;

int main()
{
    int count;

    for(count=100; count>0 ; count--){
        cout << count << endl;
    }

    return 0;
}

Nem sempre, porém, vamos incrementar ou decrementar de 1 em 1.
Podemos atualizar nossas variáveis da maneira que quisermos.

Por exemplo, vamos imprimir na tela todos os números pares de 1 até mil.
O primeiro par é o 2, então inicializamos nossa variável com esse valor.
Vamos incrementar de 2 em 2: count += 2
E o teste é enquanto a variável for menor ou igual a mil: count <= 1000

#include <iostream>
using namespace std;

int main()
{
    int count;

    for(count=2; count<=1000 ; count+=2){
        cout << count << endl;
    }

    return 0;
}

Veja a incrível velocidade com que esse código é executado.
Duvida da capacidade do C++? Coloque 1 milhão.

Quando usar o laço FOR

Muitas vezes, queremos fazer loopings com determinado número de iterações.
Por exemplo, ao pedir as notas de um aluno, vamos pedir o tanto de matérias que existem, para calcular a média.

Para calcular seu imposto de renda, precisamos somar todo seu salário do ano, ou seja, 13 salários (tem o décimo terceiro).

O laço FOR é ideal quando você sabe exatamente o número de iterações que vai fazer: "ah, quero calcular isso nesse intervalo de x até y", então pimba, use a estrutura de repetição FOR.

Quando não sabe quando o looping deve terminar ou tem menos controle sobre quantas iterações devem ocorrer, aí use o laço WHILE.

Lembrando que, no fundo, eles são absolutamente a mesma coisa.
Só vai ser mais fácil trabalhar com FOR algumas vezes e com WHILE em outras ocasiões.

Estrutura de Repetição FOR

Crie um programa que pede quantas notas você quer calcular a média, em seguida pede cada uma dessas notas e por fim exibe a média.

Vamos armazenar o número de notas que vamos pedir na variável n.
O próximo passo é pedir nota por nota, e aqui vem o pulo do gato: calcular a soma de todas as notas.

Dentro do FOR, a variável de controle aux vai da nota 1 até a nota n, pedindo uma por uma e armazenando essa nota na variável grade.

Vamos armazenar na variável sum, a soma de todas essas notas.

Por fim, exibimos sum/n para exibir a média.
Veja nosso código C++:

#include <iostream>
using namespace std;

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

    cout <<"Quantas matérias: ";
    cin >> n;

    for(aux=1; aux<=n ; aux++){
        cout <<"Nota "<<aux<<": ";
        cin >> grade;
        sum += grade;
    }

    cout << "Média: "<<(sum/n)<<endl;

    return 0;
}

Note como essa estrutura de repetição é controlada: ela vai sempre rodar 'n' iterações, seja lá qual o valor de 'n' (obviamente, o número de notas deve ser um valor inteiro positivo).

Pode preencher com 2 notas, 3 notas, mil notas, um milhão de notas...
Poderoso, esse laço FOR não é?