Programação 1 - Engenharia - Comandos de Repetição no C

De MediaWiki do Campus São José
Revisão de 08h20min de 14 de dezembro de 2020 por Eraldo (discussão | contribs) (→‎Objetivos)
Ir para navegação Ir para pesquisar

Objetivos

Após esta aula o aluno deverá:

  • conhecer a sintaxe e a semântica dos comandos de repetição do C: while, do while, for e goto.
  • mapear estruturas simples de repetição especificadas em fluxogramas ou pseudo-código em estruturas em linguagem C.
  • identificar quando usar variáveis inteiras com maior ou menor capacidade de armazenamento (char, unsigned, long).

Estruturas de Repetição

Existem 4 estruturas/comandos que permitem implementar loops ou repetições de blocos de código:

  • while()
  • do while()
  • for()
  • goto label
NOTA: Observe que repetir o código significa voltar a executá-lo, normalmente sobre o controle de uma expressão lógica.

O comando 'while()': TESTE da REPETIÇÃO no começo

O comando while permite implementar loops com controle no início.

A semântica do while é a seguinte: ao entrar no comando a EXPRESSÃO entre parênteses é AVALIADA. Caso resulte em uma valor VERDADEIRO o LAÇO do loop é executado uma vez. O programa testa então novamente a expressão. LEMBRAR que:

  • VERDADEIRO é qualquer valor diferente de ZERO;
  • DENTRO do laço NORMALMENTE existe uma modificação de alguma parte da expressão de teste de forma que em algum momento o LOOP se encerra.
  • Ao se encerrar o programa continua na próxima instrução APÓS o comando "while()";
  • ANTES DE entrar no comando while SEMPRE tenha certeza que as variáveis estão com valores adequados de forma que a expressão SEJA AVALIADA sempre corretamente.

No exemplo que se segue existe UMA única instrução simples (terminada em ";"). 

#include <stdio.h>
main() 
{
  int contador;
  
  contador=0;
  while (contador<5)     
     contador=contador+1;
  printf("valor do contador =  %d\n", contador);
}

OBSERVE a seguir uma variação do exemplo anterior usando um bloco de instruções delimitado por "{" e "}" 

#include <stdio.h>
main() 
{
  int contador;
 
  contador=0;
  while (contador<5) {  
         printf("valor da expressão =  contador < 5 é %d\n", contador<5);  
         printf("valor do contador =  %d\n", contador);
         contador=contador+1;
  }
  printf("NO FINAL a expressão  contador < 5 é %d\n", contador<5);
}

Notar que a expressão contador<5 assume valor 0 (falso) e 1 (verdadeiro).

A estrutura do comando, informalmente, é: 

while (expressão)
  instrução_simples;

ou 

while (expressão) {
  lista_de_instruções
}

Vamos ver a correspondência do comando while com um fluxograma:

Fluxograma C Comentário
Fluxo5.jpg 
while(contador<5) {
   printf("Entre com x\n");
   scanf("%f",&x);
   soma=soma+x;
   contador = contador + 1;
}
comando while() aplicado sobre um bloco de instruções. Note que se for uma instrução simples, as chaves podem ser omitidas. 
NOTE que no exemplo anterior o contador inicialmente DEVE conter um valor válido.

Exemplo 1

PROBLEMA: Elaborar um programa C para imprimir os números pares em ordem decrescente (até atingir 0 inclusive) a partir de um número N fornecido como entrada. Seguir o fluxograma mostrada abaixo.

DADOS DE ENTRADA: N (variável inteira)

DADOS DE SAÌDA: números pares impressos

FluxogramaRepeticaoImprimePar.jpg

SOLUÇÃO:

NOTE que existem outras soluções. Por exemplo, detectar se o número é par (ou ímpar) e depos fazer um loop decrementando de dois em dois (sugestão dos alunos). Esta última opção é mais eficiente em termos de tempo de execução. 

#include <stdio.h>

