Estruturas de Repetição: while e do-while

Vamos lá pessoal.

A questão quer que a gente faça um loop que imprima todos os números desde de até o número que o usuário digitar. Quando a gente tem que executar uma tarefa repetidas vezes, até um determinado ponto de parada, o comando é a nossa saída.

Mas, como sempre, vamos começar declarando as nossas variáveis! E aqui vamos precisar de duas variáveis:

• O número que o usuário digitar vai ser armazenada na variável inteira .
• E vamos precisar de uma variável pra controlar o nosso loop. Vamos chama-la de . Essa variável vai mudar de valor a cada “volta” no nosso loop e vai ajudar a gente a definir quando o cálculo tem que parar. Como o início da contagem é o número zero, vamos inicializar a variável com o valor .

Agora vamos receber o valor do usuário. Pra isso vamos usar os comandos e

Certo, vamos pro passo principal agora!

A gente precisa de um comando que inicie em zero, e avance um passo por vez até atingir o valor digitado pelo usuário. Em outras palavras, enquanto a variável for menor ou igual ao valor digitado pelo usuário, o laço deve ser ativo.

E dentro do laço vamos imprimir o valor atual de , e em seguida vamos incrementar o valor de

Essa variável auxiliar é super importante! Ela serve pra determinar o critério de parada, ou seja, até quando o laço deve ser ativo (no caso, enquanto ).

E a variável também serve pra imprimir na tela os valores de 0 até o número inserido pelo usuário, já que seu valor é incrementado em 1 a cada volta no loop. Essa variável vai assumindo valores diferentes a cada iteração. Então ao mesmo tempo que ela serve pra controlar o nosso loop, ela também serve pra imprimir o que precisamos.

E é isso! Programa pronto.

Nesse exercício vamos criar a tabuada de um número qualquer que o usuário inserir. Então vamos criar uma variável inteira chamada

A maneira mais fácil de construir uma tabuada é usando uma estrutura de repetição. Então vamos criar uma variável inteira que usaremos nas iterações do nosso laço. Uma tabuada começa no valor , então vamos inicializar o com esse valor.

Antes de escrever o laço precisamos receber o número do usuário. Usamos o para pedir o número e com o armazenamos o valor na variável correta.

Agora vamos construir o laço.

A nossa variável de iteração deve iniciar no valor e ir aumentando gradualmente até chegar em 10. Podemos expressar isso da seguinte forma:

Esta é a expressão no nosso laço!

Dentro das chaves vamos usar o para imprimir a tabuada. Usando o mesmo podemos imprimir o valor contido na variável , depois o caractere para denotar a multiplicação, em seguida imprimimos a variável que contém o valor inserido pelo usuário, e por fim imprimimos o resultado do produto .

Agora, vamos adicionar o incremento do nosso loop. A cada rodada o valor de deve aumentar uma unidade. Então podemos usar o operador de incremento ().

Graças ao incremento na linha 16 a cada iteração o valor de vai aumentar, e os valores que são impressos na linha 14 vão ser modificados, e após 10 iterações, a condição da linha 12 se torna falsa, e o laço é finalizado.

E é isso, pessoal! Questão pronta!

Lets go, pessoal!

A questão quer que a gente calcule a média entre duas notas, vamos resolver isso usando nossos conhecimentos de expressões matemáticas para calcular a média. A questão também diz pra gente possibilitar o cálculo de várias médias, e uma forma de solucionar isso é usando uma estrutura de repetição

Então, antes de mais nada, então vamos de cara criar três variáveis do tipo chamadas , e

Já sabemos que vamos ter que utilizar um loop, mas como devemos garantir que o código seja executado ao menos uma vez, a melhor escolha é usar o laço .

Uma forma de fazer a expressão de teste do nosso laço é criar uma variável lógica com valor . Vamos chamar essa variável de

E enquanto o valor da variável tiver valor igual a o laço deve continuar ativo.

Agora vamos construir o código interno do laço.

Primeiro, vamos pedir o valor das notas. Usando o informamos o usuário qual nota deve ser inserida, e com o armazenamos na variável correta.

Em seguida, vamos calcular a média do aluno e imprimir o valor na tela:

E pra finalizar vamos perguntar se o usuário deseja continuar. Utilizando o comando armazenamos o valor digitado na variável . Se ele digitar o valor lógico equivalente é e o laço faz uma nova iteração. Se ele digitar o valor lógico equivalente é e o laço será finalizado.

