Comando do while

Como sempre, a primeira coisa que devemos fazer nesse tipo de exercício é definir o escopo do programa.

Com o escopo definido, nós podemos declarar as variáveis que serão úteis para o desenvolvimento e execução do programa.

Vale lembrar que utilizaremos um vetor de 15 posições denominado alturas para armazenar as respectivas 15 alturas que serão dadas como entrada.

Além disso, essas são algumas informações sobre as variáveis que serão utilizadas:

• menor armazenará o valor da menor altura digitada pelo usuário;
• maior armazenará o valor da maior altura digitada pelo usuário;
• i variável contadora das estruturas de repetição utilizadas pelo programa.

Nós também podemos utilizar o laço de repetição do while para realizar a requisição das 15 alturas esperadas para o usuário do programa.

Para que isso aconteça, utilizaremos a condição i menor que 15, uma vez que ela é inicializada com o valor 0 e incrementada a cada loop da estrutura de repetição.

Essa mesma estrutura de repetição será utilizada para a realização do cálculo de menor altura.

Onde a primeira coisa que devemos fazer é definir o valor 1 para a variável contadora i e supor que a menor altura é aquela que está na primeira posição do vetor alturas (atribuindo esse valor a variável menor).

Logo em seguida, efetivamente usaremos a estrutura do while para verificar se as posições seguintes do vetor (posteriores a posição 0) são menores que aquela definida como a menor, por esse motivo i assumiu o valor 1. Caso alguma delas seja, essa assumirá a sua posição na variável menor.

Vale ressaltar que a condição while para as instruções do é que a variável i seja menor que 15 (quantidade de alturas e posições no vetor), além disso a variável i é incrementada a cada loop da estrutura.

A lógico para encontrar a maior altura é muito parecido com aquela utilizada por nós no passo anterior.

A única diferença está presente apenas nas ações de verificação e atribuição do código anterior, que agora passam a ser de maior na variável maior, respectivamente.

Por fim, basta realizarmos a impressão dos resultados previamente calculados.

Essas impressões foram realizadas com duas casas decimais seguidas de uma quebra de linha cada.

Em primeiro lugar, precisamos definir o escopo do nosso programa.

Podemos agora declarar as variáveis que serão úteis para o desenvolvimento e execução do programa.

A seguir estão algumas informações sobre as variáveis utilizadas:

• soma será responsável por armazenar o valor da soma de todas as divisões até o limite estipulado pelo enunciado;
• i e j serão variáveis contadoras que desempenharão as funções de numerador e denominador nos cálculos, respectivamente. Além claro, de atuarem diretamente como condição de execução da estrutura de repetição utilizada.

Ao observar o padrão de soma das frações (numerador e denominador), podemos utilizar a estrutura de repetição do while para realizar o cálculo.

O padrão de atualização das variáveis contadoras i e j é que i recebe o seu valor mais 2 a cada loop, já j o incremento de uma unidade.

Além disso, a condição de execução utilizada é a diferença dos valores que as variáveis i e j possuirão após a soma do último valor desejado, ou seja, a estrutura realizará o cálculo até a última fração estipulada pelo enunciado e encerrará os seus loops.

Por fim, nós só precisamos realizar a impressão da soma realizada na tela.

Essa impressão será feita com duas casas decimais seguida de uma quebra de linha.

A primeira coisa que devemos fazer é definir o escopo do programa.

Com o escopo definido, nós podemos declarar as variáveis que serão úteis para o desenvolvimento e execução do programa.

Onde a variável numero armazenará o número inserido como entrada pelo usuário.

Por fim, podemos utilizar a estrutura de repetição do while para fazer as requisições de número enquanto o mesmo não atender a regra do intervalo previamente definido.

Em primeiro lugar, devemos definir o escopo do nosso programa.

Com o escopo definido, podemos realizar a declaração das variáveis necessárias.

Onde cada variável possui o seguinte significado:

• razao armazenará a constante da progressão aritmética (R);
• progArit armazenará o valor de impressão da P.A durante a execução do programa;
• i será a variável contadora da estrutura de repetição do programa.

Com as variáveis devidamente declaradas, podemos requisitar as informações de entrada do programa ao usuário.

Por fim, nós podemos utilizar a estrutura de repetição do while para realizar a impressão da progressão aritmética nos parâmetros definidos pelo usuário.

A lógica consiste em o valor da variável progArit (iniciada pelo usuário) ser impresso na tela e incrementado com o valor armazenado pela variável razao a cada loop.

Como a condição de execução da estrutura é i menor que 10, os primeiros 10 itens da P.A serão impressos na tela, pois i é incrementada em uma unidade a cada loop até a condição ser falsa.

Vale ressaltar que a impressão do número da P.A será realizada seguida de um espaço em branco.

A figura a seguir ilustra o algoritmo em C descrito no enunciado:

Onde basicamente uma estrutura de repetição do while é utilizada com a condição de execução menor que 2000. Cada loop dessa estrutura de repetição realiza uma verificação de igualdade por 5 do resto da divisão do atual valor processado pela variável contadora por 11, caso a verificação seja verdadeira esse número é impresso na tela.

Antes de tudo, vamos definir o escopo do nosso programa.

Com o escopo do programa definido, nós podemos declarar as variáveis que serão úteis.

Informações sobre as variáveis:

• n é uma variável responsável por armazenar o limite do intervalo;
• i é uma variável contadora responsável por gerenciar a estrutura de repetição principal do programa;
• j é uma variável contadora responsável por gerenciar a estrutura de repetição que verifica se um é primo;
• flag é uma variável representativa do tipo booleano responsável por armazenar se um número possui ou não mais que dois divisores.