int main()
{
  int N,i;

  printf("Entre com o valode N\n");
  scanf ("%d", &N);
  i=N;
  while(i>=0) {
      if (i%2==0) { /* parênteses em (i%2) é opcional porque o operador de resto tem precedência */
          printf("%d\n", i);
      }
      i=i-1;
  } 
  return 0;
}

Exemplo 2

PROBLEMA: Elaborar um programa C para computação do fatorial de um número conforme definição abaixo:

DADOS DE ENTRADA:número N (numero inteiro)

DADOS DE SAÌDA: FATORIAL computado

O fatorial é definido por:

FluxogramaFatorialNum.jpg

SOLUÇÃO:

NOTE que a solução abaixo é simplificada pois não testa se a entrada é menor que ZERO. 

#include <stdio.h>

int main()
{
  int N,i,FAT;

  printf("Entre com o valor de N\n");
  scanf ("%d", &N);
  i=N;
  FAT=1;
  while(i>1) {
      FAT=FAT*i;
      i=i-1;
  } 
  printf("Valor de FAT  de %d é %d\n", N, FAT);
  return 0;
}

Exercício 1

Modificar o exercício do FATORIAL apresentado anteriormente para caso sejam lidos números negativos o programa pergunte novamente o número N. Usar um comando "while" adicional.

Antes de entrar com o valor de N, atribua um valor NEGATIVO, por exemplo -1 a N. A expressão de teste no comando "while" deve ser verdadeira enquanto N for negativo. Coloque o scanf dentro deste "while".

Solução Ex. 1 
#include <stdio.h>
 
int main()
{
  int N,i,FAT;
 
  printf("Entre com o valor de N\n");
  scanf ("%d", &N);

  while (N < 0){
    printf("Entre com um novo valor de N\n");
    scanf ("%d", &N);
  }  

  i=N;
  FAT=1;
  while(i>1) {
      FAT=FAT*i;
      i=i-1;
  } 
  printf("Valor de FAT  de %d é %d\n", N, FAT);
  return 0;
}

Exercício 2

Elaborar um programa C para computar a SOMA do fatorial de dois números inteiros fornecidos como entrada. O programa deve prever a entrada somente de números não negativos. Olhe as soluções acima e reproduza as estruturas propostas.

Solução Ex. 2 
#include <stdio.h>
 
int main()
{
  int n1, n2,i,fat1, fat2;
 
  printf("Entre com o valor do fatorial 1\n");
  scanf ("%d", &n1);

   
  printf("Entre com o valor do fatorial 2\n");
  scanf ("%d", &n2);

  while (n1 < 0){
    printf("Entre com um novo valor de N1\n");
    scanf ("%d", &n1);
  } 
    while (n2 < 0){
    printf("Entre com um novo valor de N1\n");
    scanf ("%d", &n2);
  }   

  i=n1;
  fat1=1;

  while(i>1) {
      fat1=fat1*i;
      i=i-1;
  } 

  i=n2;
  fat2=1;
  while(i>1) {
      fat2=fat2*i;
      i=i-1;
  } 

  printf("A soma dos fatoriais de N1 e N2 é %d\n", (fat1+fat2));
  return 0;
}

Exercício 3

Elabore uma versão otimizada do programa que computa a soma do fatorial de dois números. Observe que poderíamos "economizar" laços de repetição se calcularmos o fatorial do menor número e depois computar o fatorial do maior usando o menor número como ponto de parada na repetição.

Solução Ex. 3 
#include <stdio.h>
 
int main()
{
  int maior, menor, n1, n2,i,fat1, fat2;
 
  printf("Entre com o valor do fatorial 1\n");
  scanf ("%d", &n1);

  printf("Entre com o valor do fatorial 2\n");
  scanf ("%d", &n2);
 
  while (n1 < 0){
    printf("Entre com um novo valor de N1\n");
    scanf ("%d", &n1);
  } 
    while (n2 < 0){
    printf("Entre com um novo valor de N1\n");
    scanf ("%d", &n2);
  }   
 
  if (n2>n1) {
     maior = n2;
     menor = n1;
  } else {
     maior = n1;
     menor = n2;
  }
  
  i=menor;
  fat1=1;

  while(i>1) {
      fat1=fat1*i;
      i=i-1;
  } 
 
  i=maior;
  fat2=1;

  while(i>menor) {
      fat2=fat2*i;
      i=i-1;
  } 
  fat2=fat2*fat1;
 
  printf("A soma dos fatoriais de N1 (%d)e N2(%d) é %d\n", fat1, fat2, (fat1+fat2));
  return 0;
}

