Comando for em C

A primeira coisa que devemos fazer para resolver esse exercício é definir o escopo do nosso programa em C.

Com o escopo definido, nós agora podemos realizar a declaração das variáveis e constantes que serão úteis para o desenvolvimento e execução do programa.

Informações sobre as variáveis e constantes:

• K é uma constante que armazenará o valor da divisão entre 5 e 9;
• c é uma variável que armazenará o resultado da conversão de um valor na unidade Fahrenheit para a unidade Celsius;
• limInf é uma variável inicializada com o valor 10 (limite inferior que o enunciado pede para ser considerado em todas as execuções do programa);
• limSup é uma variável que armazenará o limite superior do intervalo;
• inc é uma variável que armazenará o valor de incremento das conversões a serem realizadas dentro do intervalo;
• i variável contadora de um laço de repetição do programa.

Com as variáveis e constantes declaradas e inicializadas, podemos requisitar os dados de entrada do programa ao usuário.

Nesse caso, os dados de entrada inseridos pelo usuário são: limite superior e o valor de incremento das conversões a serem realizadas.

Por fim, nós podemos utilizar a estrutura de repetição for para realizar as conversões e impressões de valores até o limite superior do intervalo.

A lógica consiste em atribuir como valor inicial da variável contadora no laço for o valor armazenado pela variável limInf (limite inferior). Como condição de execução temos que i deve ser menor ou igual ao valor armazenado pela variável limSup (limite superior). Ainda nos referindo aos parâmetros da estrutura de repetição, temos que definir o incremento da variável contadora a partir da soma de seu valor atual com o valor armazenado pela variável inc (incremento).

Com todos os parâmetros da estrutura de repetição for definidos, basta termos como instruções da estrutura a conversão para Celsius dos valores assumidos por i (assume-se que estes estão em Fahrenheit) a cada loop atribuídos a c, seguida da impressão da impressão dessa operação.

Vale lembrar que essa impressão possui 2 casas decimais para os valores em Celsius seguida de uma quebra de linha.

Para iniciarmos o desenvolvimento desse algoritmo em C, devemos primeiramente definir o escopo dele.

Com o escopo definido, podemos realizar a declaração e inicialização das variáveis e constantes que serão úteis para o desenvolvimento e execução do programa.

Informações sobre as variáveis e a constante serão descritas a seguir:

• TAXA é uma constante que armazenará a taxa de rentabilidade de 0,5 % ao mês;
• montante é uma variável que armazenará o valor acumulado;
• valInicial é uma variável que armazenará o valor inicial aplicado;
• aporteMensal é uma variável que armazenará o valor dos aportes mensais;
• i é uma variável contadora.

Com as variáveis declaradas e inicializadas, bem como todas as constantes definidas. Podemos requisitar a entrada de dados ao usuário do programa.

Nesse caso, os valores de entrada são: o valor inicial da aplicação e o valor dos aportes mensais.

Nós podemos utilizar uma estrutura de repetição for para a realização da simulação da aplicação através da repetição de instruções de soma e multiplicação.

A lógica consiste em antes de definir a estrutura, atribuir o valor presente em valInicial (valor inicial da aplicação) a variável montante.

Logo em seguida, realizar a definição do laço de repetição for com os seguintes parâmetros:

• i deve ser iniciado com o valor 0;
• O laço deve ser executado enquanto i for menor que 12 (12 loops);
• A cada loop o valor de i deve ser incrementado em 1 unidade.

Com a estrutura definida, as instruções que serão repetidas consistem em acrescentar o valor da rentabilidade de 0,5 % ao mês ao montante (linha 13), tal operação ocorre através da multiplicação do atual valor de montante por 1,005 %. Em seguida, o aporte mensal é acrescentado ao valor de montante (linha 14), isso ocorre através da soma do valor atual presente em montante com o valor presente na variável aporteMensal.

Vale lembrar que implicitamente a cada loop o valor presente na variável contadora i é incrementado em uma unidade.

Ao fim da execução do laço de repetição, basta realizarmos a impressão do valor final da aplicação em reais, tal valor está presente na variável montante.

A impressão foi realizada com 2 casas decimais seguida de uma quebra de linha.

