APOSTILA DE LINGUAGEM C

Prévia do material em texto

UNIVERSIDADE FEDERAL DO OESTE DA BAHIA
INSTITUTO DE CIÊNCIAS AMBIENTAIS E DESENVOLVIMENTO SUSTENTÁVEL
ENGENHARIA CIVIL
ITAYLANE MALTA SANTOS
APOSTILA DE LINGUAGEM C
BARREIRAS-BA
JANEIRO DE 2014
ITAYLANE MALTA SANTOS
APOSTILA DE LINGUAGEM C
BARREIRAS-BA
JANEIRO DE 2014
SUMÁRIO
APRESENTAÇÃO.........................................................................................................4
HISTÓRICO DA LINGUGEM C...................................................................................5
PROGRAMAS UTILIZADOS.......................................................................................6
CARACTERÍSTICAS E PECULIARIDADES..............................................................7
ESTRUTURA DE UM PROGRAMA EM C.................................................................7
Biblioteca ou Arquivos-cabeçalho..................................................................................8
Sintaxe.............................................................................................................................8
VARIÁVEIS...................................................................................................................9
Declaração de Variáveis..................................................................................................9
Tipos de Variáveis e Constantes...................................................................................10
Inteiros...........................................................................................................................10
Floats.............................................................................................................................11
OPERADORES.............................................................................................................11
Atribuição......................................................................................................................11
Operadores Aritméticos.................................................................................................12
Operadores relacionais..................................................................................................12
Incremento e Decremento.............................................................................................13
Operadores Lógicos.......................................................................................................14
FUNÇÕES BÁSICAS DA LINGUAGEM C...............................................................15
Função printf.................................................................................................................15
Função scanf..................................................................................................................17
ESTRUTURAS CONDICIONAIS...............................................................................19
Estruturas Compostas....................................................................................................19
Condicional if................................................................................................................19
Condicional if-else-if.....................................................................................................20
LAÇOS..........................................................................................................................21
Laço for.........................................................................................................................21
Laço while.....................................................................................................................22
Laço do-while................................................................................................................23
EXERCÍCIOS RESOLVIDOS.....................................................................................24
REFERÊNCIAS............................................................................................................89�
APRESENTAÇÃO
Esta apostila foi elaborada com o objetivo de auxiliar pessoas que se interessem em aprender a linguagem de programação C. Nela serão apresentados os comandos básicos da linguagem e também a resolução de 25 exercícios em algoritmo e linguagem C.
HISTÓRICO DA LINGUAGEM C
A primeira versão de C foi criada por Dennis Ritchie em 1972 nos laboratórios Bell para ser incluído como um dos softwares a serem distribuídos juntamente com o sistema operacional Unix do computador PDP-11, na equipe certificada por Ken Thompson.
Ao ponto de vista técnico, o surgimento do C iniciou com a linguagem ALGOL 60, definida em 1960. ALGOL era uma linguagem de alto nível, que permitia ao programador trabalhar "longe da máquina", sem se preocupar com os aspectos de como cada comando ou dado era armazenado ou processado. Foi criado para substituir o FORTRAN. ALGOL não teve sucesso, talvez por tentar ser de muito alto nível em uma época em que a maioria dos sistemas operacionais exigiam do usuário um grande conhecimento de hardware.
Em 1967 surgiu CPL (Combined Programming Language) nas universidades de Londres e Cambridge com o objetivo, segundo a equipe do projeto, de "trazer ALGOL à terra", ou "manter contato com a realidade de um computador real". Da mesma forma de ALGOL, CPL não foi bem aceita, em especial pelos projetistas de sistemas operacionais que a consideravam difícil de implementar.
Ainda em 1967, em Cambridge, Martin Richards criou o BCPL (Basic CPL), uma simplificação do CPL, tentando manter apenas as "boas coisas do CPL".
Em 1970, Ken Thompson, chefe da equipe que projetou o UNIX para o PDP11 do Bell Labs, implementou um compilador para uma versão mais reduzida do CPL. Batizou a linguagem de B. 
Tanto BCPL quanto B mostravam-se muito limitadas, prestando-se apenas para certas classes de problemas. Isto se fez sentir especialmente na primeira versão do PDP11, lançado no mercado em 1971. Um dos fatores que levou a isto foi à intenção do grupo responsável pelo UNIX de reescrevê-lo todo em uma linguagem de alto nível, e para isto B era considerado lenta.
Estes problemas levaram o projetista Dennis Ritchie, do Bell Labs, a projetar uma nova linguagem, sucessora do B, que viria então, a ser chamada de C.
A linguagem C buscou manter o "contato com o computador real" e ainda sim dar ao programador novas condições para o desenvolvimento de programas em áreas diversas, como comercial, científica e de engenharia.
Por muitos anos (aproximadamente 10) a sintaxe (formato) tida como padrão da linguagem C foi aquela fornecida com o UNIX versão 5.0 do Bell Labs. A principal documentação deste padrão encontra-se na publicação "The C Programming Language", de Brian Kernighan e Dennis Ritchie (K&R), tida como a "bíblia da linguagem C".
O mais interessante desta versão de C era que os programas-fonte criados para rodar em um tipo de computador podiam ser transportados e recompilados em outros sem grandes problemas. A esta característica dá-se o nome de portabilidade. Com ela, uma empresa que desenvolve um programa pode fazê-lo rodar em diferentes computadores sem ter um elevado custo a cada vez que isto for feito.
Em 1985, ANSI (American National Standards Institute) estabeleceu um padrão oficial de C o chamado "C ANSI". 
EVOLUÇÃO DA LINGUAGEM C
PROGRAMAS UTILIZADOS
Existem na internet alguns programas que são utilizados para criar as linhas de códigos e compilar os mesmos, tornando em executáveis as aplicações. As ferramentas mais comuns são:
DevC++: Hoje mais utilizada pelas pessoas que estão aprendendo a linguagem. Lembrando que esse programa tem algumas limitações quanto ao uso integral da linguagem.
Visual Studio: Ferramenta mais completa. Utilizada para o desenvolvimento de aplicações em C e C++,sendo que tem a parte de console para desenvolvimento e a porte visual. Com essa ferramenta também tem como utilizar Banco de dados para utilização da Linguagem de Programação C.
C Builder: Ferramenta utilizada comumente para o desenvolvimento de aplicações visuais.
CARACTERÍSTICAS E PECULIARIDADES
Portabilidade;
Geração de códigos executáveis compactos e rápidos;
Case sensitive, ou seja, existe diferenciação entre maiúsculas e minúsculas. Dessa forma, as variáveis VALOR e valor são distintas;
Uso de funções: todo programa em C é um conjunto de funções;
Todas as operações são feitas por bibliotecas. As bibliotecas são arquivos cabeçalhos que possuem declarações de funções úteis para a execução do código.
ESTRUTURA DE UM PROGRAMA EM C
Um programa em C é composto dos seguintes elementos:
Bibliotecas ou Arquivos Cabeçalhos;
Definição de tipos;
Protótipos de funções;
Funções;
Comentários.
Exemplo de um programa em C:
#include<stdio.h>
 int main( ){
 int x=2;
 printf(“O valor de x é: %d”, x);
 return(0);
 }
Onde: 
#include<stdio.h> é uma biblioteca de entrada e saída de dados;
main ( ) é a função principal do programa. ‘int’ indica que a função é do tipo inteira, ou seja, retorna um valor inteiro, no exemplo retorna o valor 0 (zero);
int x é uma variável numérica inteira (int) de nome ‘x’.
Quando um programa inicia, o compilador reconhece as variáveis criadas e parte imediatamente para a execução da função principal, que por sua vez, pode chamar outras funções.
Bibliotecas ou Arquivos-cabeçalho
São os comandos que instruem o compilador a realizar determinadas tarefas antes de iniciar a compilação de todos ou parte do programa. Também são chamadas de diretivas de pré-processamento.
Todas as Bibliotecas começam com #include, e os arquivos tem uma extensão ‘.h’.
Sintaxe
A sintaxe de um programa em linguagem C é a maneira de escrever o programa de forma que o compilador entenda, ou seja, um conjunto de regras que é específico da linguagem.
Em C existe a necessidade de um programa principal main( ), e cada comando é finalizado com ; (ponto e vírgula). Existem também comentários, que são dados, palavras ou frases que auxiliam o programador enquanto está escrevendo o software. Os comentários são escritos da seguinte forma:
/* O uso de comentários torna o código mais fácil de entender */
Tudo que existir entre o intervalo /*........*/ não será interpretado pelo compilador C, então pode ser escrito qualquer caractere ou frase a fim de auxiliar o programador ou quem está lendo o programa fonte.
VARIÁVEIS
Para poder fazer uso das variáveis e constantes dentro de um programa, devemos utilizar identificadores. Existem algumas regras para a utilização de identificadores.
Todos os identificadores devem começar por a... z ou A... Z ou sublinhado ( _ ). Por exemplo:
int a;
int A;
int numero;
int _numero;
Observação: a linguagem C é case sensitive (caractere sensível) e interpreta letras minúsculas diferente de letras maiúsculas. Todo cuidado deve ser tomado quando se definir uma variável, usando-a de forma idêntica no decorrer do programa.
Declaração de Variáveis
Todas as variáveis devem ser declaradas antes de poderem ser utilizadas. A forma de declarar é:
tipo nome_variavel = valor;
Exemplo:
int x; /* cria uma variável de nome a, do tipo inteira*/
int euro=1000; /* cria uma variável de nome euro com valor inicial igual a 1000, do tipo inteira*/
char opção_menu; /*cria uma variável de nome opção_menu, do tipo caractere*/
Tipos de Variáveis e Constantes
Inteiros
Int
Representa um número inteiro (negativo ou positivo).
unsigned int
Define uma variável inteira (int) com um valor sem o sinal negativo.
void
É um dado que não retorna valor algum à variável ou função.
char
É uma variável ou constante do tipo caractere (o compilador utiliza a tabela ASCII). Também pode ser tratado como int porque a tabela ASCII retorna um valor numérico inteiro de 8 bits quando pressiona-se uma tecla. A definição de um char para o compilador C deve ser colocada entre apóstrofes (‘A’).
Exemplos:
char código, inicial; /* cria duas variáveis, uma de nome código e outra de nome inicial*/
unsigned char tipo, tab; /* cria duas variáveis, uma de nome tipo e outra de nome tab*/
/* Em seguida, atribui-se assim*/
código=65; /* código ASCII da letra A */
inicial=’A’; /* idem ao anterior */
tab=’\t’; /* caractere tab*/
tipo=inicial+1; /* resulta no caractere B */
tipo=’A’+1; /* idem ao anterior */
6.2.2 Ponto Fluatuante
float
É um dado em ponto flutuante (número fracionário). São os números reais da teoria de conjuntos na matemática. Exemplo de variáveis float:
float a=-1.234;
float PI=3.1415;
double
É também um dado em ponto flutuante, mas com precisão dupla. Exemplo:
double x= -253.778978e274 /* número com 9 dígitos significativos */
OPERADORES
Atribuição
Para atribuir um valor numérico ou um caractere a uma variável, utiliza-se o sinal de igual ( = ). Exemplo:
int y; /* cria-se a variável de nome y*/
y=2; /*atribui o valor dois à variável y */
Essa sintaxe pode ser resumida em:
int y=2;
Observação: a ideia de atribuir um valor inicial à variável, ou seja, inicializar a variável com um valor pré-determinado é imprescindível em alguns casos, porque no momento que se cria uma variável, o compilador atribui a ela um valor aleatório (contido na memória do computador).
Operadores Aritméticos 
São idênticos à maioria dos operadores comumente utilizados em outras linguagens.
	OPERADOR
	SIGNIFICADO
	+
	ADIÇÃO
	-
	SUBTRAÇÃO
	*
	MULTIPLICAÇÃO
	/
	DIVISÃO
	%
	RESTO DA DIVISÃO DE INTEIROS
