1)
Um dos comandos de repetição de uso mais comum é para.
Assinale todas as afirmações corretas sobre este comando.
Escolha uma ou mais:
a. O comando para somente pode ser usado com variáveis de controle inteiras.
//CORRETO - esta questao e parecida com a 36, do qual apresenta que e possivel
usar o for da linguagem C com CHAR
//MAS no caso do visualG realmente o para so pode utilizar variaveis INTEIRAS
b. Para usar o para é preciso saber, antes da sua execução, dos valores inicial e final da
repetição.
//CORRETO - no caso do visualG e‘ sim necessario
// na linguagem C nao. Pode-se perfeitamente solicitar do usuario dizer
quantas vezes, como no exemplo abaixo:
main(){
int i,
t;
scanf("%d", &t);
for(i
= 0; i <= t; i++)
printf("%d\n", i);
}
c. Para terminar um comando para, basta fazer a atribuição à variável de controle um valor
maior que o valor específicado como valor final.
//ERRADO. Na linguagem C isto funcionaria, mas no visualG NAO, conforme podese observar
//Nao isto nao vai fazer terminar, como por exemplo:
algoritmo "letra_c"
var
i : inteiro
inicio
para i de 1 ate 10 faca
i <- 11
escreval(i)
fimpara
fimalgoritmo
d. Se o valor especificado como início for maior que o especificado como final, o
comando para faz a contagem regressivamente.
//ERRADO, no visualG o comando nao e‘ executado nenhuma vez.
Para decrementar deve-se utilizar o passo -1
algoritmo "letra_d"
var
i : inteiro
inicio
para i de 10 ate 1 passo -1 faca
escreval(i)
fimpara
fimalgoritmo
e. Durante a repetição de um comando para é possível voltar retroceder a contagem
modificando-se o valor da variável de controle.
//CORRETO, pode-se retroceder conforme o codigo abaixo:
algoritmo "letra_e"
var j: inteiro
inicio
para j de 1 ate 10 faca
se j = 5 entao
j <- j -1
fimse
escreva (j:3)
fimpara
fimalgoritmo
f. No para, se o valor inicial for igual ao final, não é feita nenhuma repetição.
//ERRADO, o codigo e‘ executado pelo menos uma vez, conforme abaixo:
algoritmo "letra_f"
var j: inteiro
inicio
para j de 1 ate 1 faca
escreva (j:3)
fimpara
fimalgoritmo
g. So o valor especificado como inicial for maior que o valor especificado como final,
o para não executa os comandos internos nenhuma vez.
//CORRETO – conforme exemplificado na letra E (de acordo com visual G)
h. O comando para executa zero ou mais vezes.
//Correto – de acordo com visualG
2)
Para o comando abaixo, quantas vezes o comando escreva é executado?
para i <- 1 até 10 faça
escreva("x")
fim-para
//10 vezes se a sintaxe do PORTUGOL estiver correta .Em visualG , o codigo
deveria estar //assim para funcionar:
algoritmo "num2"
var i,c: inteiro
inicio
c <- 1
para i <- 1 ate 10 faca
escreval("x", c)
c <- c + 1
fimpara
fimalgoritmo
3) Para o comando abaixo, quantas vezes o comando escreva é executado?
para i <- 0 até 10 faça
escreva("x")
fim-para
//11 vezes se a sintaxe estiver correta, conforme o visualG
algoritmo "num3"
var i,c: inteiro
inicio
c <- 1
para i <- 0 ate 10 faca
escreval("x", c)
c <- c + 1
fimpara
4) Para o comando abaixo, quantas vezes o comando escreva é executado?
para i <- -10 até 10 faça
escreva("x")
fim-para
//21 vezes conforme pode-se exemplificar abaixo:
algoritmo "num4"
var i: inteiro
inicio
para i <- 1 ate 10 faca
escreval("x")
fimpara
fimalgoritmo
5) Para o comando abaixo, quantas vezes o comando escreva é executado?
para i <- 10 até 1 faça
escreva("x")
fim-para
//nenhum vez, conforme codigo abaixo
algoritmo "num2"
var i,c: inteiro
inicio
c <- 1
para i <- 10 ate 1 faca
escreval("x", c)
c <- c + 1
fimpara
fimalgoritmo
6)
Escreva um algoritmo para gerar uma tabela de conversão de unidades,
convertendo pés para metros. Devem ser escritos os valores de 1 a 20 pés, de um em um,
seguido do valor correspondente em metros. Um pé equivale a 30,48 cm.
algoritmo "conversao pe em metro"
// 1 pe equivale a 30,48 cm ou 0,3048m
var
i : inteiro
x : real
inicio
para i de 1 ate 20 faca
x <- i * 0.3048
escreval(i ," pe = ", x , " m")
fimpara
fimalgoritmo
7)
Escreva um algoritmo para gerar uma tabela de conversão de unidades,
convertendo graus Celsius para graus Rankine. Devem ser escritos em Celsius, de um em
um, seguido do valor correspondente em Rankine. A conversão de Celsius para Rankine é
dada por:
O intervalo usado deve ser fornecido ao algoritmo, indicando valor inicial e final (inteiros) para
Celsius. Se o intervalo não for válido, nada deve ser escrito.
algoritmo "conversao celsius em rankine"
var
i, ini, fim : inteiro
rank : real
inicio
escreval("Digite o valor inicial:")
leia(ini)
escreval("Digite o valor final:")
leia(fim)
se ini<=fim entao
para i de ini ate fim faca
rank <- (i * 9 )/5 + 491.67
escreval(i ," C = ", rank , " Rankine")
fimpara
fimse
fimalgoritmo
8)
O que faz o algoritmo abaixo?
{ um algoritmo }
algoritmo
declare i, quantidade, valor: inteiro
{ determinação do número de repetições }
leia(quantidade)
se quantidade <= 0 entao
escreva("Nenhum valor será informado")
senão
leia(valor)
auxiliar <- valor
para i <- 2 até quantidade faça
leia(valor)
se valor < auxiliar então
auxiliar <- valor
fim-se
fim-para
escreva(auxiliar)
fim-algoritmo
//O algoritmo nao funciona, pois a variavel auxiliar nao foi declarada e esta
tentar usa-la atribuindo a variavel valor a mesma. Assim, nenhuma das opcoes
abaixo e’ valida. – deveria ser anulada. Mas desconsiderando este erro, o
objetivo do programa e’ que, dado uma quanidade inicial de numeros, ele
imprime o menor de todos
//LETRA C
Escolha uma:
a. Escreve o último valor digitado.
b. Escreve o último valor se for menor que o penúltimo; senão escreve o penúltimo valor
digitado.
c. Escreve o menor valor entre todos os digitados.
d. Escreve o maior valor entre todos os digitados.
e. Escreve o primeiro valor digitado, desprezando os demais.
9)
Escreva um algoritmo para, dados a quantidade de valores de temperaturas e as
temperaturas, determinar qual é a maior. Se a quantidade for menor ou igual a zero, uma
mensagem de erro deve ser escrita.
//Praticamente a mesma coisa do algoritmo acima, so inverter o valor de “<”
para ” >”
algoritmo "Temperatura"
var
i, quantidade : inteiro
temperatura, aux: real
inicio
Escreva("Digite a quantidade de temperaturas:")
leia(quantidade)
se (quantidade <= 0) entao
escreva("Erro: A quantidade deve ser maior que zero")
senao
Escreval("Digite a temperatura")
leia(temperatura)
aux <- temperatura
para i <- 2 ate quantidade faca
leia(temperatura)
se temperatura > aux entao
aux <- temperatura
fimse
fimpara
escreva("A maior temperatura e: ", aux)
fimalgoritmo
10)
Escreva um algoritmo para, dadas a quantidade de valores de idades (assuma valores
sempre maiores ou iguais a zero) e as idades, determinar qual é a maior e o número de vezes
que ela ocorreu. Se a quantidade for menor ou igual a zero, uma mensagem de erro deve ser
escrita.
Por exemplo:
o
o
Número de idades: 5
Idades:
o 25
o 34
o 44
o 25
o 38
Resultado esperado: menor idade igual a 25, com duas ocorrências.
//quase a mesma coisa do exercicio 10, com a diferenca da frequencia que a
maior ocorreu
//o unico problema e‘ que no enunciado pede a MAIOR idade(deixei em negrito
acima), mas no exemplo apresenta a MENOR(deixei em negrito acima)!
Considerando que o exemplo esta incorreto, sera resolvido baseado no
enunciado!
algoritmo "idade"
var
i, quantidade,x : inteiro
idade, aux: real
inicio
x <- 1
Escreva("Digite a quantidade de idades:")
leia(quantidade)
se (quantidade <= 0) entao
escreva("Erro: A quantidade deve ser maior que zero")
senao
Escreval("Digite a idade")
leia(idade)
aux <- idade
para i <- 2 ate quantidade faca
leia(idade)
se idade > aux entao
aux <- idade
senao
se (idade = aux) entao
x <- x + 1
fimse
fimse
fimpara
escreva("A maior idade igual a: ", aux, " com ", x ," ocorrencias")
fimalgoritmo
11)
O que faz o algoritmo abaixo? Qual seria um identificador adequado para a
variável auxiliar?
{ algoritmo que ...??? }
algoritmo
declare
i, quantidade, idade, auxiliar: inteiro
{ número de idades que serão digitadas }
leia(quantidade)
{ leitura e processamento das idades }
auxiliar <- 0
para i <- 1 até quantidade faça
leia(idade)
se 18 <= idade e idade <= 21 então
auxiliar <- auxiliar + 1
fim-se
fim-para
{ resultado }
escreva(auxiliar)
fim-algoritmo
//este algoritmo tem um erro de sintaxe (18 <= idade) ??? do qual tambem nao
funcionaria
// o mais correto seria idade >= 18
//Quase a mesma coisa do exercicio anterior (10), tem o objetivo de:
//dada uma quantidade de idades, contar apenas as que estao entre 18 e 21
anos.
//o identificador que poderia representar poderia ser: conta_entre18_e_21_anos
//Abaixo um algoritmo completo explicando melhor(nao precisa do mesmo, so para
vc entender melhor)
algoritmo "ex11"
var
i, quantidade, idade,
conta_entre18_e_21_anos: inteiro
inicio
escreval("Digite a quantidade de idades:")
leia(quantidade)
conta_entre18_e_21_anos <- 0
para i <- 1 ate quantidade faca
escreva("Digite a idade:")
leia(idade)
se (idade >= 18) e (idade <= 21) entao
conta_entre18_e_21_anos <- conta_entre18_e_21_anos + 1
fimse
fimpara
escreva("Numero de idades entre 18 e 21 anos: " , conta_entre18_e_21_anos)
fimalgoritmo
12)
Um digitador tem uma lista impressa como a apresentada abaixo
Número de itens: 4
Código do produto
Valor unitário
Quantidade
12998
27,38
30
328
1,99
235
53334
7,20
55
3332
15,00
72
Escreva um algoritmo que permita a um operador digitar os dados da lista e, ao final, obter as
seguintes informações:
o
o
Quantos produtos custam mais que R$10,00 unitariamente
Quantos produtos possuem valor total (quantidade X valor unitário) superior a
R$200,00
o Qual o menor valor unitário existente
Assuma que todos os valores digitados serão inseridos corretamente, não sendo preciso
verificar a consistência dos dados (não há quantidades nem preços negativos, por exemplo).
//Exercicio parecido com o anterior novamente, pelo menos a ideia. So um pouco
maior
algoritmo "ex12"
var
codigo, quantidade, i : inteiro
valor_unitario : real
qtd : inteiro
conta_mais_10 : inteiro
conta_mais_200 : inteiro
menor : real
inicio
conta_mais_10 <- 0
escreval("Digite a quantidade de itens:")
leia(quantidade)
escreva("Digite o codigo do produto:")
leia(codigo)
escreva("Digite o valor unitario")
leia(valor_unitario)
menor <- valor_unitario
escreva("Digite a qtd do produto")
leia(qtd)
se (valor_unitario > 10) entao
conta_mais_10 <- conta_mais_10 + 1
fimse
se (valor_unitario * qtd > 200) entao
conta_mais_200 <- conta_mais_200 + 1
fimse
para i <- 2 ate quantidade faca
escreva("Digite o codigo do produto:")
leia(codigo)
escreva("Digite o valor unitario")
leia(valor_unitario)
escreva("Digite a qtd do produto")
leia(qtd)
se valor_unitario < menor entao
menor <- valor_unitario
fimse
se (valor_unitario > 10) entao
conta_mais_10 <- conta_mais_10 + 1
fimse
se (valor_unitario * qtd > 200) entao
conta_mais_200 <- conta_mais_200 + 1
fimse
fimpara
escreval("Qtd de produtos que custam mais que R$ 10,00 unitariamente: ",
conta_mais_10 )
escreval("Qtd de produtos que possuem valor total superior a R$200,00: ",
conta_mais_200 )
escreval("O menor valor unitário existente e:",menor)
fimalgoritmo
13)
O que faz o algoritmo abaixo? Qual seria um identificador adequado para a
variável auxiliar?
{ algoritmo que ...??? }
algoritmo
declare
i, quantidade: inteiro
preço, auxiliar: real
{ número de preços que serão digitados }
leia(quantidade)
{ leitura e
auxiliar <para i <- 1
leia(preço)
auxiliar <fim-para
processamento dos preços }
0
até quantidade faça
auxiliar + preço
{ resultado }
escreva(auxiliar)
fim-algoritmo
//O objetivo do algoritmo e‘ de acumular os precos digitados, ou seja somalos. Assim, o identificador no lugar de auxiliar poderia ser somaPreco,
conforme pode-se ver seu Portugol
algoritmo "somaPreco"
var
i, quantidade: inteiro
preco, somaPreco: real
inicio
leia(quantidade)
somaPreco <- 0
para i <- 1 ate quantidade faca
leia(preco)
somaPreco <- somaPreco + preco
fimpara
escreva(somaPreco)
fimalgoritmo
14) Um digitador tem uma lista impressa como a apresentada abaixo
Número de itens: 4
Código do produto
Valor unitário
Quantidade
12998
27,38
30
328
1,99
235
53334
7,20
55
3332
15,00
72
Escreva um algoritmo que permita a um operador digitar os dados da lista e, ao final, obter a
quantidade total de produtos com valor individual superior a R$25,00.
15)
O que faz o algoritmo abaixo? Qual seria um identificador adequado para a
variável auxiliar?
{ algoritmo que ...??? }
algoritmo
declare
i, quantidade: inteiro
temperatura: real
auxiliar: lógico
{ número de temperaturas que serão digitadas }
leia(quantidade)
{ leitura e processamento das temperaturas }
auxiliar <- falso
para i <- 1 até quantidade faça
leia(temperatura)
se temperatura < 0 então
auxiliar <- verdadeiro
fim-se
fim-para
{ resultado }
se auxiliar então
escreva("Há")
senão
escreva("Não há")
fim-se
fim-algoritmo
16)
Escreva um algoritmo para ler o número de alunos e, para cada aluno, ler as notas de
duas provas, calculando sua média individual (média aritmética simples das duas notas). Ao
final, informar a média geral da turma (média das médias individuais) e se todos os alunos
foram aprovados (i.e., tiveram média individual maior ou igual a 6,0).
Esforcem-se para fazer a verificação se todos foram aprovados usando uma variável lógica.
17)
Em uma usina é preciso verificar as condições da pressão em uma caldeira.
Uma informação importante para a administração é o momento em que a pressão ficou abaixo
de 15,5 MPa (mega Pascal). Para isso, um funcionário é encarregado de anotar em um
caderno a pressão de hora em hora, iniciando às 0h00min e encerrando às 23h.
Escreva um algoritmo que permita digitar os 24 valores de pressão anotados e obter como
resultado a hora em que a última ocorrência de pressão inferior ao limite ocorreu. Veja que
não é preciso digitar a hora, pois já se sabe que cada valor corresponde a uma leitura e que as
leituras são dadas na ordem correta.
algoritmo "pressao"
var
hora : inteiro
pressao : real
ultima_hora : inteiro
inicio
hora <- 0
enquanto (hora <= 23) faca
escreva(hora , "h - Pressao? ")
leia(pressao)
se (pressao < 15.5) entao
ultima_hora <- hora
fimse
hora <- hora + 1
fimenquanto
escreva("A ultima hora que a pressao ficou abaixo de 15.5 MPa foi as",
ultima_hora)
fimalgoritmo
18)
Considere o seguinte problema:
Em um shopping center foi instalado um quiosque para registrar uma pesquisa de opinião,
sendo entrevistadas as pessoas que passam pelo local. Nesta pesquisa, registram-se apenas
dois tipos de votos: sim e não. Ao final do dia, deseja-se saber se houve mais votos sim do
que votos não.
É possível escrever um algoritmo para resolver este problema usando o comando para?
Escolha uma opção:
Verdadeiro
Falso
19)
Escreva um algoritmo para ler um número inteiro e, se ele for maior ou igual a zero,
escrever todos os seus divisores. Por exemplo, se for digitado o número 10, devem ser escritos
os valores 1, 2, 5 e 10.
20)
Um número perfeito é aquele em que a soma de seus divisores (exceto ele mesmo) é
igual ao próprio número. Por exemplo, os divisores de 28 são 1, 2, 4, 7, 14 e 28; a soma 1 + 2
+ 4 + 7 + 14 = 28; portanto 28 é perfeito.
Escreva um algoritmo para ler um número inteiro e, se ele for maior ou igual a zero, determinar
e escrever se ele é um número perfeito.
21) Assinale todas as afirmações corretas sobre o comando enquanto.
Escolha uma ou mais:
a. O comando enquanto usa uma variável de controle inteira, incrementada
automaticamente.
b. É possível que, ao se escrever um código com enquanto, a repetição nunca termine,
pois a condição de término pode nunca ser alcançada.
c. Os comandos internos do enquanto são executados pelo menos uma vez antes da
primeira avaliação da condição de término.
d. O comando enquanto termina imediatamente quando a condição de término é
verdadeira, mesmo que ainda haja comandos internos que não foram executados.
e. A condição de término do enquanto pode ser qualquer expressão lógica válida.
22)
Assinale todas as afirmações corretas sobre o comando de repetição faça...até.
Escolha uma ou mais:
a. A repetição com o faça...até pode não executar nenhuma vez, o que acontece quando a
condição de término é verdadeira já antes da execução do comando.
b. O faça...até termina quando a condição especificada para término é avaliada com
resultado verdadeiro.
c. O faça...até e o comando enquanto têm as mesmas características.
d. O faça...até usa sempre uma variável de controle inteira, a qual é incrementada
automacamente.
23)
Assinale todas as afirmações corretas sobre o comando de repetição faça...enquanto.
Escolha uma ou mais:
a. A repetição com o faça...enquanto necessariamente executa pelo menos uma vez os
comandos antes de avaliar a expressão de término.
b. O faça...enquanto termina quando a condição especificada para término é avaliada
com resultado falso.
c. O faça...enaquanto e o comando enquanto têm as mesmas características.
d. O faça...enquanto usa sempre uma variável de controle inteira, a qual é incrementada
automacamente.
e. A diferença entre o faça..até e o faça...enquanto é que a condição de término de um é
a negação da condição de término do outro.
24)
Considere o algoritmo abaixo. Sua função é ler um conjunto de notas, ignorando as
digitadas fora do intervalo válido (0 a 10) e calcular sua média.
Para este algoritmo, assume-se que não se sabe quantas notas serão digitadas e, assim, não
se pode ler o número de notas antes.
{ algoritmo para calcular a média de um número indefinido de notas }
algoritmo
declare
númeroNotas: inteiro
nota, somaNotas, média: real
{ leitura das notas e soma dos valores }
somaNotas <- 0
númeroNotas <- 0
faça
escreva("Digite uma nota (0,0 a 10,0): ")
leia(nota)
se 0 <= nota e nota <= 10 então
somaNotas <- somaNotas + nota
quantidade <- quantidade + 1
fim-se
enquanto nota <> -1
{ cálculo da média e resultado }
se númeroNotas = 0 então
escreva("Nenhuma nota válida digitada")
senão
média <- somaNotas/númeroNotas
escreva("Média das ", númeroNotas, " digitadas: ", média)
fim-se
fim-algoritmo
Como é indicado o fim das notas que devem ser digitadas? Qual seria uma boa mensagem ao
ser colocada na tela ao se digitar cada nota, no lugar de "Digite uma nota (0,0 a
10,0): "?
25)
Escreva um algoritmo para ler um número indefinido de alturas e determinar qual o
maior valor digitado. O fim dos dados é indicado por um valor negativo.
26)
Considere o seguinte algoritmo, que se propõe a ler um conjunto indefinido de
temperaturas e indicar se existem temperaturas no intervalo de 0 a 4 graus Celsius (condição
de geada). O término dos dados é indicado pelo valor "especial" -100.
{ determinar, para um conjunto de temperaturas, se há ocorrências
de temperaturas no intervalo [0, 4] graus }
algoritmo
declare temperatura: real
{ leitura das temperaturas e verificação de ocorrência }
leia(temperatura)
enquanto temperatura <> -100 faça { -100 indica o término }
se 0 <= temperatura e temperatura <= 4 então
escreva("Sim, há ocorrências de temperaturas de geada"")
senão
escreva("Não, não há ocorrências de temperaturas de geada")
fim-se
fim-enquanto
fim-algoritmo
Esta é uma boa solução para o problema? Discuta no fórum porque sim ou porque não?
Escolha uma opção:
Verdadeiro
Falso
27)
Escreva um algoritmo para ler um conjunto de idades, com término indicado por um
valor negativo. Deve ser apresentado como resultado o valor médio apenas para as idades
maiores ou iguais a 20 e menores ou iguais a 50.
Note que o valor da idade média deve ser dado em um número real.
Observação importante: seu algoritmo deve cuidar do caso em que, entre todas as idade
digitadas, não haja nenhuma dento do intervalo especificado.
//Observacao: quer dizer para cuidar para que nao tenha divisao por zero!
algoritmo "idade"
var
idade : inteiro
conta_idade : inteiro
soma_idade : real
media : real
inicio
idade <- 1
conta_idade <- 0
media <- 0
enquanto (idade > 0) faca
escreval("Digite a idade:")
escreval("(-1) para finalizar")
leia(idade)
se (idade >= 20) e (idade <= 50) entao
soma_idade <- soma_idade + idade
conta_idade <- conta_idade + 1
fimse
fimenquanto
se conta_idade <> 0 entao
media <- soma_idade/conta_idade
fimse
escreval("Media das idades entre 20 e 50 e':", media )
fimalgoritmo
28)
A sequência de Fibonacci é uma sequência importante (clique aqui).
Ela se inicia com o valor 0, seguido do valor 1. A partir do terceiro elemento, cada novo número
da sequência é obtido pela soma dos dois anteriores.
Assim, a sequência é dada por: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55...
Escreva um algoritmo para escrever os termos da sequência. O número de termos deve ser
dado pelo usuário (se for especificado para se escrever 11 termos, então serão escritos os
valores do 0 até o 55).
Nota: Alguns textos não consideram o zero como valor inicial da sequência, sendo esta 1, 1, 2,
3, 5...
algoritmo "fib"
var
n, n1, n2, cont: inteiro
fib : inteiro
inicio
//0,1,1,2,3,5,8,13,21,34
escreval("Escreva o valor do termo que deseja apareca a seq. Fibonacci:")
leia(n)
n1 <- 0
n2 <- 1
cont <- 2
fib <- n1 + n2
escreva("0, 1")
enquanto (cont < n) faca
escreva(",", fib )
n1 <- n2
n2 <- fib
fib <- n1+n2
cont <- cont + 1
fimenquanto
fimalgoritmo
29)
Deseja-se fazer uma repetição de 1 até 100. A codificação em C foi feita do seguinte
modo:
for(i = 1; i == 100; i++)
Está correto?
Escolha uma opção:
Verdadeiro
Falso
//ERRADO, pois o i comeca de 1 e como nao e’ 100, jamais imprime a sequencia.
Deveria ter i<= 100, ficando o codigo completo:
#include <stdio.h>
#include <stdlib.h>
main()
{
int i;
for(i = 1; i <= 100; i++)
printf("%d", i);
}
30)
Deseja-se fazer uma repetição de 1 até 100. A codificação em C foi feita do seguinte
modo:
for(i = 1; i < 100; i++)
Está correto?
Escolha uma opção:
Verdadeiro
Falso
//ERRADO, porque nao imprime o valor 100. Deveria ter i <= 100. Exemplo na
questao 29.
31)
Deseja-se fazer uma repetição de 1 até 100. A codificação em C foi feita do seguinte
modo:
for(i = 1; i <= 100; i = i + 1)
Está correto?
Escolha uma opção:
Verdadeiro
Falso
//CORRETO
32)
Para se escrever os valores de 0 a 20 em um programa em C, foram propostas duas
alternativas:
A:
for(i = 0; i <= 20; i++)
printf("%d", i);
B:
for(i = 0; i <= 20; i++){
printf("%d", i);
}
Qual a codificação correta?
Escolha uma:
a. Somente a codificação A.
b. Somente a codificação B.
c. As duas codificações estão corretas.
d. Nenuma das codificações está correta.
//As duas estao corretas. A primeira nao utiliza chaves, como tem apenas uma
linha pode. A Segunda utiliza chaves, tambem pode. LETRA C
33)
Considere o programa em C abaixo.
/* programa para escrever uma tabela de conversão de temperaturas */
#include <stdio.h>
int main(){
int celsius;
float fahrenheit;
for(celsius = 0; celsius <= 20; celsius++)
fahrenheit = 1.8 * celsius + 32;
printf("%d C = %.1f F\n", celsius, fahrenheit);
return 0;
}
Quantas vezes o comando printf é executado?
Resposta:
//Apenas 1 vez, pois nao tem chaves
34)
Veja o programa em C e verifique qual o problema que ele tem.
Veja a resposta somente depois de tentar resolver sozinho...
Resposta:
/*
Conversoes de temperatura Celsius -> Fahrenheit
Jander Moreira, 2011
*/
#include <stdio.h>
int main()
{
float celsius, fahrenheit;
printf("Digite temperatura em Celsius (-100 para terminar): ");
scanf("%f", &celsius);
while(celsius != -100);
{
fahrenheit = 1.8 * celsius + 32;
printf("%.1f oC = %.1f F\n\n", celsius, fahrenheit);
printf("Digite temperatura em Celsius (-100 para terminar): ");
scanf("%f", &celsius);
}
return 0;
}
//O ; depois do while, ficando em loop infinito
35)
Em C, é possível fazer um for usando o tipo char.
Execute o programa abaixo e faça novos testes com incrementos (++), decrementos (--) ou
outras operações (como ('A' + 'E')/2) para testar essa possibilidade.
/*
Exemplos de uso do 'for' com o tipo 'char'
Jander, 2011
*/
#include <stdio.h>
int main(){
char c;
for(c = 'f'; c <= 'r'; c++)
printf("%c\n", c);
return 0;
}
36)
Verifique o programa em C abaixo. O que ele calcula? Se os nomes das variáveis e a
documentação estivesse em ordem, ficaria mais fácil?
/*
Programa sem comentarios ou nomes de variaveis suficientes
Jander, 2011
*/
#include <stdio.h>
int main(){
int a, b, c;
printf("Digite um valor: ");
scanf("%d", &a);
printf("Digite um outro valor: ");
scanf("%d", &b);
do{
c =
a =
b =
}while(c !=
a % b;
b;
c;
0);
printf("Resultado: %d\n", a);
system("PAUSE");
return 0;
}