Para criarmos esse algoritmo em C, a primeira coisa que nós devemos fazer é definir o escopo do programa.

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

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

• n é uma variável que armazenará o último número que deverá ser somado (limite);
• acumulado é uma variável que armazenará a soma de todos os elementos até n;
• i é uma variável contadora.

Com as variáveis devidamente declaradas e inicializadas, podemos requisitar a entrada de dados ao usuário do programa.

Nesse exemplo, o dado de entrada é um número limite de acumulação n.

Tendo conhecimento do último número a ser soma, podemos utilizar uma estrutura de repetição for.

A definição do laço de repetição for deve ser realizada com os seguintes parâmetros:

• i deve ser iniciado com o valor 1;
• O laço deve ser executado enquanto i for menor que n (n loops);
• A cada loop o valor de i deve ser incrementado em 1 unidade.

Com a estrutura definida, uma atribuição a variável acumulado deve ser realizada a cada loop do laço de repetição. Essa atribuição consiste em somar o valor atual presente em acumulado com o atual valor da variável contadora i (linha 10).

Ao término do laço de repetição, basta realizarmos a impressão do valor presente na variável acumulado, uma vez que ela possuirá a soma de todos os elementos de 1 até n.

Essa impressão está acompanhada de uma quebra de linha.

Como sempre, precisamos definir o escopo do nosso programa.

Com o escopo do programa definido, nós podemos declarar e inicializar as variáveis necessárias.

Informações sobre as variáveis:

• potencia armazenará o resultado da potenciação;
• x armazenará o valor da base da potência inserida pelo usuário;
• y armazenará o valor do expoente da potência inserida pelo usuário;
• i é uma variável contadora.

Com as variáveis devidamente declaradas e inicializadas, nós podemos requisitar os dados de entrada do programa ao usuário.

Nesse caso, os dados de entrada são: a base e o expoente da potenciação.

Para calcular a potência com as informações inseridas pelo usuário, nós podemos utilizar uma estrutura de repetição for para a execução das consecutivas multiplicações.

A definição dessa estrutura deve ser realizada com os seguintes parâmetros:

• i deve ser iniciado com o valor 0;
• O laço deve ser executado enquanto i for menor que y;
• A cada loop o valor de i deve ser incrementado em 1 unidade.

Ao término do laço de repetição, basta imprimirmos o valor armazenado pela variável potencia.

Essa impressão por sua vez será acompanhada de uma quebra de linha.

Para construirmos esse algoritmo em C precisamos definir o seu escopo de atuação.

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

A seguir estão algumas informações sobre elas:

• n armazenará o valor da posição de um determinado elemento da série;
• i será uma variável contadora;
• x e y serão responsáveis por armazenar os termos e de todo o processo até o elemento desejado da série, considere o termo atualmente processado pelo programa;
• fibonacci (equivalente a ) armazenará a soma entre e de todo o processo até armazenar o valor de através da soma de e .

Com todas as variáveis declaradas e devidamente inicializadas, nós podemos requisitar a entrada do programa ao usuário.

Nesse caso, a entrada do programa será a posição n da série de Fibonacci.

Para realizar o cálculo da sequência, nós podemos utilizar uma estrutura de repetição for com o processamento consecutivo das operações até a obtenção do valor desejado.

Sendo que a definição dessa estrutura deve ser feita com os seguintes parâmetros:

• i é atribuída com o valor 2 (excluindo os 2 primeiros termos da série que já são conhecidos);
• A condição de execução da estrutura é i menor que n;
• Com o incremento da variável contadora i em uma unidade a cada loop.

A lógica por traz desse laço de repetição está em somar os dois termos anteriores e atribuí-los a variável fibonacci atualizando os mesmos até obtermos o valor de .

Para entendermos melhor o que acontece, considere k o atual termo em processamento pelo laço de repetição. Dessa forma, a cada loop temos a seguinte operação (linha 09), mas como queremos , enquanto os termos que representam os elementos anteriores ao atual devem ser atualizados. Ou seja, se torna (linha 10) e se torna (linha 11) até o momento que obtivermos o elemento da série.

Depois disso tudo, basta imprimirmos o valor presente na variável fibonacci, uma vez que ao término do laço de repetição ela armazenará o elemento da série.