Agora que já temos todas as informações das variáveis que utilizaremos, está na hora de requisitarmos a entrada do programa ao usuário.

Essa entrada é o número n que determina o fim do intervalo de comparações.

Entraremos agora na principal lógica de instruções do programa, ela constitui toda verificação se um número é ou não primo.

É sempre bom lembrar que essa estrutura de repetição não é a mais adequada para esse exercício, mas estamos utilizando-a principalmente para verificarmos que independente de qual utilizarmos conseguimos resolver problemas que envolvem repetições (mesmo que de uma forma mais longa).

Basicamente utilizaremos um laço de repetição do while controlado pela variável i (inicializada com o valor 2) que será incrementada até i ser igual a n – 1. Os resets feitos na linha 09 se referem a segunda estrutura do while, essa que é controlada pela variável contadora j e tem simplesmente a função de verificar se o número processado por i naquele momento possui ou não algum divisor que quebra a regra de número primo.

Com isso, para cada valor de i a variável j será reinicializada com o valor 2 e incrementada até atingir o valor i – 1 procurando divisores. Caso encontre, o número i não é primo e uma variável flag (também reinicializada na linha 09) recebe o valor 1.

Ao sair da segunda estrutura de repetição e retornar para a principal, uma verificação da variável flag é realizada. Se o valor dela for 0, quer dizer que nenhum outro divisor foi encontrado e se trata de um número primo que deve ser impresso.

Esse processo se repetirá exatamente da mesma forma até que o laço principal atinja a falha da condição de execução do laço do while.

Nós devemos começar o desenvolvimento desse programa através da definição de seu escopo.

Com o escopo do programa definido, podemos iniciar a declaração de variáveis que serão úteis.

Informações sobre as variáveis:

• a, b, c, d, nulo e branco são variáveis responsáveis por armazenar suas respectivas quantidades específicas de votos;
• confirma é uma variável responsável por armazenar o voto que está sendo processado pelo programa em determinado momento de execução;
• votos é uma variável responsável por armazenar a quantidade total de votos.

Como devemos computar mil votos, podemos uma utilizar uma estrutura de capaz de repetir o processamento de um voto mil vezes. Para esse programa, utilizaremos a estrutura do while.

A lógica desse bloco de instruções consiste em ler o voto de um cidadão (consequentemente usuário do programa) e utilizar a estrutura condicional switch case para incrementar a respectiva opção de voto escolhida por ele.

Além disso, independente do voto escolhido, a variável votos é incrementada em uma unidade. Controlando assim, a estrutura de repetição a atuar apenas para computar os mil votos, uma vez que a condição do laço de repetição é votos menor que 1000.

Ao término da estrutura de repetição nós já temos todas as informações necessária para a impressão dos cálculos computados na tela.

Total de votos para cada candidato e seu percentual sobre o total pode ser obtido através do seguinte trecho de código:

Que imprime todas as médias e seus respectivos percentuais através da divisão da quantidade de votos específicos de cada opção pelo total de votos.

Observe que uma conversão de tipo de int para float foi necessária em todas essas divisões, pois sem ela o programa retornaria a divisão inteira dos valores, que por se tratar de porcentagens seriam apenas 0 (desconsiderando a parte real).

O total de votos nulos e o seu percentual sobre o total pode ser obtido através do seguinte trecho de código:

Consiste em dividir a variável nulo da mesma forma como foi feita a divisão das variáveis de quantidade específica de votos.

Por fim, o total de votos em branco e o seu percentual sobre o total pode ser obtido através do seguinte trecho de código:

E da mesma forma que fizemos nos passos anteriores, devemos dividir o valor presente no conteúdo da variável branco pelo conteúdo da variável total. A explicação disso é idem aos passos anteriores.

A primeira coisa que devemos fazer é definir o escopo do programa.

Com o escopo do programa definido, nós podemos realizar a declaração e inicialização das variáveis necessárias.

Informações sobre as variáveis:

• Saldo é a variável responsável por armazenar o saldo atualizado do cliente (usuário do programa);
• valorProcessado é a variável que armazena temporariamente o valor que será inserido ou removido nas operações de depósito e saque, respectivamente.
• opcao é a variável responsável por armazenar o número de uma das opções disponíveis do programa que, consequentemente, será executada em seguida.

Com as variáveis declaradas e já inicializadas, podemos definir a estrutura principal do programa, um laço de repetição do-while.

A lógica consiste em ler as opções inseridas pelo usuário enquanto elas forem diferentes de 4 (opção sair).

Além disso, para controlar o fluxo do programa e garantir a execução das operações, devemos utilizar uma estrutura condicional.

Nesse caso, utilizaremos a estrutura switch case com 4 casos:

Esses casos são responsáveis por representar as opções de seleção do programa. Vamos agora declarar as instruções de cada um deles, iniciando pela opção consulta:

Que simplesmente imprime na tela o valor armazenado pela variável saldo com duas casas decimais seguida de uma quebra de linha.

O segundo caso se refere a opção saque:

Que basicamente deve ler o valor a ser sacado e em seguida descontar do saldo. Algo parecido ocorre na operação seguinte, que é débito:

A única diferença é que o valor presente saldo sofrerá uma adição do valor lido.

Por fim nós temos os casos 4 e default que permanecerão da forma como foram apresentados originalmente. Isso acontece, pois quando o caso 4 for verdadeiro a única instrução que deve ser executada é o break já que a condição do laço de repetição será automaticamente falsa nesse caso. Da mesma forma com que o caso default deve apenas imprimir que a opção é inválida.

Ao término da estrutura de repetição, realizaremos uma impressão na tela dizendo que o programa está sendo finalizado antes dele ser encerrado.