Desenhando no terminal MODO texto

A saída de um programa em um terminal modo TEXTO possui algumas limitações. Além da questão da definição, o programa escreve sempre na posição de um CURSOR que avança automaticamente. Em condições normais não é possível retornar o cursor para linhas acima. Deve-se portanto planejar cuidadosamente o desenho de figuras levando em consideração estas restrições. As instruções de repetição ajudarão bastante neste processo.

Exemplo: imprimir uma linha com 10 caracteres 'A'

AAAAAAAAA

#include <stdio.h>

int main()
{
 int i;
 
 i=0;
 while (i<10) {
    printf("A");
    i=i+1;
 }
 printf("\n");
}

Exercício 1

Elaborar um programa para imprimir uma linha CUSTOMIZADA em 3 partes. Cada parte imprime um número variável de caracteres. O número de caracteres e o caracter a ser impresso em cada parte deve ser informado.

ImpressaoSimplesTerminal.jpg

Solução Ex. 1 
#include <stdio.h>
 
int main(){

int p1,p2,p3,i;
char c1, c2, c3;

printf("Carcater a ser desenhado na primeira parte da linha\n");
scanf("%c", &c1);
printf("Quantidade de caracteres a ser desenhado na primeira parte da linha\n");
scanf("%d", &p1);

printf("Carcater a ser desenhado na segunda parte da linha\n");
scanf(" %c", &c2);
printf("Quantidade de caracteres a ser desenhado na segunda parte da linha\n");
scanf("%d", &p2);

printf("Carcater a ser desenhado na terceira parte da linha\n");
scanf(" %c", &c3);
printf("Quantidade de caracteres a ser desenhado na terceira parte da linha\n");
scanf("%d", &p3);
 
i=0;
while (i < p1) {
   printf("%c", c1);
   i=i+1;
}

i=0;
while (i < p2) {
   printf("%c", c2);
   i=i+1;
}

i=0;
while (i < p3) {
   printf("%c", c3);
   i=i+1;
}

printf("\n");
return 0;
}

Exercício 2

Modificar o exercício anterior para imprimir uma quantidade variável de LINHAS. As linhas são exatamente iguais.

Solução Ex. 2 
#include <stdio.h>
 
int main(){

int p1,p2,p3,i,j,linhas;
char c1, c2, c3;

printf("Carcater a ser desenhado na primeira parte da linha\n");
scanf("%c", &c1);
printf("Quantidade de caracteres a ser desenhado na primeira parte da linha\n");
scanf("%d", &p1);

printf("Carcater a ser desenhado na segunda parte da linha\n");
scanf(" %c", &c2);
printf("Quantidade de caracteres a ser desenhado na segunda parte da linha\n");
scanf("%d", &p2);

printf("Carcater a ser desenhado na terceira parte da linha\n");
scanf(" %c", &c3);
printf("Quantidade de caracteres a ser desenhado na terceira parte da linha\n");
scanf("%d", &p3);

printf("Informe a quantidade de linhas\n");
scanf("%d", &linhas);
 
j=0;
while (j < linhas){
    i=0;
    while (i < p1) {
        printf("%c", c1);
        i=i+1;
    }

    i=0;
    while (i < p2) {
        printf("%c", c2);
        i=i+1;
    }

    i=0;
    while (i < p3) {
        printf("%c", c3);
        i=i+1;
    }
printf("\n");    
j = j+1;    
}
printf("\n");
return 0;
}

Comando do while: controle do loop no final