Oi pessoal, vamos lá resolver essa questão.

Vamos começar relembrando que um número primo é qualquer número inteiro e positivo que só seja divisível por 1 e por ele mesmo.

O programa que vamos criar vai usar o operador de resto da divisão (). Se o resto da divisão de um número por outro for igual a zero, então esses números são divisíveis entre si. Por exemplo: pois é divisível por . Por outro lado, pois não é divisível por .

Pra descobrir se um número é primo, temos que tentar dividi-lo por todos os números menores do que ele. Se houver algum caso em que o resto da divisão seja zero, então o número não é primo.

Vamos começar declarando as variáveis. Vamos precisar de uma variável para conter o número inteiro digitado pelo usuário, chamada . Uma outra variável inteira chamada será a variável usada no nosso laço.

Também vamos criar uma variável lógica chamada que será inicializada com o valor . Dessa forma, todo número é considerado primo até que se prove o contrário!

Então, vamos declarar essas variáveis no código:

Antes de escrever o laço precisamos receber o número do usuário. Usamos o para pedir o número e com o armazenamos o valor na variável correta.

Agora vamos usar um laço para testar se o número é ou não primo.

Pra começar, vamos inicializar a variável . Por definição, já sabemos que os números primos são divisíveis por um, então não faz sentido testar a divisão por 1, por isso vamos começar os testes partindo do . Da mesma forma, não faz sentido testar se o número é divisível por ele mesmo. Então, a expressão de teste do nosso laço vai ser:

Pra testar se o número é primo vamos usar uma condição . Se o for divisível por então ele não é primo, e o valor lógico da variável deve ser mudado para .

E no final de cada iteração, a variável deve ser incrementada para que possamos testar o próximo número.

O nosso laço está finalizado!

Agora vamos usar uma estrutura para imprimir uma mensagem adequada.

Se o número for primo vamos imprimir uma mensagem dizendo “eh primo”. E caso não seja, devemos imprimir uma mensagem dizendo “não eh primo”

E é isso! Programa concluído.

Essa questão vai ser grande. Mas não se preocupa que a gente vai resolver passo a passo.

Primeiro, ele quer que a gente crie uma calculadora, que é uma espécie de menu de opções de contas, e a gente já viu que a melhor forma de fazer esse tipo de coisa é usando a estrutura de seleção

Mas o enunciado diz que, quando terminar uma operação, o programa pergunta qual a próxima operação, ou seja, essa calculadora vai ser repetida até que uma tecla de finalização seja pressionada. Por isso vamos colocar o código da calculadora dentro do laço pra garantir que a calculadora seja executada várias vezes.

Então vamos começar a codar.

Bem, se isso é uma calculadora que aplica uma operação simples a 2 números, então precisaremos receber esses dois números reais e guardar um resultado. Então criamos três variáveis do tipo chamadas , , .

Também vamos dar ao usuário o poder de escolher qual operação ele quer fazer, então vamos criar uma outra variável chamada do tipo . A função dessa variável é receber a escolha de operação do usuário.

Agora vamos iniciar nosso loop. E pra que vamos usar um loop? Porque o usuário pode fazer quantas contas ele quiser e podem ser muitas. Então se a gente colocar a calculadora dentro de um loop, cada conta que o usuário quiser fazer vai ser uma iteração (uma “volta”) nesse loop. Sacou? Então vamos ao loop!

A expressão de teste mais simples possível pra um loop é usar uma variável lógica. Quando essa variável for verdadeira o loop continua. Quando for falsa o loop é quebrado.

Então, primeiro vamos criar uma variável chamada do tipo inicializada com o valor lógico

E vamos colocar a seguinte expressão no nosso laço: enquanto a variável for verdadeira o loop vai estar ativo!

Pra fazer isso, a gente coloca o no começo e abre a chave, pra escrever nosso programa. E o fica lá no final com a nossa condição de parada.

Pronto! Agora tenha atenção. Quase tudo que vamos escrever depois vai ser feito dentro desse loop

Agora nós precisamos perguntar ao usuário os valores das variáveis , e ! Mas note que a cada conta que o usuário quiser fazer, a gente vai ter que receber novos valores e vamos usar uma nova operação. Cada conta vai ser uma iteração do loop. Então vamos colocar o código de receber dados dentro do loop!