Há sempre algum operador um pouco diferente, por exemplo:
% (indica o resto de uma divisão inteira).
Exemplo: 
/* Programa para mostrar o resto de uma divisão entre dois números*/
#include<stdio.h>
 main( ) {
 int x=8, y=2;
 printf(“%d \n”, x/y); /*quociente da divisão de x por y; \n é um uma expressão de controle para saltar linha */
 printf(“%d \n”, x%y); /*mostra o resto da divisão de x/y */
 }
Operadores Relacionais
Traz a ideia de comparação entre valores. São eles:
	OPERADOR
	SIGNIFICADO
	>
	MAIOR QUE
	>=
	MAIOR OU IGUAL
	<
	MENOR
	<=
	MENOR OU IGUAL
	==
	IGUAL
	!=
	DIFERENTE
O resultado obtido na utilização desses operadores é um dado verdadeiro (true) ou falso (false). Verdadeiro é qualquer valor diferente de zero. O resultado falso é o próprio zero. Por exemplo:
#include<stdio.h>
#include<stdlib.h>
 main( ){
 int i, j;
 printf(“Digite dois números:\n”);
 scanf(“%d %d”, &i, &j);
 if(i==j) printf(“%d é igual a %d”, i, j);
 if(i != j) printf(“%d é diferente de %d”, i, j);
}
Incremento e Decremento
O incremento de valores nas variáveis pode ser feito assim:
int x;
x=10;
x=x+1; /* Incrementa em 1 o valor anterior de x*/
Porém, há uma maneira de incrementar as variáveis.
++x ( incrementa x antes de utilizar seu valor.
x++( incrementa x depois de ter utilizado seu valor.
Exemplo:
#include<stdio.h>
#include<stdlib.h>
 main( ){
 int x=10;
 printf(“x= %d\n”, x++);
 printf(“x=%d\n”, x);
 printf(“x=%d\n”,++x);
 printf(“x=%d\n”, x);
}
Operadores Lógicos
	OPERADOR
	SIGNIFICADO
	&&
	AND/ E
	| |
	OR/ OU
	!
	NOT/ NEGAÇÃO
Esse tipo de operador tem o objetivo de testar as combinações nas expressões relacionais. Exemplo:
if(x>=3&&x<7) /*Executa o comando se x estiver entre 3 e 6*/
FUNÇÕES BÁSICAS DA LINGUAGEM C
Função printf
Sintaxe: printf(“expressão de controle”, argumento);
É uma função padrão para exibir uma mensagem, número, caractere ou qualquer tipo de símbolo no dispositivo padrão de saída de dados, no caso, a tela do computador.A expressão de controle pode ser uma mensagem que o programador deseja imprimir na tela, podendo conter também formatadores padrão que indicam o tipo de variável a ser vinculada nessa mensagem. Os argumentos são as próprias variáveis, que podem ser inclusive, impressas em forma de operações lógicas ou aritméticas. Cada argumento deve ser separado um do outro por vírgula ( , ).
	EXPRESSÕES DE CONTROLE
	SIGNIFICADO
	\n
	New line (pula linha)
	\t
	tab (tabulação horizontal)
	\b
	Backspace(volta um caractere)
	\f
	Form feed (avanço de página)
	\\
	Imprimir a barra invertida
	\‘
	Imprimir a apóstrofe
	\’’
	Imprimir aspas
	FORMATADORES
	SIGNIFICADO
	%d
	int
	%f
	float
	%e
	notação científica
	%s
	string (sequência de caracteres)
	%c
	char
	%p
	ponteiro
	%o
	octal
	%u
	Inteiro sem sinal(unsigned)
Exemplos:
#include<stdio.h>
#include<stdlib.h>
main( ) {
 printf(“Cinco é igual a %d”, 5);
}
#include<stdio.h>
#include<stdlib.h>
main( ){
 int a=5, b=10;
 printf(“O valor de %d + %d é =”, a, b, a+b);
}
#include<stdio.h>
#include<stdlib.h>
main( ){
 printf(“%s era usado como remédio em %d”, “O ketchup”, 1830);
}
Existe ainda uma maneira de limitar o número máximo de algarismos significativos nos formatadores.
Para arredondamentos:
main( ){
 float a=3456.78;
 printf(“%.2f\n”, a); /* %.2f significa que a quantidade limite de algarismos significativos depois do ponto é 2 */
 printf(“%.1f\n”, a); /* %.1f significa que a quantidade limite de algarismos significativos depois do ponto é 1 */
 printf(“%.3f\n”, a); /* %.3f significa que a quantidade limite de algarismos significativos depois do ponto é 3 */
}
Complementos com zeros à esquerda:
main( ){
 printf(“%04d\n”, 21); /* significa que o valor terá 4 algarismos significativos*/
 printf(“%06d\n”, 21); /* significa que o valor terá 6 algarismos significativos*/
}
Função scanf
Da mesma forma que é importante imprimir dados na tela do computador, há necessidade de entrar com dados pelo teclado.
Sintaxe: scanf (“expressão de controle”, argumentos);
Na expressão de controle valem os mesmos formatadores da função printf.
Os argumentos são precedidos do & indicando uma operação utilizando endereço de memória para armazenar o valor da variável.
Exemplo:
#include<stdio.h>
#include<stdlib.h>
main( ) {
 int num;
 printf(“Digite um número inteiro:\n”);
 scanf(“%d”, &num);
 printf(“O número digitado foi %d”, num);
}
Exemplo de scanf para caracteres:
#include<stdio.h>
#include<stdlib.h>
main( ){
 char nome[50] /* Define um vetor de caracteres com tamanho máximo de 50 posições*/
 printf(“Digite seu nome completo:\n”);
 scanf(“%s”, &nome); /* captura uma string do teclado */
 printf(“\nO nome digitado foi %s”, nome);
}
Observação: Note que o scanf necessita do <enter> como confirmação do dado (int, float, char, string, etc.) digitado para confirmar.
Se o usuário digitar o nome completo:
Ian Joseph Somerhalder
O scanf trunca a string assim que encontra o primeiro espaço em branco, porque o compilador entende que é o fim da string, imprimindo apenas Ian na tela.
Para contornar esse problema utiliza-se outra função, por exemplo:
#include<stdio.h>
#include<stdlib.h>
main( ){
 char nome[50] /* Define um vetor de caracteres com tamanho máximo de 50 posições*/
 printf(“Digite seu nome completo:\n”);
 gets(nome); /* l
 printf(“\nO nome digitado foi %s”, nome);
}
A função gets lê tudo o que foi digitado no teclado até o <enter> ser pressionado. A função não armazena o <enter>, mas adiciona um caractere nulo (\0) para indicar o final da string.
ESTRUTURAS CONDICIONAIS
Instruções Compostas
Como foi visto até agora em exemplos, os comandos foram executados de forma única em uma única instrução, mas para que possa executar várias instruções em um único comando é necessária a utilização de uma instrução composta. As instruções compostas consistem de:
Uma chave aberta ( { )
Uma sequência de instruções (cada uma terminada por ponto e vírgula)
Uma chave fechada ( } )
9.2 Condicional if
Sintaxe: if (condição){
 instrução 1;}
 else{
 instrução 2;}
Onde a condição pode ser uma operação relacional entre 2 ou mais variáveis. Se a condição for verdadeira (diferente de zero), a instrução 1 é executada, caso contrário a instrução 2 será executada. O else é opcional quando se tratar de uma condição simples de teste.
if(condição)
 instrução 1;
Exemplo:
/* Proteção para divisões por zero */
#include <stdio.h>
#include<stdlib.h>
main( ) {
 int a, b;
 printf(“Digite 2 números: \n”);
 scanf(“%d%d”, &a, &b);
 if(b!=0)
 printf(“Divisão= %d \n”, a/b);
 else
 printf(“Divisão por zero”);
}
Condicional if – else – if 
É uma maneira de fazer testes sucessivos quando se tem uma lista de combinações para a variável.
Exemplo:
#include<stdio.h>
#include<stdlib.h>
 main( ) {
 float a, b, c, min, max;
 printf(“Digite 3 números:\n”);
 scanf(“%f%f%f”, &a, &b,& c);
 if(a<b)
 if(a<c){
 min=a; 
 if(b<c)
 max=c; /* condição teste a<b<c */
 else 
 max=b; /* condição teste a<c<b */
 }
 else{ 
 min=c;
 max=b; /* condição teste c<a<b */
 }
 else
 if(a>c){
 max=a;
 if(b>c)
 min=c;
 else
 min=b;
 }
 else{
 max=c;
 min=b;
 }
 printf(“maior valor= %f \n menor valor= %f \n”, max, min);
}
LAÇOS
Laços (ou em inglês – loops) são estruturas utilizadas quando houver a necessidade de sucessivas repetições durante, por exemplo, uma condição de testes. Pode ser utilizado também para implementar cálculos sucessivos (séries matemáticas), incrementando ou decrementando variáveis ou funções.
Laço for
Sintaxe: for (inicialização; condição; incremento/ decremento){
 Comando;}
Onde:
Inicialização: normalmente é uma atribuição a uma variável índice.
Condição: é a expressão de teste sobre a condição da variável índice, em relação a um parâmetro de comparação ou igualdade.
Incremento/ Decremento: alguma modificação (aumentando ou diminuindo) a variável índice a fim/ ou não de estabelecer a condição.
Exemplo:
#include<stdio.h>
#include<stdlib.h>
main( ){
 int x;
 printf(“Imprime a sequência de 1 a 1000 na tela \n”);
 for (x=1; x<=1000; x++)
 printf(“%d\n”, x); /* imprime o número e pula uma linha */
 }
Observação: note que o ponto e vírgula vem somente no final do comando (nesse exemplo o printf).
O resultado da execução do programa é uma sequência impressa na tela de 1 até o número 1000, porque a condição incrementa o x(x++). Se quisesse fazer uma contagem regressiva de 1000 a 1, a linha de comando muda para:
for (x=1000; x>=1; x--)
Laço while
É o laço mais simples de todos. Normalmente um laço substitui o outro, porém alguns trazem vantagens ou facilidade em relação aos outros dependendo da aplicação.
Sintaxe: while(condição){
 Instrução;}
O comando while testa a condição e executa a instrução, ou conjunto de instruções, no caso da instrução composta. Terminado a execução das instruções, retorna à condição, se for satisfeita, executa a instrução novamente, e assim sucessivamente. Dependendo da condição impostapode se tornar um loop infinito.
Exemplo:
/*Programa que imprime os números de 1 até 10 */
#include<stdio.h>
int main( ) { /* Função principal do tipo inteira */
 int i=0;
 while(i<=10){
 printf(“numero %d\n”, i);
 i++;
 }
return(0); /* retorno da função principal */
}
Laço do-while 
A principal diferença do do-while em relação ao while é que os comandos existentes no laço do-while sempre são executados ao menos uma vez, porque a condição de teste está no final do loop.
Sintaxe: do {
 intruções;
 } while(condição);
Exemplo:
/* Programa que imprime os divisores (no intervalo de 1 a 10) de um número */
#include<stdio.h>
#include<stdlib.h>
main ( ){
int n, j=0;
printf(“Digite um numero\n”);
scanf(“%d\n”, &n);
do{ 
 ++j; /* incrementa antes*/
 if(n%j==0){
 printf(“%d é divisor de %d”, j, n);
 }while(j<=10);
} 
EXERCÍCIOS RESOLVIDOS
Questão 1- Imprimir todos os números de 1 até 100 e a soma deles. 
Explanação da questão: Para imprimir todos os números de 1 até 100 será necessário duas variáveis, uma para os números e outra para a soma desses números. Será necessário também utilizar uma estrutura de repetição que começa do número 1 e termina no número 100, com o acréscimo de +1 à cada repetição; e terá as seguintes instruções: imprimir cada número e acrescentar à variável soma (nome utilizado no exercício) o valor de cada número.
Observação válida para todas as questões: No algoritmo, as variáveis estão em negrito para facilitar a visualização das mesmas. E o símbolo ‘←’ (seta contrária) significa que a variável ‘recebe’ algo, isto é, o que vem após a mesma.
Algoritmo: 
Início Exercicio1
 Inteiro i, soma
 soma←0 
 Imprima 'Programa que imprime todos os números de 1 até 100 e sua soma'
 Faça i←1 até 100, i← i+1
 Imprima i
 soma←soma+i
 Fim Faça
 Imprima 'A soma de todos os números de 1 até 100 é', soma
Fim
Linguagem C:
#include<stdio.h> /* Biblioteca de entrada e saída de dados*/
#include <stdlib.h>/* Biblioteca de alocação de memória e conversões*/
int main( ){ /*Função principal, tipo: Inteiro, ou seja, retorna um valor inteiro*/
	int i=1, soma=0; /* Declaração das variáveis, tipo: Inteiro */
	printf("Programa que imprime todos os números de 1 ate 100 e sua soma \n\n"); /* 'printf' - Função padrão para exibir mensagens */
 for(i=1;i<=100;i++){ /* Laço de repetição */
 	printf("%d \n", i); 
		soma=soma+i; /* Incremento de cada numero*/
 }
 printf("\nA soma de todos os números de 1 ate 100 e: %d", soma);
	
	printf("\n\n");	/* '\n' (barra invertida-n): comando utilizado para saltar linha*/
	return(0); /*retorno da função principal*/
	system("pause"); /* comando utilizado para pausar a tela*/	
}
Resultados: Como esperado, o programa imprime ordenadamente os números de 1 até 100 e a soma dos mesmos.
SOFTWARE - QUESTÃO 1
Questão 2 - Imprimir todos os números de 100 até 1.
Explanação da questão: Para imprimir todos os números de 100 até 1 será necessário uma variável para os números e também uma estrutura de repetição, que vai de 100 até 1, com o decremento de -1 à cada repetição. A estrutura terá a instrução de imprimir cada número do laço.
Algoritmo:
Início Exercicio2
 Inteiro i 
 Imprima 'Programa que imprime todos os números de 100 até 1'
 Faça i ←100 até 1,i← i -1
 Imprima i
 Fim faça
Fim
Linguagem C:
#include<stdio.h> /* Biblioteca de entrada e saida de dados*/
#include <stdlib.h>/* Biblioteca de alocação de memória e conversões*/
int main(){ /*Função principal, tipo: Inteiro, ou seja, retorna um valor inteiro*/
	int i; /*Declaração das variáveis, tipo: Inteiro*/
	printf("Programa que imprime todos os numeros de 100 ate 1 \n\n"); /* 'printf' - Função padrão para exibir mensagens*/
	for(i=100;i>=1;i--){ /* Laço de repetição condicional */
		printf("%d \n", i); 
	}
	return(0); /*retorno da função principal*/
}
Resultados: Como esperado, o programa imprime ordenadamente os números de 100 até 1.
SOFTWARE – QUESTÃO 2
Questão 3 - Imprimir os cem primeiros números pares. 
Explanação da questão: Para imprimir os 100 primeiros números pares, utilizou-se do conhecimento da matemática que diz que se o resto da divisão de um número por dois for igual a zero, então esse número é par. Sabendo-se disso, utilizou-se uma estrutura de repetição condicional (faça enquanto/while), que executará determinadas instruções enquanto for satisfeita uma condição. As instruções foram: testar se os números são pares, utilizando uma estrutura condicional (se/if) e acrescentar 1 à variável i (variável que esta sendo testada) a cada repetição. A condição utilizada na estrutura de repetição condicional (faça enquanto/while) foi: faça enquanto soma (é a quantidade de números pares) for menor que 100. E a estrutura condicional (se/if) foi: se o resto da divisão de i por dois for igual a zero, acrescenta-se 1 à variável soma e imprime o número i, que segundo à matemática é par. Quando a variável soma for igual a 100, o laço de repetição é encerrado. 
Algoritmo:
Início Exercicio3
 Inteiro i, soma
 i←1
 soma←0
 Imprima 'Programa que imprime os 100 primeiros números pares'
 Faça enquanto (soma<100) 
 Se (mod(i,2)=0) então
 Imprima i
 soma ←soma+1
 Fim se
 i←i+1
 Fim faça
Fim
Linguagem C:
#include<stdio.h> /* Biblioteca de entrada e saida de dados*/
#include <stdlib.h> /* Biblioteca de alocação de memória e conversões*/
int main(){ /*Função principal, tipo: Inteiro, ou seja, retorna um valor inteiro*/
	int soma=0, i=1; /* Declaração das variáveis, tipo: Inteiro */
	printf("Programa que imprime os 100 primeiros numeros pares: \n\n"); /* 'printf' - Função padrão para exibir mensagens*/
	while(soma<100){ /* Laço de repetição condicional */
		if(i%2==0){ /*Estrutura condicional */
			printf("%d\n", i);
			soma++; /*Incremento: acrescimo que conta quantos numeros são pares*/
		
		}
		i++; /*Incremento: acrescimo ordenado*/
	}
	return(0); /*retorno da função principal*/
}
Resultados: Como esperado, foram impressos os 100 primeiros números pares.
SOFTWARE – QUESTÃO 4
Questão 4 - Imprimir os múltiplos de 5 no intervalo de 1 até 500. 
Explanação da questão: Para resolver está questão será necessário utilizar um conhecimento da matemática que diz: quando um número é divisível por outro, isto é, o resto da divisão destes for igual a zero, dizemos que os números são múltiplos. Sabendo-se disso, utilizou-se uma estrutura de repetição condicional (faça enquanto/while), que executará determinadas instruções enquanto for satisfeita uma condição. As instruções foram: testar se os números são múltiplos (utilizando uma estrutura condicional (se/if) e acrescentar 1 à variável i (variável que esta sendo testada) a cada repetição. A condição utilizada na estrutura de repetição condicional (faça enquanto/while) foi: faça enquanto i for menor que 500. E a estrutura condicional (se/if) foi: se o resto da divisão de i por cinco for igual a zero, o programa imprimirá o número i, que segundo a matemática é múltiplo de 5. Quando a variável i for igual a 500, o laço de repetição é encerrado. 
Algoritmo:
Início Exercicio4
 Inteiro i
 i=1
 Imprima 'Programa que imprime os múltiplos de 5 de 1 até 500'
 Faça enquanto (i<=500)
 Se (mod(i,5)=0) então
 Imprima i
 Fim se
 i←i+1
 Fim Faça
Fim
Linguagem C:
#include<stdio.h> /* Biblioteca de entrada e saida de dados*/
#include <stdlib.h> /* Biblioteca de alocação de memória e conversões*/int main(){ /*Função principal, tipo: Inteiro, ou seja, retorna um valor inteiro*/
 	int i=1; /* Declaração das variáveis, tipo: Inteiro */
 	printf("Programa que imprime os multiplos de 5 de 1 até 500\n\n"); /* 'printf' - Função padrão para exibir mensagens*/
 	while(i<=500){ /* Laço de repetição condicional */
 		if(i%5==0){ /*Estrutura condicional */
 			printf("%d\n",i);
 		}
 		i++; /* Incremento */
 	}
	 return(0); /*retorno da função principal*/
 }
Resultados: O programa imprimirá os múltiplos de 5 de 1 até 500.
SOFTWARE – QUESTÃO 4
Questão 5 - Ler 10 números e imprima a metade de cada número.
Explanação da questão: O programa irá ler 10 números e imprimir a metade de cada um. Para isso, utilizou-se uma estrutura de repetição, de 1 até 10, com o incremento de 1 à cada repetição; com as seguintes instruções: uma mensagem para que o usuário digite um número, um comando para que o usuário possa digitar o número e uma mensagem com a metade do número digitado (para isso utiliza-se o operador matemático(/) de divisão). Após o usuário digitar os 10 números e as mensagens forem impressas na tela do computador, o programa será encerrado. 
 
Algoritmo:
Início Exercício5
 Inteiro i
 Real n
 Imprima 'Programa que lê 10 números e calcula a metade de cada.'
 Faça i← 1 até 10, i← i+1
 Imprima 'Digite um número'
 Leia n
 Imprima 'A metade de', n, 'é', n/2
 Fim faça
Fim
Linguagem C:
#include<stdio.h>/* Biblioteca de entrada e saida de dados*/
#include <stdlib.h> /* Biblioteca de alocação de memória e conversões*/
 int main(){ /*Função principal, tipo: Inteiro, ou seja, retorna um valor inteiro*/
 	int i; /* Declaração das variáveis, tipo: Inteiro */
 	float n; /* Declaração das variáveis */
 	printf("Programa que le 10 numeros e calcula a metade de cada.\n"); /* 'printf' - Função padrão para exibir mensagens*/
 	for(i=1; i<=10;i++){ /* Laço de repetição */
 		printf("\nDigite um numero: \n\n");
 		scanf("%f",&n); /*Função padrão para entrada de dados, tipo: '%f' - Real */
 		printf("\nA metade de %f e: %f", n, n/2);
 	}
 	return(0); /*retorno da função principal*/
 }
Resultados: após digitar cada número, o programa imprimirá a metade dos mesmos. Após as 10 repetição será encerrado.
SOFTWARE – QUESTÃO 5
Questão 6 - Ler um número de entrada (num), leia n números inteiros da entrada e imprima o maior deles. Não suponha que todos os números serão positivos. 
Explanação da questão: A questão pede para que no programa o usuário possa digitar a quantidade de números que ele quer comparar, digite esses números e compare qual deles é o maior. Para isso, armazenou-se na variável maior o primeiro número digitado e depois foi utilizada uma estrutura de repetição que vai de 1 até num-1(pois já foi lido o primeiro número) e dentro dessa estrutura de repetição utilizou-se uma estrutura condicional, com a seguinte condição: se o número digitado for maior que a variável maior, a variável maior receberá esse número. Após os testes, o programa imprimirá no final o maior número digitado.
Algoritmo:
Início Exercício6
 Inteiro i, num, n, maior
 Imprima 'Programa que calcula o maior número'
 Imprima 'Digite a quantidade de números de entrada'
 Leia num
 Se (num>=1) então
 Imprima 'Digite um número'
 Leia n
 maior← n
 Faça i← 1 até num -1, i« i+1
 Imprima 'Digite um número'
 Leia n
 Se (n>maior) então
 maior← n
 Fim se
 Fim faça
 Imprima 'O maior número digitado foi', maior
 Senão
 Imprima 'Número inválido'
 Fim se
Fim
Linguagem C:
#include<stdio.h> /* Biblioteca de entrada e saida de dados*/
#include <stdlib.h> /* Biblioteca de alocação de memória e conversões*/
 int main(){ /*Função principal, tipo: Inteiro, ou seja, retorna um valor inteiro*/
 	int i, num, n, maior; /* Declaração das variáveis, tipo: Inteiro */
 	printf("Programa que calcula o maior numero.\n\n"); /* 'printf' - Função padrão para exibir mensagens*/
 	printf("Digite a quantidade de numeros de entrada:\n");
 	scanf("%d", &num); /*Função padrão para entrada de dados, tipo: '%d' - Inteiro */
 	if(num>=1){ /*Estrutura condicional */
 		printf("\nDigite um numero\n");
 		scanf("%d",&n); /*Função padrão para entrada de dados, tipo: '%d' - Inteiro */
 		maior=n;
 		for(i=1; i<= num-1;i++){ /* Laço de repetição */
 	 printf("\nDigite um numero\n");
 	 scanf("%d",&n); /*Função padrão para entrada de dados, tipo: '%d' - Inteiro */
 	 if(n>maior) maior=n; /*Estrutura condicional */
 	 }
 	 printf("O maior numero digitado foi %d", maior);
 	}
 	
 else{ /*Estrutura condicional */
 	printf("Numero Invalido");
 }
 	return(0); /*retorno da função principal*/
 	
 }
Resultados: O programa verificará qual o maior número dentre os digitados pelo usuário e o imprimirá na tela.
SOFTWARE – QUESTÃO 6
Questão 7 - Ler um número de entrada (num), leia n números inteiros da entrada e imprima o maior e menor deles. Não suponha que todos os números serão positivos. 
Explanação da questão: A questão pede para que no programa o usuário possa digitar a quantidade de números que ele quer comparar, digite esses números e imprima qual é o maior e o menor número digitado. Para isso, armazenou-se na variável maior e na variável menor o primeiro número digitado e depois foi utilizada uma estrutura de repetição que vai de 1 até num-1(pois já foi lido o primeiro número) e dentro dessa estrutura de repetição utilizou-se duas estruturas condicionais, a primeira com a seguinte condição: se o número digitado for maior que a variável maior, a variável maior receberá esse número. E outra estrutura de repetição com a condição: se o número digitado for menor que a variável menor, a variável menor receberá esse número. Após os testes, o programa imprimirá no final o maior e o menor número digitado.
Algoritmo:
Início Exercicio7
Inteiro num, n, i, maior, menor
Imprima 'Programa que calcula o maior e o menor número'
Imprima ' Digite a quantidade de números de entrada'
Leia num
Se (num>=1) então
 Imprima 'Digite um número'
 Leia n
 maior←n
 menor← n
 Faça i← 1 até num-1, i← i+1
 Imprima 'Digite um número'
 Leia n
 Se (n>maior) então
 maior←n
 Fim se
 Se (n<menor) então
 menor←n
 Fim se
 Fim faça
 Imprima 'O maior número digitado foi', maior, 'e o menor número digitado foi', menor
 Senão
 Imprima 'Número inválido'
Fim se
Fim
Linguagem C:
#include<stdio.h> /* Biblioteca de entrada e saida de dados*/
#include <stdlib.h> /* Biblioteca de alocação de memória e conversões*/
 int main(){ /*Função principal, tipo: Inteiro, ou seja, retorna um valor inteiro*/
 	int num, n, i, maior, menor; /* Declaração das variáveis, tipo: Inteiro */
 	printf("Programa que calcula o maior e o menor numero.\n\n"); /* 'printf' - Função padrão para exibir mensagens*/
 	printf("Digite a quantidade de numeros de entrada:\n");
 	scanf("%d", &num); /*Função padrão para entrada de dados, tipo: '%d' - Inteiro */
 	if(num>=1){ /*Estrutura condicional */
 		printf("\nDigite um numero:\n");
 		scanf("%d",&n); /*Função padrão para entrada de dados, tipo: '%d' - Inteiro */
 		maior=n;
 		menor=n;
 		for(i=1;i<=num-1;i++){ /* Laço de repetição */
 			printf("Digite um numero:\n");
 			scanf("%d", &n); /*Função padrão para entrada de dados, tipo: '%d' - Inteiro */
 			if(n>maior) maior=n;/*Estrutura condicional */
 			if(n<menor) menor=n; /*Estrutura condicional */
 		}
 		printf("\n\nO maior numero digitado foi %d e o menor numero digitado foi %d", maior, menor);
 	}
 	else{ /*Estrutura condicional */
 		printf("Numero Invalido"); 
 	}
 	
 return(0); /*retorno da função principal*/
 }
Resultados: O programa imprimirá o maior e o menor número, dentre os digitados pelo usuário.
SOFTWARE – QUESTÃO 7
Questão 8 - Ler a quantidade de números que se deseja digitar para que possa ser impresso o maior e menor número digitado. 
Explanação da questão: resolução igual a questão anterior. Foi modificado apenas os nomes das variáveis.
Algoritmo:
Início Exercício8
 Inteiro q, numero, i, maior, menor
 Imprima 'Programa que calcula o maior e o menor número digitado'
 Imprima ' Digite a quantidade de números de entrada'
 Leia q
 Se (q>=1) então
 Imprima 'Digite um número'
 Leia numero
 maior← numero
 menor← numero
 Faça i← 1 até q-1, i← i+1
 Imprima 'Digite um número'
 Leia numero
 Se (numero>maior) então
 maior← numero
 Fim se
 Se (numero<menor) então
 menor← numero
 Fim se
 Fim faça
 Imprima 'O maior número digitado foi', maior, 'e o menor número digitado foi', menor
 Senão
 Imprima 'Número inválido'
Fim se
Fim
Linguagem C:
#include<stdio.h> /* Biblioteca de entrada e saida de dados*/
#include <stdlib.h> /* Biblioteca de alocação de memória e conversões*/
 int main(){ /*Função principal, tipo: Inteiro, ou seja, retorna um valor inteiro*/
 	 int q, numero, i, maior, menor; /* Declaração das variáveis, tipo: Inteiro */
 	 printf("Programa que calcula o maior e o menor numero digitado\n\n"); /* 'printf' - Função padrão para exibir mensagens*/
 	 printf("Digite a quantidade de numeros de entrada:\n");
 	 scanf("%d",&q); /*Função padrão para entrada de dados, tipo: '%d' - Inteiro */
 	 if(q>=1){ /*Estrutura condicional */
 	 	 printf("\nDigite um numero:\n");
 	 	 scanf("%d",&numero); /*Função padrão para entrada de dados, tipo: '%d' - Inteiro */
 	 	 maior=numero;
 	 	 menor=numero;
 	 	 for(i=1;i<=q-1;i++){ /* Laço de repetição */
 	 	 	 printf("\nDigite um numero:\n");
 	 	 	 scanf("%d", &numero); /*Função padrão para entrada de dados, tipo: '%d' - Inteiro */
 	 	 	 if(numero>maior) maior=numero; /*Estrutura condicional */
 	 	 	 if(numero<menor) menor=numero; /*Estrutura condicional */
 	 	 	 
 	 	 }
 	 	 printf("O maior numero digitado foi %d e o menor numero digitado foi %d.", maior, menor);
 	 }
 	 else{ /*Estrutura condicional */
 	 	 printf("Numero Invalido");
 	 }
 	 
 	return(0); /*retorno da função principal*/
 }
Resultados: O programa imprimirá o maior e o menor número digitado pelo usuário.
SOFTWARE – QUESTÃO 8
Questão 9 - Entrar com 12 números e imprimir a média desses números. 
Explanação da questão: O programa terá que receber 12 números e calcular a sua média. Para isso, utiliza-se uma estrutura de repetição de 1 até 12, com acréscimo de 1 a cada repetição, com as seguintes instruções: imprimir a mensagem para que o usuário digite um número, leia esse numero e acrescente esse número à variável soma(que tem valor inicial igual a zero). Após o usuário ter digitado os 12 números, o programa imprimirá a média desses números utilizando o operador aritmético (/). A média será igual a soma/12.
Algoritmo:
Início Exercício9
 Real soma, numero
 Inteiro i
 soma←0
 Imprima 'Programa que calcula a média de 12 números'
 Faça i← 1 até 12, i← i+1
 Imprima 'Digite um número'
 Leia numero
 soma← soma+ numero
 Fim faça
 Imprima 'A média dos números digitados é', soma/12
Fim
Linguagem C:
#include<stdio.h> /* Biblioteca de entrada e saida de dados*/
#include <stdlib.h> /* Biblioteca de alocação de memória e conversões*/
 
 int main(){ /*Função principal, tipo: Inteiro, ou seja, retorna um valor inteiro*/
 	float soma=0, numero; /* Declaração das variáveis, tipo: Real */
 	int i; /* Declaração das variáveis, tipo: Inteiro */
 	printf("Programa que calcula a media de 12 numeros.\n\n"); /* 'printf' - Função padrão para exibir mensagens*/
 	for(i=1; i<=12;i++){ /* Laço de repetição */
 		printf("Digite um numero:\n");
 		scanf("%f", &numero); /*Função padrão para entrada de dados, tipo: '%f' - Real */
 		soma=soma+numero;
 	}
 	printf("A media dos numeros digitados e: %f", soma/12);
 	return(0); /*retorno da função principal*/
 }
Resultados: Após o usuário digitar os 12 números, o programa imprimirá a média dos mesmos.
SOFTWARE – QUESTÃO 9
Questão 10 - Entrar com nome, nota da 1ª prova e nota da 2ª prova de 15 alunos. Imprimir uma listagem, contendo: nome, nota da 1a. prova, nota da 2ª prova, média de cada aluno. Ao final calcule a média geral da turma. 
Explanação da questão: No programa o usuário deverá digitar: o nome, as notas da 1ª e 2ª prova de 15 alunos. Para isso, será necessário utilizar um laço de repetição de 1 até 15, com acréscimo de 1 ao índice (i) à cada repetição. As instruções dentro do laço serão: mensagem para que o usuário digite o nome, ler o nome, mensagem para que o usuário digite a nota da 1ª prova, ler a nota da 1ª prova, mensagem para que o usuário digite a nota da 2ª prova, ler a 2ª nota. Após digitar os dados, o programa imprimirá os mesmos na tela. Ainda dentro do laço, a variável média receberá a nota 1 e a nota 2, e esse valor será dividido por 2 e depois será impresso na tela para que o usuário saiba a média de cada aluno. Além disso (ainda dentro do laço), uma variável soma (que possui valor inicial igual a zero) receberá a cada repetição o valor de cada média. Após o laço, o programa imprimirá a média geral da turma, que será a variável soma dividido por 15.
Algoritmo:
Início Exercício10
 Real n1, n2, media, soma, mediag 
 Caracter nome
 Integer i
 soma« 0
 Imprima 'Programa que calcula a média dos alunos e a média geral da turma'
 Faça i←1 até 15, i← i+1
 Imprima 'Digite o nome do aluno'
 Leia nome
 Imprima 'Digite a nota da 1a prova'
 Leia n1
 Imprima 'Digite a nota da 2a prova'
 Leia n2
 media← (n1+n2)/2
 soma← soma+ media
 Imprima 'Nome do aluno', nome
 Imprima 'Nota da 1a prova', n1
 Imprima 'Nota da 2a prova', n2
 Imprima 'Média do aluno', media
 End do
 mediag← soma/15
 Imprima 'A média geral da turma é', mediag
Fim
Linguagem C:
#include<stdio.h> /* Biblioteca de entrada e saida de dados*/
#include <stdlib.h> /* Biblioteca de alocação de memória e conversões*/
 
 int main(){ /*Função principal, tipo: Inteiro, ou seja, retorna um valor inteiro*/
 	float n1, n2, media, soma=0, mediag; /* Declaração das variáveis, tipo: Real */
 	char nome[16][30]; /* Declaração das variáveis, tipo: Inteiro */
 	int i; /* Declaração das variáveis */
 	printf("Programa que calcula a média dos alunos e a média geral da turma.\n\n"); /* 'printf' - Função padrão para exibir mensagens*/
 for(i=1;i<=15;i++){ /* Laço de repetição */
 	fflush (stdin);
 	printf("Digite o nome do aluno:\n");
 	gets(nome[i]); /* Função para entrada de dados do tipo string */
 	printf("\nDigite a nota da 1a prova:\n");
 	scanf("%f", &n1); /*Função padrão para entrada de dados, tipo: '%f' - Real */
 	printf("\nDigite a nota da 2a prova:\n");scanf("%f",&n2); /*Função padrão para entrada de dados, tipo: '%f' - Real */
 	media=(n1+n2)/2;
 	soma=soma+media;
 	printf("\nNome do aluno: %s\n", nome[i]);
 	printf("\nNota da 1a prova: %.2f\n", n1);
 	printf("\nNota da 2a prova: %.2f\n", n2);
 	printf("\nMedia do aluno: %.2f\n", media);
 }
 mediag=soma/15;
 printf("\nA media geral da turma e: %.2f\n", mediag);
 	return(0); /*retorno da função principal*/
 }
Resultados: Após digitar os dados dos 15 alunos de uma turma, o programa imprimirá o nome, as notas da 1ª e 2ª prova e a média de cada aluno. No final, o programa imprimirá a média geral da turma.
SOFTWARE – QUESTÃO 10
Questão 11 - Entrar com 15 números e imprimir quantos números maiores que 30 foram digitados. 
Explanação da questão: No programa o usuário deverá entrar com 15 números e no final deverá imprimir quantos números, dentre os digitados, são maiores que 30. Para isso, será necessário um laço de repetição de 1 até 15, com o acréscimo de 1 ao índice (i), à cada repetição. Dentro do laço terá as seguintes instruções: uma mensagem para que o usuário digite um número, ler esse número e uma estrutura condicional que testará se o número digitado é maior que 30, se sim, ele acrescentará 1 á variável q, que possui valor inicial igual a 0. Após o laço, o programa imprimirá o valor de q, que corresponde a quantidade de números maiores que 30.
Algoritmo:
Início Exercício11
 Real numero
 Integer i, q
 q←0
 Imprima 'Programa que calcula quantos números são maiores que 30, dentre os 15 digitados'
 Faça i← 1 até 15, i← i+1
 Imprima 'Digite um número'
 Leia numero
 Se (numero>30) então
 q←q +1
 Fim se
 Fim faça
Imprima 'Dentre os 15 números digitados', q, 'são maiores que 30'
Fim
Linguagem C:
#include<stdio.h> /* Biblioteca de entrada e saida de dados*/
#include <stdlib.h> /* Biblioteca de alocação de memória e conversões*/
int main(){ /*Função principal, tipo: Inteiro, ou seja, retorna um valor inteiro*/
	float numero; /* Declaração das variáveis, tipo: Real */
	int i, q=0; /* Declaração das variáveis, tipo: Inteiro */
	printf("Programa que calcula quantos numeros são maiores que 30, dentre os 15 digitados\n\n"); /* 'printf' - Função padrão para exibir mensagens*/
	for(i=1;i<=15;i++){ /* Laço de repetição */
		printf("\nDigite um numero:\n");
		scanf("%f",&numero); /*Função padrão para entrada de dados, tipo: '%f' - Real */
		if(numero>30) /*Estrutura condicional */
		 q++; /*Incremento*/
	}
	printf("Dentre os 15 numeros digitados, %d sao maiores que 30", q);
	return(0); /*retorno da função principal*/
}
Resultados: O usuário digitará 15 números e o programa imprimirá quantos números, dentre os digitados são maiores que 30. 
SOFTWARE – QUESTÃO 11
Questão 12 - Entrar com 20 números e imprimir a soma dos positivos e o total de números negativos. 
Explanação da questão: A questão pede um programa em que o usuário digite 20 números e no final, imprima a soma dos números positivos e o total de números negativos. Será necessário usar um laço de repetição de 1 até 20, com acréscimo de 1 ao índice à cada repetição. O laço terá as seguintes instruções: uma mensagem para que o usuário digite um número; ler o número; uma estrutura de repetição que testará se o número é positivo ou negativo, se for positivo ele acrescentará o valor do número à variável soma (que possui valor inicial igual a zero. Se for negativo, ele acrescentará 1 à variável q, que corresponde à quantidade. Após o laço, o programa imprimirá a soma dos números positivos e a quantidade de números negativos. 
Algoritmo:
Início Exercício12
 Real numero, soma
 Inteiro i, q
 soma← 0
 q←0
 Imprima 'Programa que calcula a soma dos números positivos e a quantidade de números negativos, dentre os 20 números digitados.'
 Faça i← 1 até 20, i← i+1
 Imprima 'Digite um número'
 Leia numero
 Se (numero>0) então
 soma←soma+ numero
 Fim se
 Se (numero<0) então
 q←q+1
 Fim se
 Fim faça
 Imprima 'A soma dos números positivos é', soma
 Imprima 'Dentre os números digitados,', q, 'são negativos.'
Fim
Linguagem C:
#include<stdio.h> /* Biblioteca de entrada e saida de dados*/
#include <stdlib.h> /* Biblioteca de alocação de memória e conversões*/
 int main(){ /*Função principal, tipo: Inteiro, ou seja, retorna um valor inteiro*/
 	float numero, soma=0; /* Declaração das variáveis, tipo: Real */
 	int i,q=0; /* Declaração das variáveis, tipo: Inteiro */
 	printf("Programa que calcula a soma dos numeros positivos e a quantidade de numeros negativos, dentre os 20 numeros digitados.\n\n"); 
 	for(i=1;i<=20;i++){ /* Laço de repetição */
 		printf("\nDigite um numero:\n"); /* 'printf' - Função padrão para exibir mensagens*/
 		scanf("%f",&numero); /*Função padrão para entrada de dados, tipo: '%f' - Real */
 		if(numero>0) soma=soma+numero; /*Estrutura condicional */
 		if(numero<0) /*Estrutura condicional */ 
		 q++; /*Incremento*/
 		
 	}
 	printf("\nA soma dos numeros positivos e: %f", soma);
 	printf("\n\nDentre os numeros digitados, %d sao negativos", q);
 	return(0); /*retorno da função principal*/
 }
Resultados: O usuário irá digitar 20 números e no final o programa imprimirá a soma dos números positivos e a quantidade de números negativos.
SOFTWARE – QUESTÃO 12
Questão 13 - Permitir escolher qual a tabuada de multiplicar que se deseja imprimir e imprimir esta tabuada. 
Explanação da questão: No programa, o usuário deverá digitar o número da tabuada que deseja e o programa deverá imprimir a tabuada do mesmo. Para isso, utilizou-se um laço de repetição de 1 até 10 (geralmente a tabuada vai até 10, mas isso fica a critério do programador), com o acréscimo de 1 à cada repetição. Dentro do laço deverá ter a instrução para imprimir o produto do índice (i) e do número digitado.
Algoritmo:
Início Exercício 13
 Inteiro i, tab
 Imprima 'Programa da tabuada de multiplicar'
 Imprima 'Digite o número da tabuada de multiplicação que deseja'
 Leia tab
 Faça i← 1 até 10, i← i+1
 Imprima tab, 'x', i, '=', tab*i
 Fim faça
Fim
Linguagem C:
#include<stdio.h> /* Biblioteca de entrada e saida de dados*/
#include <stdlib.h> /* Biblioteca de alocação de memória e conversões*/
int main(){ /*Função principal, tipo: Inteiro, ou seja, retorna um valor inteiro*/
	int i, tab; /* Declaração das variáveis, tipo: Inteiro */
	printf("Programa da tabuada de multiplicar\n\n"); /* 'printf' - Função padrão para exibir mensagens*/
	printf("Digite o numero da tabuada de multiplicacao que deseja\n");
	scanf("%d", &tab); /*Função padrão para entrada de dados, tipo: '%d' - Inteiro */
	for(i=1; i<=10;i++){ /* Laço de repetição */
		printf("%d x %d = %d \n\n", tab,i,tab*i);
	}
	return(0); /*retorno da função principal*/
}
Resultados: Como esperado, o programa imprimirá a tabuada do número digitado.
SOFTWARE – QUESTÃO 13
Questão 14 - Entrar com números enquanto forem positivos e imprimir quantos números positivos foram digitados. 
Explanação da questão: no programa o usuário deverá digitar um número, se o número for positivo, o programa pedirá que o usuário digite outro número, ou seja, enquanto os números fornecidos pelo usuário forem positivos, o programa continuará pedindo que se digite um novo número e só interromperá o programa quando for digitado um número negativo. Para isso, será necessário usar estruturas de condição e laços de repetição. Além disso, o programa deverá ter uma variável (q) que armazenaráa quantidade de números positivos digitados.
Algoritmo: 
Início Exercício 14
 Inteiro numero, q
 q←0
 Imprima 'Programa que calcula a quantidade de números positivos digitados'
 Imprima 'Digite um número'
 Leia numero
 Se (numero>0) então
 q←q+1
 Faça enquanto(numero>0)
 Imprima 'Digite um número'
 Leia numero
 Se(numero>0) então
 q←q+1
 Fim se
 Fim faça
 Fim se
Imprima 'A quantidade de números positivos digitados é', q
Fim
Linguagem C:
#include<stdio.h> /* Biblioteca de entrada e saida de dados*/
#include <stdlib.h> /* Biblioteca de alocação de memória e conversões*/
 int main(){ /*Função principal, tipo: Inteiro, ou seja, retorna um valor inteiro*/
 	int numero, q=0; /* Declaração das variáveis, tipo: Inteiro */
 	printf("Programa que calcula a quantidade de numeros positivos digitados. \n\n");
 	printf("Digite um numero:\n"); /* 'printf' - Função padrão para exibir mensagens*/
 	scanf("%d", &numero); /*Função padrão para entrada de dados, tipo: '%d' - Inteiro */
 	fflush (stdin);
 	if(numero>0) /*Estrutura condicional */
	 q++; /* Incremento*/
 	
 	while(numero>0){ /* Laço de repetição condicional */
 		
 		printf("\nDigite um numero:\n");
 		scanf("%d", &numero); /*Função padrão para entrada de dados, tipo: '%d' - Inteiro */
 		
 		if(numero>0) /*Estrutura condicional */
		 q++; /* Incremento*/
 		
 	}
 	printf("A quantidade de numeros positivos digitados e: %d", q);
 	return(0); /*retorno da função principal*/
 	
 }
 
Resultados: O programa só será finalizado quando o usuário digitar um número negativo e então imprimirá a quantidade de números positivos fornecidos pelo usuário. 
SOFTWARE – QUESTÃO 14
 Questão 15 - Receber a idade e o peso de 20 pessoas. Calcular e imprimir as médias dos pesos das pessoas da mesma faixa etária. As faixas etárias são: de 1 a 10 anos, de 11 a 20 anos, de 21 a 30 anos e maiores de 30 anos. 
Explanação da questão: O programa deverá receber a idade e o peso de 20 pessoas. Para calcular a média dos pesos por faixa etária, o programa deverá ter variáveis para a soma dos pesos e quantidade de pessoas por faixa etária correspondentes. Para isso, deverá ser usado um laço de 1 até 20, com acréscimo de 1 ao índice(i) à cada repetição. E estruturas de condição para testar em qual faixa etária está cada pessoa e assim, armazenar os pesos nas variáveis correspondentes à cada faixa etária e a quantidade das mesmas. No final o programa deverá imprimir a média dos pesos por faixa etária, que é obtido pelo quociente da soma dos pesos pela quantidade de pessoas.
Algoritmo:
Início Exercício15
 Real soma1, soma2, soma3, soma4, peso
 Inteiro i, idade, q1, q2, q3, q4
 soma1←0
 soma2←0
 soma3←0
 soma4←0
 q1←0
 q2←0
 q3←0
 q4←0
 Imprima 'Programa que calcula a média dos pesos de pessoas da mesma faixa etária.'
 Faça i←1 até 20, i← i+1
 Imprima 'Digite a idade'
 Leia idade
 Imprima 'Digite o peso'
 Leia peso
 Se(idade>=1 e idade<=10) então
 soma1←soma1+ peso
 q1←q1+1
 Fim se
 Se(idade>=11 e idade<=20) então
 soma2← soma2+peso
 q2← q2+1
 Fim se
 Se (idade>=21 e idade<=30) então
 soma3← soma3+peso
 q3← q3+1
 Fim se
 Se (idade>30) então
 soma4← soma4+peso
 q4← q4+1
 Fim se
 Fim faça
 Imprima 'A média dos pesos de pessoas da faixa etária de 1 à 10 anos é', soma1/q1
 Imprima 'A média dos pesos de pessoas da faixa etária de 11 à 20 anos é', soma2/q2
 Imprima 'A média dos pesos de pessoas da faixa etária de 21 à 30 anos é', soma3/q3
 Imprima 'A média dos pesos de pessoas com faixa etária maior de 30 anos é', soma4/q4
Fim
Linguagem C:
#include<stdio.h> /* Biblioteca de entrada e saida de dados*/
#include <stdlib.h> /* Biblioteca de alocação de memória e conversões*/
 int main(){ /*Função principal, tipo: Inteiro, ou seja, retorna um valor inteiro*/
 	float soma1=0, soma2=0, soma3=0, soma4=0, peso; /* Declaração das variáveis, tipo: Real */
 	int i, idade, q1=0, q2=0, q3=0, q4=0; /* Declaração das variáveis, tipo: Inteiro */
 	printf("Programa que calcula a media dos pesos de pessoas da mesma faixa etaria.\n\n"); /* 'printf' - Função padrão para exibir mensagens*/
 	for(i=1;i<=20; i++){ /* Laço de repetição */
 		fflush(stdin);
 		printf("Digite a idade:\n");
 		scanf("%d", &idade); /*Função padrão para entrada de dados, tipo: '%d' - Inteiro */
 		printf("\nDigite o peso:\n");
 		scanf("%f", &peso); /*Função padrão para entrada de dados, tipo: '%f' - Real */
 		if(idade>=1&&idade<=10){ /*Estrutura condicional */
 			soma1=soma1+peso;
 			q1++; /* Incremento */
 		}
 		if(idade>=11&&idade<=20){ /*Estrutura condicional */
 			soma2=soma2+peso;
 			q2++; /* Incremento */
 		}
 		if(idade>=21&&idade<=30){ /*Estrutura condicional */
 			soma3=soma3+peso;
 			q3++; /* Incremento */
 		}
 		if(idade>30){ /*Estrutura condicional */
 			soma4=soma4+peso;
 			q4++; /* Incremento */
 		}
 		
 	}
 	printf("\nA media dos pesos de pessoas da faixa etaria de 1 a 10 anos e: %f \n", soma1/q1);
 	printf("\nA media dos pesos de pessoas da faixa etaria de 11 a 20 anos e: %f \n", soma2/q2);
 	printf("\nA media dos pesos de pessoas da faixa etaria de 21 a 30 anos e: %f \n", soma3/q3);
 	printf("\nA media dos pesos de pessoas com faixa etaria maior de 30 anos e: %f \n", soma4/q4);
 	return(0); /*retorno da função principal*/
 	
 }
Resultados: O programa receberá a idade e o peso de 20 pessoas e no final imprimirá a média dos pesos por faixa etária.
SOFTWARE – QUESTÃO 15
Questão 16 - Calcular e imprimir o fatorial de um determinado número n. 
Explanação da questão: Para resolver está questão é necessário conhecer o conceito de fatorial. Da matemática, o fatorial de um número é o produto deste número pelos seus antecessores até o número 1 ou o produto do número 1 pelos seus sucessores até o número que se deseja calcular o fatorial, pois no produto a ordem dos fatores não modifica o resultado. O programa deverá solicitar ao usuário que digite o número que ele deseja calcular o fatorial. Para o cálculo do fatorial utiliza-se um laço de repetição de 1 até o número que o usuário digitou, com o acréscimo de 1 ao índice i à cada repetição. Dentro do laço se faz uso das seguintes instruções: fat(de valor inicial igual a 1, ou seja, valor neutro da multiplicação que não irá interferir no cálculo do fatorial) é igual a fat*i, ou seja, fat será multiplicado ordenadamente de 1 até o número que se deseja calcular o fatorial, o resultado é o fatorial do número. Após o laço, o programa deverá imprimir o valor de fat.
Algoritmo:
Início Exercício16
 Inteiro n, i, fat
 fat←1
 Imprima 'Programa que calcula o fatorial de um determinado número'
 Imprima 'Digite o número que deseja calcular o fatorial'
 Leia n
 Faça i← 1 até n, i←i+1 
 fat=fat*i
 Fim faça
 Imprima 'O fatorial de', n, 'é', fat
Fim
Linguagem C:
#include<stdio.h> /* Biblioteca de entrada e saida de dados*/
#include <stdlib.h> /* Biblioteca de alocação de memória e conversões*/
 int main(){ /*Função principal, tipo: Inteiro, ou seja, retorna um valor inteiro*/
 	int n, i, fat=1; /* Declaração das variáveis, tipo: Inteiro */
 	printf("Programa que calculao fatorial de um determinado numero.\n\n"); /* 'printf' - Função padrão para exibir mensagens*/
 	printf("Digite o numero que deseja calcular o fatorial\n");
 	scanf("%d",&n); /*Função padrão para entrada de dados, tipo: '%d' - Inteiro */
 	for(i=1;i<=n;i++){ /* Laço de repetição */
 		fat=fat*i;
 	}
 	printf("\nO fatorial de %d e: %d", n, fat);
 	return(0); /*retorno da função principal*/
 	
 }
Resultados: Após digitar o número que se deseja calcular o fatorial o programa irá imprimir o resultado.
SOFTWARE 16
Questão 17 - Apresentar o total da soma obtida do fatorial dos dez primeiros números inteiros. 
Explanação da questão: Nessa questão, o programa deverá calcular a soma do fatorial dos dez primeiros números inteiros. Será necessário um laço de repetição de 1 até 10, com acréscimo de 1 ao índice à cada repetição. Com as seguintes instruções: fat será igual a fat*i e a variável soma (de valor inicial igual a zero) à cada repetição receberá o valor de fat. Dessa forma, a variável soma ao final do laço receberá a soma do fatorial dos 10 primeiros números inteiros. Após o laço, o programa deverá imprimir a variável soma.
Observação: Na questão anterior foi explicado o cálculo do fatorial de um número.
Algoritmo:
Início Exercicio17
 Inteiro i, n, fat, soma
 fat←1
 soma←0
 Imprima 'Programa que calcula a soma do fatorial dos 10 primeiros números inteiros.'
 Faça i← 1 até 10, i« i+1
 fat← fat*i
 soma← soma+fat
 Fim faça
 Imprima 'A soma do fatorial dos 10 primeiros números inteiros é', soma
Fim
Linguagem C:
#include<stdio.h> /* Biblioteca de entrada e saida de dados*/
#include <stdlib.h> /* Biblioteca de alocação de memória e conversões*/
 int main(){ /*Função principal, tipo: Inteiro, ou seja, retorna um valor inteiro*/
 	int i, n, fat=1, soma=0; /* Declaração das variáveis, tipo: Inteiro */
 	printf("Programa que calcula a soma do fatorial dos 10 primeiros numeros inteiros.\n\n"); /* 'printf' - Função padrão para exibir mensagens*/
 	for(i=1;i<=10;i++){ /* Laço de repetição */
 		fat=fat*i;
 		soma=soma+fat;
 	}
 	printf("A soma do fatorial dos 10 primeiros numeros inteiros e: %d \n", soma);
 	return(0); /*retorno da função principal*/
 }
Resultados: Como esperado, o programa imprimirá a soma do fatorial dos dez primeiros números inteiros.
SOFTWARE – QUESTÃO 17
Questão 18 - Entrar com dez notas de cada aluno de uma turma de 20 alunos e imprimir: 
• A média de cada aluno; 
• A média da turma; 
• percentual de alunos que tiveram médias maiores ou iguais a 5.0 
Explanação da questão: Nessa questão será necessário a utilização de um laço de repetição composto, ou seja, um laço dentro do outro. Primeiro um laço de 1 até 20 com acréscimo de 1 à cada repetição e outro com laço de 1 até 10 com acréscimo de 1 à cada repetição, pois serão digitados 10 notas para cada aluno em uma turma de 20 alunos. Após digitar as 10 notas de um aluno, o programa deverá imprimir a média desse aluno, para isso o programa deverá ter uma variável soma que terá valor inicial igual a zero à cada repetição do primeiro laço, que receberá à cada repetição do 2º laço as notas de um aluno, então, a média do aluno e calculada por soma/10. Para o cálculo da média da turma, o programa deverá ter uma variável para armazenar o valor da média de cada aluno (mediat). E a média da turma será dada por mediat/20. Para calcular o percentual de alunos que tiveram médias maiores ou iguais a 5 será necessário uma estrutura condicional, com a seguinte instrução: se media for maior ou igual a 5, a variável q (de valor inicial igual a zero) receberá um acréscimo de 1 (dentro do 1º laço). Após fechar os dois laços, o programa deverá imprimir o valor da média da turma e a percentagem de alunos com nota maior que 5, que é dada por q*100/20.
Algoritmo:
Início Exercício18
 Real soma, nota, media, mediat
 Inteiro i, j, q
 q← 0
 mediat←0
 Imprima 'Programa que calcula: a média do aluno, a média da turma e o percentual de alunos com média maior ou igual a 5.'
 Faça i← 1 até 20, i← i+1
 soma← 0
 Faça j← 1 até 10, j← j+1
 Imprima 'Digite a nota', j, 'do aluno', i 
 Leia nota
 soma← soma+nota
 Fim faça 
 media← soma/10
 mediat←mediat+media
 Imprima 'A media do aluno', i, 'é', media
 Se(media>=5) então
 q← q+1
 Fim se
 Fim faça
Imprima 'A percentagem de alunos com média maior ou igual a 5 é', q*100/20
Imprima ‘A média da turma e:’, mediat/20
Fim
 
Linguagem C:
#include<stdio.h> /* Biblioteca de entrada e saida de dados*/
#include<stdlib.h> /* Biblioteca de alocação de memória e conversões*/
int main(){ /*Função principal, tipo: Inteiro, ou seja, retorna um valor inteiro*/
	float soma, nota, media, mediat=0; /* Declaração das variáveis, tipo: Real */
	int i, j, q=0; /* Declaração das variáveis, tipo: Inteiro */
	printf("Programa que calcula: a media do aluno, a media da turma e o percentual de alunos com media maior ou igual a 5.\n\n");
	for(i=1; i<=20;i++){ /* Laço de repetição */
		fflush(stdin);
		soma=0;
		for(j=1;j<=10;j++){ /* Laço de repetição */
		printf("\nDigite a nota %d do aluno %d \n", j, i); /* 'printf' - Função padrão para exibir mensagens*/
		scanf("%f",&nota); /*Função padrão para entrada de dados, tipo: '%f' - Real */
		soma=soma+nota;	
		}
		media=soma/10;
 mediat=mediat+media;
		printf("\nA media do aluno %d e: %.2f", i, media);
		if(media>=5) q++; /*Estrutura condicional */
		
	}
	printf("\n\nA percentagem de alunos com media maior ou igual a 5 e: %d", q*100/20);
 printf(“\n\nA media da turma e: %f\n\n”, mediat/20);
	return(0); /*retorno da função principal*/
} 
Resultados: Como esperado, o programa imprimirá ao final: a média da turma e o percentual de alunos com média maior ou igual a 5. 
SOFTWARE – QUESTÃO 18
Questão 19 - No dia da estreia do filme "Senhor dos Anéis", uma grande emissora de TV realizou uma pesquisa logo após o encerramento do filme. Cada espectador respondeu a um questionário no qual constava a idade e a sua opinião em relação ao filme: excelente - 3; bom - 2; regular - 1. Criar um algoritmo que receba a idade e a opinião de 20 espectadores, calcule e imprima: 
• A média das idades das pessoas que responderam excelente; 
• A quantidade de pessoas que responderam regular; 
• A percentagem de pessoas que responderam bom entre todos os espectadores analisados. 
Explanação da questão: O programa deverá receber a idade e a opinião de 20 pessoas, para isso será necessário um laço de repetição de 1 até 20, com acréscimo de 1 à cada repetição. Para calcular a média das idades das pessoas que responderam excelente, faz-se uso de uma estrutura condicional, com a seguinte condição: se a variável op for igual a 3, então, a variável somae(de valor inicial 0) receberá a idade da pessoa que respondeu excelente e a variável qe (de valor inicial igual a 0) receberá qe mais 1. Para calcular a quantidade de pessoas que responderam regular também faz-se uso de uma estrutura condicional, com a seguinte condição: se op for igual a 1, qr (de valor inicial igual a 0) receberá qr mais 1. Para calcular a percentagem de pessoas que responderam bom, primeiro será necessário saber quantas pessoas responderam bom, para isso, utiliza-se uma estrutura condicional com a seguinte condição: se op for igual a 2, então qb (de valor inicial igual a zero) receberá qb mais 1. Após o final do laço deverá ser impresso: a média da idade das pessoas que responderam excelente, que é dada por somae/qe; a quantidade de pessoas que responderam regular, ou seja, qb; e a percentagem das pessoas que responderam bom, que é calculadapor qb*100/20.
Algoritmo:
Início Exercício19
 Inteiro i, op, id, somae, qe, qr, qb
 somae←0
 qe←0
 qr←0
 qb←0
 Imprima 'Programa que lê idade e opinião sobre o filme Senhor dos Anéis'
 Faça i←1 até 20, i←i+1
 Imprima 'Digite sua idade'
 Leia id
 Imprima 'Digite sua opinião sobre o filme'
 Imprima 'Opções:'
 Imprima '1- Regular; 2-Bom; 3- Excelente'
 Leia op
 Se(op=3) então
 somae←somae+id
 qe←qe+1
 Fim se
 Se(op=1) então
 qr←qr+1
 Fim se
 Se (op=2) então
 qb←qb+1
 Fim se
Fim faça
 Imprima 'A média de idades de pessoas que responderam Excelente é', somae/qe
 Imprima 'A quantidade de pessoas que responderam Regular é', qr
 Imprima 'A percentagem de pessoas que responderam Bom entre todos os expectadores analisados é', qb*100/20
Fim
Linguagem C:
#include<stdio.h> /* Biblioteca de entrada e saida de dados*/
#include<stdlib.h> /* Biblioteca de alocação de memória e conversões*/
 int main(){ /*Função principal, tipo: Inteiro, ou seja, retorna um valor inteiro*/
 	int i, op, id, somae=0, qe=0, qr=0, qb=0; /* Declaração das variáveis, tipo: Inteiro */
 	printf("Programa que le idade e opiniao sobre o filme Senhor dos Aneis.\n\n"); /* 'printf' - Função padrão para exibir mensagens*/
 	for(i=1;i<=20;i++){ /* Laço de repetição */
 		fflush(stdin);
 		printf("Digite sua idade:\n");
 		scanf("%d",&id); /*Função padrão para entrada de dados, tipo: '%d' - Inteiro */
 		printf("\nDigite sua opniao sobre o filme.\n\n");
 		printf("Opcoes:\n 1-Regular; \n 2-Bom; \n 3-Excelente;\n\n");
 		scanf("%d",&op); /*Função padrão para entrada de dados, tipo: '%d' - Inteiro */
 		if(op==3){ /*Estrutura condicional */
 			somae=somae+id;
 			qe++; /* Incremento */
 		}
 		if(op==1) /*Estrutura condicional */
		 qr++;/* Incremento */
 		
 		if(op==2) /*Estrutura condicional */
		 qb++; /* Incremento */
 		
 	}
 	printf("A media de idades de pessoas que responderam Excelente e: %d \n\n", somae/qe);
 	printf("A quantidade de pessoas que responderam Regular e: %d \n\n", qr);
 	printf("A percentagem de pessoas que responderam Bom entre todos os expectadores analisados e: %d \n\n", qb*100/20);
 	return(0); /*retorno da função principal*/
 	
 }
Resultados: Após o programa receber as opiniões e idades de 20 pessoas, ele imprimirá na tela a média de idade das pessoas que responderam excelente, a quantidade de pessoas que responderam regular e a percentagem de pessoas que responderam bom.
SOFTWARE – QUESTÃO 19
Questão 20 - Num campeonato europeu de volleyball, se inscreveram 30 países. Sabendo-se que na lista oficial de cada país consta, além de outros dados, peso e idade de 12 jogadores, criar um algoritmo que apresente as seguintes informações: 
• peso médio e a idade média de cada um dos times; 
• peso médio e a idade média de todos os participantes. 
Explanação da questão: Na resolução dessa questão será necessário o uso de um laço de repetição composto, ou seja, um laço de repetição dentro do outro. Pois o programa irá receber o peso e da idade dos jogadores de 30 times, sendo que cada time possui 12 jogadores. O primeiro laço é de 1 até 30 com acréscimo de 1 á cada repetição e o segundo laço é de 1 até 12 com acréscimo de 1 à cada repetição. Para o cálculo do peso médio e idade média de cada time, será necessário 2 variáveis (somapt e somaidt) para armazenar: a soma dos pesos de cada time e a soma das idades de cada time, sendo que estas variáveis receberão valor igual à zero no início do primeiro laço. A média dos pesos é calculada por somapt/12 e a média das idades por somaidt/12. Para calcular a média do peso e a média da idade de todos os participantes, faz-se uso de duas variáveis (somapp e somaidp) para armazenar todos os pesos e todas as idades respectivamente. A média dos pesos e a média das idades de todos os participantes são dadas respectivamente por: somapp/(12*30 ou 360) e somaidp/(12*30 ou 360).
Algoritmo:
Início Exercício20
Integer i, j, id
Real peso, somapt, somaidt, somapp, somaidp
somapp←0 ! soma do peso de todos participante
somaidp←0 ! soma da idade de todos participante
Imprima 'Programa que calcula: peso e idade média de todos os jogadores e de cada time de um campeonato europeu de volleyboll.'
Faça i←1 até 30, i←i+1
 somapt←0 ! soma do peso dos jogadores do time
 somaidt←0 ! soma da idade dos jogadores do time
 Faça j←1 até 12, j←j+1
 Imprima 'Digite o peso do jogador', j, 'do time', i
 Leia peso
 Imprima 'Digite a idade do jogador', j, 'do time', i
 Leia id
 somapt←somapt+peso
 somaidt←somaidt+id
 Fim faça
 Imprima 'O peso médio do time', i, 'é', somapt/12
 Imprima 'A idade média do time', i, 'é', somaidt/12
 somapp←somapp+somapt
 somaidp←somaidp+somaidt
Fim faça
Imprima 'O peso médio de todos os participante é', somapp/360
Imprima 'A idade média de todos os participante é', somaidp/360
Fim
Linguagem C:
#include<stdio.h> /* Biblioteca de entrada e saida de dados*/
#include<stdlib.h> /* Biblioteca de alocação de memória e conversões*/
 int main(){ /*Função principal, tipo: Inteiro, ou seja, retorna um valor inteiro*/
 	int i, j, id; /* Declaração das variáveis, tipo: Inteiro */
 	float peso, somapt, somaidt, somapp=0, somaidp=0; /* Declaração das variáveis, tipo: Real */
 	printf("Programa que calcula: peso e idade media de todos os jogadores e de cada time de um campeonato europeu de volleyboll.\n\n");
 	for(i=1;i<=30;i++){ /* Laço de repetição */
 		fflush(stdin);
 		somapt=0;
 		somaidt=0;
 		for(j=1;j<=12;j++){ /* Laço de repetição */
 			printf("\nDigite o peso do jogador %d do time %d \n", j, i); /* 'printf' - Função padrão para exibir mensagens*/
 			scanf("%f",&peso); /*Função padrão para entrada de dados, tipo: '%f' - Real */
 			printf("\nDigite a idade do jogador %d do time %d \n",j,i);
 			scanf("%d",&id); /*Função padrão para entrada de dados, tipo: '%d' - Inteiro */
 			somapt=somapt+peso;
 			somaidt=somaidt+id;
 			
 		}
 		printf("\nO peso medio do time %d e: %f \n", i,somapt/12);
 		printf("\nA idade media do time %d e: %f\n", i, somaidt/12);
 		somapp=somapp+somapt;
 		somaidp=somaidp+somaidt;
 	}
 	printf("\n\n\nO peso medio de todos os participantes e: %f \n", somapp/360);
 	printf("\nA idade media de todos os participantes e: %f \n", somaidp/360);
 	return(0); /*retorno da função principal*/
 }
Resultados: após digitar os dados de cada time, o programa imprimirá a média de pesos e a média das idades de cada time. E após digitar os dados dos 30 times, o programa imprimirá a média dos pesos de todos os jogadores e a média da idade de todos os jogadores. 
SOFTWARE – QUESTÃO 20
Questão 21 - Cinco amigos estavam jogando baralho e ao final do jogo querem calcular a pontuação de cada um. Sabendo-se que cada jogador sempre termina o jogo com cinco cartas na mão e que cada carta vermelha, se estiver entre 1 (Ás) e 5 vale 5 pontos, se estiver entre 6 e 10 vale 10 pontos e qualquer outra carta do baralho não vale ponto. Elaborar um programa para ler as cinco cartas que o jogador tem nas mãos e calcular e imprimir a pontuação de cada jogador ao final do jogo. 
Explanação da questão: O programa deverá ter 2 laços de repetição, um relativo aos 5 jogadores e outro relativo às 5 cartas que serão lidas. Dentro do segundo laço deverá ter uma estrutura condicional com a seguinte condição: se cor for igual a 1, ou seja, se a carta for vermelha, ele