O comando do while() permite a repetição de uma ou mais instruções, com controle do loop no final. Isto permite que o bloco seja executado pelo menos uma vez. 

#include <stdio.h>
main() 
{
  int contador;
  
  contador=0;
  do {  
     printf("valor do contador =  %d\n", contador);
     contador=contador+1;
  } while (contador<5);
}

A estrutura do comando, informalmente, é: 

do 
  instrução_simples;
while (expressão);

ou 

do {
  lista_de_instruções
} while (expressão);
Fluxograma C Comentário
FluxoDoWhile-Eraldo.jpg 
contador = 0;
do {
   scanf("%d",&x);
   soma=soma+x;
   if (soma>150) 
       y=z+x;
   contador++;
} while(contador<5);
Note que instruções while e if são tratadas como instruções normais que podem ser aninhadas normalmente em outros comandos.

Exemplo 1

Modificar o exemplo do cálculo do FATORIAL apresentado anteriormente para caso sejam lidos números negativos o programa pergunte novamente o número N. Usar um comando "do while" para construir o loop onde será realizado o scanf(). 


#include <stdio.h>

int main()
{
  int N,i,FAT;

  /* Leitura do número e 
     verificação se o número é negativo */

  do {
    printf("Entre com o valor de N\n");
    scanf ("%d", &N);
    if (N<0)
       printf("Número negativo...");
  } while (N<0);

  /* computação do fatorial */
  i=N;
  FAT=1;
  while(i>1) {
      FAT=FAT*i;
      i=i-1;
  } 
  printf("Valor de FAT  de %d é %d\n", N, FAT);
  return 0;
}

Um problema na computação do fatorial é que rapidamente pode existir overflow', ou seja, ultrapassar a capacidade da da variável do tipo 'int'. VEJA a tabela abaixo com alternativas de inteiros com seus respectivos tamanhos.

TIPO bytes RANGE COMENTÁRIO
char 1 -128 até 127 um bit para o sinal
short int 2 32,768 to 32,767 um bit para o sinal
int 4 -2147483648 até 2147483647 um bit para o sinal. Dependendo da máquina poderia ser 8 bytes
long int 8 -9223372036854775808 até 9223372036854775807 um bit para o sinal
unsigned char 1 0 to 255
unsigned short 2 0 to 65,535
unsigned int 4 0 to 4294967295
unsigned long 8 0 até 18446744073709551615

Execute o programa abaixo para conferir. 

#include <stdio.h>

int main()
{
  char num0;
  short num1;
  int num2;
  long int num3; 

  /* Leitura do número e 
     verificação se o número é negativo */

  printf ("tamanho de num0 = %ld\n", sizeof (num0));
  printf ("tamanho de num1 = %ld\n", sizeof (num1));
  printf ("tamanho de num2 = %ld\n", sizeof (num2));
  printf ("tamanho de num3 = %ld\n", sizeof (num3));
  
  return 0;
}

Exercício

Reimplementar o exemplo anterior usando o long int para computar o fatorial.

Exemplo 2

O programa abaixo foi extraído de (referência). Ele permite realizar a adivinhação de um número entre 1 e 10. Observe que as instruções permitem a geração do número randômico. 

srand ( time(NULL) ); /* inicia o gerador com a semente baseada no relógio local */
iSecret = rand() % 10 + 1 /* gera o número */

// exemplo de geração randômica
// extracted and adapted from www.stackoverflow.com 
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main ()
{
      int segredo, sugestao;

      /* iniciar semente: */
      srand ( time(NULL) );

      /* gerar o número secreto: */
      segredo = rand() % 10 + 1;

      do {
          printf ("Adivinhe um número entre (1 a 10): ");
          scanf ("%d",&sugestao);
          if (segredo<sugestao) 
              printf ("O número secreto é menor\n");
          else {
              if (segredo>sugestao) 
                 printf ("O número secreto é maior\n");
          }
      } while (segredo!=sugestao);

      printf ("Parabéns!\n");
      return 0;
}