Vale ressaltar que essa impressão será seguida de uma quebra de linha.

A figura a seguir ilustra a definição da estrutura de repetição for na linguagem C explicitando através de comentários como os parâmetros são reservados e dispostos para cada ação:

Vamos iniciar o desenvolvimento do programa definindo o seu escopo.

Agora vamos para a etapa de declaração e inicialização de variáveis.

Informações sobre as variáveis:

• n é uma variável que será responsável por armazenar o número inserido como entrada do programa;
• i é uma variável contadora;
• somaDivisores é uma variável que armazenará a soma de todos os divisores do número n inserido;
• marcador é uma variável booleana representativa que informará se o número n inserido é ou não perfeito.

Tendo em mãos as variáveis do programa, nós podemos requisitar a entrada do programa ao usuário.

Essa entrada nada mais é que o número n.

Após a instrução de leitura do número n que será inserido, nós podemos definir uma estrutura de repetição for para verificar a igualdade da soma dos divisores de n.

Vamos começar definindo os parâmetros da estrutura for. A variável contadora i deve ser inicializada com o valor 1, pois ela terá o papel de contar os divisores e divisões por 0 são indeterminadas. A condição de execução desse laço de repetição deve ser i menor que n. Além disso, a regra de incremento da variável contadora i deve ser de uma unidade por loop.

Basicamente, ao definirmos esses parâmetros estamos criando uma estrutura de repetição que começará em 1 e, com somas de 1 unidade por loop, irá repetir instruções até que esse valor seja igual a n – 1.

Em relação as instruções dentro do laço de repetição, temos um condicional que verificará se a divisão de n pelo número de i sendo processado é igual a 0 (verificação de divisor). Caso seja, a variável somaDivisores deve ser incrementada com o valor de i e uma nova verificação deve ser feita: se somaDivisores é igual a n. Caso verdadeiro marcador deve ser atribuída com 1 e break deve ser utilizado para encerrar os loops, pois o número é perfeito.

Por fim, basta verificarmos o valor armazenado na variável marcador para sabermos se o número é ou não perfeito.

Caso seja igual a 1, devemos imprimir que o número é perfeito. Caso contrário, se marcador ainda possuir o seu valor de inicialização (0), devemos imprimir que o número não é perfeito.

Como sempre, vamos começar definindo o escopo do nosso programa.

É claro que com o escopo definido, nós podemos também declarar e inicializar as variáveis que serão úteis.

Informações sobre as variáveis:

• n é uma variável que será responsável por armazenar o número de elementos da lista;
• i é uma variável contadora;
• menor é uma variável que será responsável por armazenar o menor elemento da lista;
• aux é uma variável que armazenará temporariamente os novos elementos lidos para realizar a comparação de menor.

Com as variáveis declarada e inicializadas, nós podemos requisitar a entrada do programa ao usuário.

Essa entrada nada mais é do que o número n.

Para realizarmos a verificação de menor número da lista, podemos utilizar uma estrutura de repetição for como base.

Vamos começar definindo os parâmetros da estrutura for. A variável contadora i deve ser inicializada com o valor 0. A condição de execução desse laço de repetição deve ser i menor que n. Além disso, a regra de incremento da variável contadora i deve ser de uma unidade por loop.

Basicamente, ao definirmos esses parâmetros estamos criando uma estrutura de repetição que começará em 0 e, com somas de 1 unidade por loop, irá repetir instruções até que esse valor seja igual a n – 1.

Em relação as instruções, devemos ter uma verificação de primeiro loop para que o valor lido ali seja armazenado na variável menor como uma suposição de menor número da lista. A partir disso, os outros loops consistirão em atribuir o novo valor inserido pelo usuário a variável aux, em seguida verificar se aux é menor que o valor armazenado pela variável menor e realizar a atribuição do valor de aux para menor em caso afirmativo.

Com isso, criamos uma suposição de menor valor que servirá apenas como base para as próximas inserções na lista. Porém, tal suposição será substituída ao se deparar com um valor mais baixo, garantindo assim que obtenhamos o menor valor da lista ao fim do programa.

Por fim, basta imprimirmos o conteúdo da variável menor.