Gabarito de Lista de Exercícios
Solução:
int x,y,z;
x=y=10;
z=++x;
x=-x;
y++;
x=x+y-(z--);
Solução:
x = -11
y = 11
z = 10
Comentários:
- Em z = ++x, x é incrementado e então
o seu valor e atribuído a z
- Em x = x+y-(z--), z e atribuído a x
e então acontece o decremento
-> ((10>5)||(5>10))
-> (!(5==6)&&(5!=6)&&((2>1)||(5<=4)))
Solução:
-> ((10>5)||(5>10))
=> Verdadeira
TRUE || FALSE = TRUE
-> (!(5==6)&&(5!=6)&&((2>1)||(5<=4)))
=> Verdadeira
!(FALSE)&&(TRUE)&&(TRUE)
Solução:
Quando se usa o modelador (float) o resultado impresso na tela
é 1.428571, que é o valor exato de 10 dividido por sete.
Quando não se usa o modelador o resultado apresentado é 1.0000,
que é o valor do inteiro resultante da operação 10/7
(=1) transformado depois para float.
Solução:
#define LIMITE_INF -100
#define LIMITE_SUP 100
#define INCREMENTO 20
#include <stdio.h>
main()
{
int tempC;
float tempF;
printf("\n\nTemperatura Celsius Temperatura Farenheit\n");
for (tempC = LIMITE_INF; tempC<=LIMITE_SUP; tempC += INCREMENTO)
{
tempF = 9*(float)(tempC+32)/5; /* Float = (9/5)*(Celsius+32)
*/
printf("\t%.3d\t\t %f\n", tempC, tempF);
}
printf("\n\n");
}
Obs: A maior vantagem de se usar as constantes está na
portabilidade estabelecida no programa. Veja, e fácil modificar
os limites da tabela ou mesmo o incremento. Se os valores fossem usados
outras vezes no programa você não precisaria ficar procurando
onde eles estavam para mudar, bastaria mudar as constantes.
Exercício 2:
Faça um programa em C para ler números em ponto flutuante
(representando ângulos em radianos) e imprima o seno do número.
Ao ler o número zero, o programa deverá terminar. Teste seu
programa para verificar seu funcionamento.
Solução:
#include <stdio.h>
#include <math.h>
/* Este programa recebe um angulo inteiro e apresenta o valor de
seu
seno. */
main()
{
int i, angulo = -1; /* angulo inicializado para evitar erro
de
lógica caso o lixo inicial na variável fosse zero */
float seno;
for (i=0; angulo != 0; i++)
{
printf("\n\nEntre com o angulo: ");
scanf("%d", &angulo);
seno = sin(angulo);
printf("\n Seno de %d: %f\n", angulo, seno);
}
}
Solução:
i)
/* Este programa determina as faixas de valores para variáveis
*/
/* int e char por calculo direto
*/
/* Incrementos iniciais: ---------------------------------------
*/
/* Obs: Estes valores precisam ser do tipo 10^x, sendo x inteiro
*/
#define INCR_C 10
#define INCR_I 1000000 /* Um milhao */
#include <stdio.h>
main()
{
int i =1, antigo_i =0, incr_i =INCR_I;
char c =1, antigo_c =0, incr_c =INCR_C;
/* Todas as variáveis foram inicializadas para estarem
compativeis a lógica do programa */
printf("\n\n ----------- Primeiro para os char: \n");
while (incr_c > 0)
{
antigo_c = c;
c += incr_c;
if (antigo_c > c)
{
if (incr_c == 1) incr_c = 0;
/*Seta incr_c=0
para sair do while*/
else incr_c
/= 10;
c = antigo_c;
}
printf("%d\n",c);
}
printf("\n\nLimites: %d\te\t%d\n\n", antigo_c, ++c);
printf("\n\n ----------- Agora para os int: \n");
scanf("%c", &c);
while (incr_i > 0)
{
antigo_i = i;
i += incr_i;
if (antigo_i > i)
{
if (incr_i == 1) incr_i = 0;
/* Seta incr_i = 0 para sair do
while */
else incr_i
/= 10;
i = antigo_i;
}
printf("%d\n",i);
}
printf("\n\nLimites: %d\te\t%d\n\n", antigo_i, ++i);
printf("\n\n\n");
}
ii) O arquivo limits.h, fornece os limites definidos pela implementação. As constantes CHAR_MAX e CHAR_MIN fornecem os limites para o tipo char e as constantes INT_MAX e INT_MIN, os limites para int. Você pode tentar abrir e olhar o arquivo ( :-(( não é muito legal..) ou pode escrever um programa que inclua a biblioteca e apresente os valores na tela.
Observações:
O programa vai incrementar a variável c ou i (dependendo
se é para o tipo char ou int) até que ocorra
um overflow. Quando ocorre o overflow, a variável é atribuída
de seu último valor, e se o incremento for > 1 o é dividido
por 10. Se o incremento for = 1, isto significa que alcançou-se
o menor incremento possível para um inteiro (ou char) e que
aquele número e o maior número possível para aquele
tipo. O incremento é zerado, para que o loop possa ser abandonado.
Abandonando o loop, o programa imprime o número atual (o limite
superior) e o número atual incrementado de 1 (que será o
limite inferior).
Isto acontece porque quando ocorre o overflow em uma variável
signed (leia-se: não unsigned), a variável
passa do seu limite superior para o seu limite inferior. (I.E de 127 a
-128 para char). No sistema onde este programa foi originalmente
rodado, as variáveis char trabalham com 8 bits, e as variáveis
inteiras, com 32 bits.
É importante ressaltar que a grandeza dos incrementos vai ser
responsável pela velocidade com que você vai alcançar
o limite. Se os incrementos forem muito pequenos, o seu computador pode
passar o resto do dia fazendo contas, e não chegar ao resultado.
Compete a você determinar o incremento certo para a sua máquina
e compilador.
As pessoas que tiverem dificuldades em entender o programa acima, deverão
reportar as suas dúvidas para a lista, indicando as partes de difícil
compreensão.