Comando for()

O comando for() permite uma forma mais elaborada de loop, com controle no início do bloco de repetição. 


#include <stdio.h>

main()
{
  int i;
  
  for (i=0;i<10;i=i+1)
      printf("i =%d\n",i);
}

A estrutura do comando é: 

for(expressão_inicial;expressão_de_controle; expressão_de_final_de _bloco)
instrução_simples;

ou 

for(expressão_inicial;expressão_de_controle; expressão_de_final_de _bloco) {
lista_de_instruções
}

!Fluxograma !C !Comentário | |FluxogramaComandoFor-Eraldo.jpg

for(i=0; i<10; i++) {
  printf("Laço de número %d\n", i);
  if (i==5)
      printf("Este é o laço 5\n");
}
Observe que a expressão i=0 é executada SEMPRE e uma única VEZ, no início do comando.

A expressão i<10 é o controle do loop. Se FALSA o loop é encerrado. Ela é executada após a expressão de inicialização e, na sequência, no início de cada loop. A expressão i++ é executada no final de cada loop.

Exemplo

Elaborar um programa que lê um número inteiro e imprime todos os números pares entre 1 e este número INCLUSIVE. 

#include <stdio.h>

int main()
{
  int i, N;

  printf("Entre com o número\n");
  scanf ("%d", &N);

  for (i=1;i<=N;i=i+1) {
     if (i%2==0)
       printf("número par ====> %d\n", i);
  }
  printf("FIM\n");

  return 0;
}

Aninhamento de loops

É muito comum que a solução de problemas exijam o aninhamento de loops. Neste caso, as instruções são aninhadas normalmente usando, se necessário, o recurso de bloco de instruções. Observe no código abaixo que para cada laço mais externo o comando for interno é executado integralmente. 

#include <stdio.h>
int main()
{
  int i,j;
 
  for (i=0;i<3;i++) {
     for (j=0;j<4;j++) {
         printf("valor de j = %d\n", j);
     }
     printf("valor de i = %d\n", i);
  }
  return 0;
}

Comando goto

O comando goto é um dos mais antigos da programação. A ideia é comandar um salto para um determinado ponto específico do programa marcado por um rótulo (LABEL). Para utilizá-lo deve-se, portanto, marcar o ponto para onde será feito o salto usando um LABEL.

Exemplo: 

#include <stdio.h>

main()
{
   int i;

   i=0;

PONTO1:
   printf("Laço de número %d\n", i);
   i++;
   if (i<10)
       goto PONTO1;
}

Devido a ser uma instrução "desestruturante", em geral NÂO se recomenda o uso deste comando.

Em alguns casos de tratamento de erro pode ser interessante o uso do goto.

Leia um pouco mais sobre o goto aqui.

Loop Infinito

É possível implementar loops infinitos com qualquer uma das instruções acima.

Exemplo com comando for: 

main()
{
   for(;;) {
        /* Este bloco se executará infinitamente */
   }
}

ou com o comando while: 

main()
{
   while(1) {
        /* Este bloco se executará infinitamente */
   }
}


Uso de break para sair de loops

Em exercícios anteriores, a finalização de um loop normalmente se dá pela expressão de controle de loop associado a instrução usada. É possível sair de um loop na força bruta usando a instrução break: 

#include <stdio.h>
main()
{
  int i,j;

  for (i=0;i<10;i=i+1) {
     if (i==5)
       break;
  }
  printf("valor de i=%d\n", i);
}

Note que o break sempre sai do loop mais próximo a ele.


  • O comando break encerra o laço no ponto em que for executado.
  • O comando continue desvia o fluxo para o início do laço.
#include <stdio.h>

int main()
{
    //break     -> simplesmente interrompe o nosso ciclo
    //continue  -> interrompe o laço (desvia o fluxo para o início do laço)
    int x;

    for(x = 0; x<=10; x++){

        //qndo x == 2, interrompa somente o laço atual
        if(x == 2){
            printf("Valor de x é 2 - fazendo continue...\n");
            continue;
        }

        //Quando chegamos a 8 o looping será finalizado
        if(x == 8){
            printf("Valor de x é 8 - fazendo continue...\n", x);
            break;
        }

        printf("%d\n", x);
    }
}