Usando vamos informar o usuário sobre como usar o programa. Informamos que ele precisa digitar se quiser sair e, com o comando da linha 12, a gente diz pra eles as opções de operação que ele tem. Por fim, com o comando vamos receber essa operação e em seguida receberemos cada um dos números.

Agora vamos construir a calculadora utilizando o comando . A expressão de teste do comando será o valor da variável , pois o que vamos fazer depende da operação escolhida pelo usuário.

Vamos observar o primeiro caso. Caso o usuário pressione ‘’, os dois números serão adicionados e o resultado impresso na tela.

Seguindo esta lógica vamos fazer o mesmo para as outras três operações:

Também temos que adicionar um botão de finalização do programa. Vamos usar a letra “S” de “Sair”, porque lá na linha 11, a gente informou pro usuário que ele tinha que digitar , caso quisesse sair. Então se o usuário pressionar ‘’ o programa vai entrar nesse quinto e será finalizado.

Pra interromper o loop, o valor da variável deve mudar para (linha 44). Vamos aproveitar pra usar o para enviar uma mensagem de finalização pro usuário.

Ou seja, temos esses 5 , um pra cada opção de operação e mais 1 pra opção de sair do programa. E, a cada volta, o programa só pode entrar em 1 delas, dependendo do valor da variável .

E vamos adicionar também um comando pro caso do usuário inserir uma opção inválida. Imagina se ele digita ou qualquer outra coisa inválida na hora da operação. Daí o programa imprime na tela “Comando invalido”.

E com isso finalizamos o programa.

E aí pessoal. Vamos resolver esse exercício!

Talvez a sequência do enunciado possa parecer um pouco aleatória. Mas na verdade é a famosa Sequência de Fibonacci, que é muito usada nos estudos de biologia e física.

Essa sequencia sempre começa com dois números pré-definidos, e daí pra frente os números seguintes é formado pela soma dos dois anteriores:

Para resolver essa sequência a gente pode utilizar um loop para calcular cada valor da sequência.

Se a gente vai usar um loop a gente vai precisar de pelo menos uma variável inteira para contar as iterações, vamos chamar de . Também vamos precisar receber do usuário a quantidade de iterações que ele deseja, então precisamos de uma variável inteira .

Mas aí tem um problema, se você ainda não sabe quantos termos vai ter a sequência de Fibonacci, então como você vai saber quantas variáveis vai precisar? Isso tem solução, acompanha comigo.

Para calcular um termo da sequencia você só precisa saber os dois termos anteriores. Então o que vamos fazer é, vamos calcular o termo da sequência, e imprimir o valor de na mesma hora. E antes de terminar a iteração a gente vai modificar o valor contido em e , para preparar para a próxima iteração:

Vamos por a mão na massa. Pra começar vamos declarar as variáveis que vamos precisar.

Inicializamos pois essa é a variável de iteração, e o primeiro termo da sequência ocorre quando . E as variáveis e são iniciadas desta forma pois representam os primeiros termos da sequência Fibonacci. E a variável será usada para calcular cada termo novo da sequência.

No passo seguinte, vamos usar o para pedir um número pro usuário, e com vamos armazenar o valor na variável

Show! Agora vamos pra parte massa da questão.

Primeiro de tudo, vamos iniciar o nosso loop. Ele vai durar enquanto a variável de iteração for menor que a quantidade de termos

A primeira coisa interessante pra notar é que no começo a nossa sequencia tem valores fixos. Quero dizer que, os dois primeiros termos da sequencia sempre são iguais a 1. Podemos usar uma estrutura para resolver isso:

• SE OU ENTÃO imprima 1.
• CASO CONTRÁRIO: calcule e imprima o próximo termo da sequencia

A primeira parte da condição fica assim. Note que devemos colocar um espaço em branco após o número. Isso vai evitar que o número seguinte fique colado no anterior.

Agora vamos considerar o caso em que precisaremos calcular a sequência. Abrimos dentro do comando adicionamos a expressão que calcula a sequência:

Em seguida a gente vai utilizar o comando para imprimir o conteúdo recém calculado.

E depois temos que atualizar as variáveis da sequência. Para calcular o próximo termo da sequência, o valor atual de passa para a variável , e o valor contido em passa para a variável Isso é necessário para preparar os as variáveis para a próxima iteração do laço!