Exercício

Elabore um programa em C que leia no máximo 5 números inteiros positivos. Caso um número negativo seja digitado no meio da seqüência uma mensagem deve ser impressa uma mensagem de aviso no terminal e o laço é encerrado de imediato.

Uso do continue para prosseguir no início do loop

#include <stdio.h>
main()
{
  int i,j;

  for (i=0;i<3;i++) {
     if (i==1) { 
         continue;
     }
     printf("valor de i = %d\n", i);
     for (j=0;j<4;j++) {
         if (j==1) { 
             continue;
         }
         printf("valor de j = %d\n", j);
     }
  }

}

Usando funções da biblioteca matemática

Para usar as funções matemáticas da biblioteca padrão, fazer os seguintes passos:

  • No arquivo-fonte incluir o header math.h da biblioteca matemática:
 
#include <stdio.h>
#include <math.h>

main()
{
 
  float x,y; /* declaração de duas variáveis reais */

  printf ("Entre com o valor de x ");
  scanf("%f",&x);

  y = sqrtf(x);
  printf ("Raiz de x = %.2lf", y);
}

NOTA: a maior parte de parâmetros e valores de retorno das funções matemáticas são reais de dupla precisão (double).

  • Compilar e linkar o arquivo da forma:
 gcc ex1.c -o ex1 -lm

EXERCÍCIOS - nível INICIANTE

  1. Desenvolver em C um programa que efetue a soma de todos os números ímpares que são múltiplos de três e que se encontram no conjunto dos números de 1 até 500 inclusive. Usar comando for.
    Solução - Exercício 1
  2. Faça uma versão "controversa" do programa de adivinhação mostrado na aula usando uma instrução goto para sair de um loop infinito.
    Solução - Exercício 2
  3. Ainda sobre o exercício 2, implemente uma versão usando o comando while().
    Solução - Exercício 3
  4. Ainda sobre o exercício 2, implemente uma versão usando loop infinito e o comando break;
    Solução - Exercício 4
  5. Implemente uma variação do jogo de adivinhação para que ele conte o número de tentativas do jogador.
  6. Implemente uma variação do jogo de adivinhação para que dois dados (1 a 6) sejam jogados. O jogador deve adivinhar a soma dos dados.
  7. Implemente um programa C para ler N resistências. O programa deve ler inicialmente N, depois o valor das resistências (fazendo os cálculos cumulativos) e então calcular o valor da resistência série e paralelo equivalente do circuito. Não usar vetores. Usar um comando while.
    Solução - Exercício 5
  8. Dado um número inteiro positivo, calcular a soma de todos os números inteiros compreendidos entre 1 e o número dado. Fazer uma versão com while e outra com for. Caso o número apresentado for negativo ou zero, solicitar a entrada novamente. Use o comando do while para esta finalidade.
  9. Dado dois números inteiros positivos "M" e "N", computar o valor "V" conforme a equação:

EXERCÍCIOS - nível MÉDIO

  1. Tente descobrir por tentativas qual carga em um circuito com uma fonte de tensão contínua de 500 V e resistência interna de 10 ohms produz a máxima dissipação de potẽncia (ver https://en.wikipedia.org/wiki/Maximum_power_transfer_theorem). Sabe-se que esta carga está entre 1 e 20 ohms. Sugestão: faça um "loop" com para testar cargas que vão de 1 a 20 ohms com acréscimos de 0.5 ohms. Crie uma variável para anotar a maior potência e a carga que produziu esta potência.
    Solução
  2. Usando o comando for aninhado, construa um programa que implemente a figura abaixo. A margem esquerda (margem de espaços representada por ponto), o caracter do desenho, o número de linhas vazadas e o tamanho horizontal da figura devem ser lidos pelo teclado. 
       
...aaaaaaaaaa
...a        a
...aaaaaaaaaa
     SUGESTÃO: dividir em subproblemas da forma:

    #include <stdio.h>

main()
{
  int i, j, margem, largura, linhas_vazadas;
  char caracter;
  
  /** sub-problema 1 - ler margem , largura de desenho, caracter do desenho e numero de linhas **/
  
  /* sub-problema 2 - desenhar linha de topo */

  /* sub-problema 3 - desenhar linhas vazadas */

  for (j=0;j<linhas_vazadas;j++) {
      /* desenhar linha vazada*/
  }

  /* sub-problema 4 - desenhar linha de fundo  (igual ao sub-problema 1*/

}
    solução 
    #include <stdio.h>

main()
{
  int i, j, margem, largura, linhas_vazadas;
  char caracter;
  
  /** sub-problema 1 - ler margem , largura de desenho, caracter desenho e numero de linhas **/

  printf("\n=====================\n");
  printf("Entrar com margem => ");
  scanf("%d", &margem);
  printf("\n=====================\n");
  printf("Entrar com largura => ");
  scanf("%d", &largura);
  printf("\n=====================\n");
  printf("Entrar com caracter => ");
  scanf(" %c", &caracter);
  printf("\n=====================\n");
  printf("Entrar com linhas_vazadas => ");
  scanf(" %d", &linhas_vazadas);
  
  /* sub-problema 2 - desenhar linha de topo */

  /* desenhar margem */
  for (i=0;i<margem;i++) 
     printf(" ");
  /* desenhar restante da linha de topo */
  for (i=0;i<largura;i++)
     printf("%c", caracter);
  printf ("\n"); /* avançar para a próxima linha */

  /* sub-problema 3 - desenhar linhas vazadas */

  for (j=0;j<linhas_vazadas;j++) {
     /* desenhar margem */
     for (i=0;i<margem;i++) 
        printf(" ");
     if(largura>0)
        printf("%c", caracter);
     for (i=0;i<largura-2;i++)
          printf(" ");
     if(largura>1)
        printf("%c", caracter);
     printf("\n");
  }

  /* sub-problema 4 - desenhar linha de fundo */

  /* desenhar margem */
  for (i=0;i<margem;i++) 
     printf(" ");
  /* desenhar restante da linha de topo */
  for (i=0;i<largura;i++)
     printf("%c", caracter);
  printf ("\n"); /* avançar para a próxima linha */
}
  3. Construa um programa para desenhar a seguinte figura de forma parametrizável (dado caracter, margem, e número de linhas): ...AAAAAAAAAAAAAAAA ...AAAAAAAAAAAAAA ...AAAAAAAAAAAA ...AAAAAAAAAA ...AAAAAAAA ...AAAAAA ...AAAA ...AA ...BB ...BBBBB ...BBBBBBBB ...BBBBBBBBBBB ...BBBBBBBBBBBBBB ...BBBBBBBBBBBBBBBBB ...BBBBBBBBBBBBBBBBBBBB ...BBBBBBBBBBBBBBBBBBBBBBB </syntaxhighlight>
    solução 
    #include <stdio.h>

main()
{
  int i, j, margem, largura, linhas;
  char caracter1,caracter2;
  
  /** sub-problema 1 - ler margem , largura de desenho, caracter desenho e numero de linhas **/

  printf("\n=====================\n");
  printf("Entrar com margem => ");
  scanf("%d", &margem);
  printf("\n=====================\n");
  printf("Entrar com caracter 1 => ");
  scanf(" %c", &caracter1);
  printf("\n=====================\n");
  printf("Entrar com caracter 2 => ");
  scanf(" %c", &caracter2);
  printf("\n=====================\n");
  printf("Entrar com linhas (tem que ser maior ou igual a 1) => ");
  scanf(" %d", &linhas);
  
  /* sub-problema 2 - desenhar parte superior */

  for (i=linhas;i>0;i--) {
     /* desenhar margem */
     for (j=0;j<margem;j++) 
        printf(" ");
     for (j=0;j<i*2;j++) {
        printf("%c", caracter1);
     }
     printf("\n");
  }

  /* sub-problema 3 - desenhar parte inferior */
  for (i=1;i<=linhas;i++) {
     /* desenhar margem */
     for (j=0;j<margem;j++) 
        printf(" ");
     for (j=0;j<i*2;j++) {
        printf("%c", caracter2);
     }
     printf("\n");
  }

}

Exercícios Extras (resolver em sala)

  1. Escreva um programa em C que mostre a tabuada de um número fornecido pelo teclado. Esse número deve estar entre 1 e 10.
  2. Faça um programa em C que calcule a média de N números a serem lidos pelo teclado.
  3. Escreva um programa em C que leia até 10 números do teclado, e informe ao final qual o maior e o menor deles. A condição de parada do programa ocorre quando o usuário informar o valor -1.
  4. Escreva um programa C que teste se um número informado pelo teclado é primo.
    Solução 
    #include <stdio.h>

int main(){
  int n, num, k, primo;

  printf("Informe o número a ser testado: ");
  scanf("%d",&num);

  primo=0;

  for(k=2; k<num; k++)
     if((num%k) == 0)
          primo++;
  if(primo > 0)
     printf("%d não é primo\n", num);
  else
     printf("%d é primo\n", num);
     
  return 0;
}
  5. Escreva um programa C que calcule a série de Fibonacci até um número N informado pelo usuário (Ex. 1 1 2 3 5 8 13 21 ...)
    Solução 1 
    #include <stdio.h>

int main (void){
    int ant1, ant2, prox, i, n;

    printf("Informe o número de termos da série de Fibonacci\n");
    scanf("%d",&n);

    ant1 = ant2 = 1;

    printf("%d %d ", ant1 ,ant2);

    i = 3;
    while (i <= n){
        prox = ant1 + ant2;
        printf("%d ", prox);
        ant2 = ant1;
        ant1 = prox;
        i++;
    }
    printf("\n");
    return 0;
}
    Solução 2 
    #include <stdio.h>

int main()
{
  int seq, n1=0,n2=1,i,n;

  printf("Entre com n\n");
  scanf ("%d", &n);

  for(i=0;i<n;i=i+1) {
    if (i<=1) {
       seq = i;
    } else {
       seq = n1+n2;
       n1=n2;
       n2=seq;
    }
    printf("%d ", seq);
  }

  printf("\n");
  return 0;
}
    Solução 3 
    #include <stdio.h>

int main()
{
  int seq, n1=-1,n2=1,i,n;

  printf("Entre com n\n");
  scanf ("%d", &n);
  printf("A série é\n");
  for(i=0;i<n;i=i+1) {
       seq = n1+n2;
       n1=n2;
       n2=seq;
       printf("%d ", seq);
  }
  printf("\n");
  return 0;
}
  6. Escreva um programa C que calcule a média entre todos os números da série de Fibonacci até um número N informado pelo usuário (Ex. 1 1 2 3 5 8 13 21 ...)
    Solução 1 
    #include <stdio.h>

int main()
{
  int seq, n1=0,n2=1,i,n, cont_impar=0;
  float soma=0,media;

  printf("Entre com n\n");
  scanf ("%d", &n);

  for(i=0;i<n;i=i+1) {
    if (i<=1) {
       seq = i;
    } else {
       seq = n1+n2;
       n1=n2;
       n2=seq;
    }
    if ((seq%2)==1) {
       soma = soma + seq; // soma poderia ser inteiro... mas teria
                          // que ter cast no final
       cont_impar = cont_impar + 1;
    }
    printf("%d ", seq);
  }
  media = soma/cont_impar;
  printf("\nA média dos números ímpares é %.2f\n", media);
  return 0;
}
Disponível em “https://wiki.sj.ifsc.edu.br/index.php?title=Programação_1_-_Engenharia_-_Comandos_de_Repetição_no_C&oldid=173102”