E antes de concluir o loop a gente não pode esquecer de atualizar a variável de iteração :

E prontinho! Finalizamos mais uma questão.

Sigam-me os bons!

De cara, da pra ver que nessa questão vamos precisar de matemática. Então já vamos começar inserindo o cabeçalho

Belezinha. Vamos então analisar a questão. O usuário vai informar o número desta série:

Para imprimir uma quantidade desconhecida de termos a gente pode usar um loop de iteração. Nesse caso vamos usar o loop .

Vamos dar uma olhada no exemplo de saída que a questão traz. A gente pode pensar que essa saída pode ser dividida em três partes:

Imagine se a gente tivesse uma grande quantidade de números:

Note que as partes circuladas em azul são sempre um número seguido de um sinal de adição. Já as partes circuladas de verde, o início e fim da expressão, não são escritos de forma repetitiva.

Isso indica pra gente que as partes em verdes a gente vai escrever direto no código. E pra parte em azul a gente vai utilizar um loop

Mas antes, vamos pensar quais variáveis serão necessárias.

Se vamos usar um loop então precisaremos de uma variável inteira de iteração, que vou chamar de . Também vamos precisar de uma variável inteira que indica a quantidade de termos da sequência. Note que esses valores serão sempre positivos, então podem ser do tipo .

Para executar a série vamos precisar do valor de , que será dado pelo usuário. E também vamos precisar de uma variável para guardar o valor do somatório, chamada . Essas duas variáveis podem assumir quaisquer valores reais, e por isso devem ser do tipo .

Vamos inicializar todas as variáveis com valor .

Já vamos aproveitar para receber os valores do usuário. Usando e iremos receber as variáveis e

Agora vamos dar vida a nossa série de potência.

Como vimos, a primeira parte dessa série não é uma estrutura repetível, então vamos escrever diretamente a frase: e imprimir o valor de :

Agora vamos entrar no nosso laço. A estrutura vai começar com (que inicializamos no momento que criamos a variável), e vai durar enquanto for menor do que :

Dentro do laço vamos efetuar três atividades.

A primeira é calcular a soma dos termos. Pra isso a gente considera o valor já existente da variável soma e adiciona o termo .

A segunda atividade é imprimir o valor atual da série. Ou seja, vamos imprimir o valor de . Não é necessário usar o pois queremos que tudo seja impresso em uma única linha.

E a terceira atividade antes de fechar o laço é atualizar a variável de iteração .

O loop está concluindo, mas lembre-se, o nosso loop foi só até , ou seja, ainda falta somar no momento que .

E por fim, precisamos adicionar a exibição da última parcela da série, e o resultado final.

E pronto. Questão finalizada!

Vamos lá galera.

Pra resolver essa questão vamos precisar de um loop que fique recebendo uma quantidade indefinida de valores.

Bem, é claro que não vamos criar infinitas variáveis. O que vamos fazer um laço em que uma variável recebe o número, e o valor recebido é adicionado a uma variável que guarda todas as somas. No loop seguinte, a variável vai receber um novo valor, e a variável soma será atualizada mais uma vez.

Mas como saberemos a quantidade de vezes que vamos executar o loop? Simples, é só a gente perguntar pro usuário o número de valores que quer inserir.

Depois é só dividir o valor da pelo valor de e termos a .

Então vamos declarar essas variáveis. E também vamos declarar uma variável de iteração que começa em zero.

Agora precisamos saber quantas vezes o laço será repetido. Então vamos perguntar pro usuário quantos valores ele quer inserir.

Usando o vamos solicitar o valor e com o vamos atribuir o valor inserido a variável

Agora vamos desenvolver o nosso laço. Vamos utilizar um que começa quando e deve continuar enquanto for menor que . Assim conseguiremos adicionar todos os números necessários

Primeira atividade do laço vai ser receber um valor do usuário e atribuir este valor à variável

A segunda atividade do laço vai ser atualizar a soma. Vamos pegar o valor atual contido em e adicionar o valor da variável .

E a última atividade dentro do laço é atualizar a variável de iteração.

Prontinho. Com isso temos a soma de todos os valores.

Agora é só a gente calcular a média. Nós já temos a soma, e temos a quantidade de valores. Então é só dividir:

E pra finalizar a questão, vamos imprimir o resultado utilizando o .