Aulas PC IC 2021 Unid6

PROGRAMAÇÃO DE
COMPUTADORES:
Instruções de controle:
estruturas de repetição
Galeno J. de Sena
UNESP / Guaratinguetá / Brazil
(galeno.sena@unesp.br)
© UNESP/Sena, G. J. PC-IC-2021 FEG/UNESP

Estruturas de repetição
Instrução while:
Estrutura algorítmica:
enquanto (<condição>) faça
início Estrutura enquanto:
<instrução_1>; ➢ O bloco contendo as instruções
<instrução_2>; será executado repetidamente
... enquanto a <condição> for
<instrução_n>; verdadeira
fim; ➢ Laço de repetição, laço de
iteração, loop, looping, ...

Instrução while:
Forma Geral (sintaxe):
while (<condição>)
<bloco de instruções>
<bloco de instruções>:
<condição>: expressão { <instrução_1>;
relacional ou lógica <instrução_2>;
...
<instrução_n>; }

Instrução while:
while (<condição>)
Semântica:
1. A <condição> é avaliada
2. Se o resultado for verdadeiro:
a. O bloco de instruções será
executado
b. O controle retorna ao passo 1
3. Se o resultado for falso:
a. O controle é desviado para a
instrução seguinte ao while

Estruturas de repetição: instrução while
Exemplo: Algoritmo: cálculo do volume de várias esferas

início
cálculo do // declaração de variáveis
volume de real: R, V; // raio, volume
várias esferas // entrada de dados
escreva("Entre com raio <= 0 para parar!");
escreva("Raio: ");
leia(R);
// calcula volumes enquanto R > 0
Algoritmo: enquanto (R > 0)
início
// cálculo/saída do volume
V = (4./3.)*PI*(R^3); // PI=3.141593...
escreva("V(", R, "): ", V);
// próxima esfera
escreva("Raio: ");
leia(R);
fim; // enquanto
fim. // algoritmo

Exemplo:
Programa para cálculo do volume de várias esferas
// determinação volume de várias esferas
#include <stdio.h>
#include <math.h>
main() {
float R, V; // raio, volume
// entrada de dados
printf("\nEntre com raio<=0 para parar!\n");
printf("Raio: ");
scanf("%f", &R);
while (R > 0) {
V = (4./3.)*acos(-1)*pow(R,3); // pi=arccos(-1)
printf("V(%.1f): %.2f\n", R, V);
// proxima esfera
printf("Raio: ");
scanf("%f", &R);
}
}
Exemplo:
Programa para cálculo do
volume de várias esferas
// determinação volume de várias esferas
#include <stdio.h>
#include <math.h>
main() {
float R, V; // raio, volume
// entrada de dados
printf("\nEntre com raio<=0 para parar!\n");
printf("Raio: ");
scanf("%f", &R);
while (R > 0) {
V = (4./3.)*acos(-1)*pow(R,3); // pi=arccos(-1)
printf("V(%.1f): %.2f\n", R, V);
// proxima esfera
printf("Raio: ");
scanf("%f", &R);
}
}

// determinação volume de n esferas
#include <stdio.h>
#include <math.h>
main() {
Exemplo: int n, // n: numero de esferas
Programa para i; // i: variável de controle (contadora)
cálculo do volume float r, v; // raio, volume
// entrada do número de esferas
de n esferas printf("Quantas esferas? ");
scanf("%d", &n);
i = 1; // inicializa variável contadora
// calcula volumes de n esferas
Repetição com while (i <= n){
variável de // raio da i-ésima esfera
printf("Raio: ");
controle scanf("%f", &r);
(contadora) // cálculo/saída do volume
v = (4./3.)*acos(-1)*pow(r,3); // pi=arccos(-1)
printf("Volume da %da esfera = %.2f\n", i, v);
// incremento da variável contadora
i++;
}
}

#include <stdio.h> Repetição com variável
#include <math.h>
main() { de controle (contadora)
int n, // n: numero de esferas
i; // i: variável de controle (contadora)
float r, v; // raio, volume
// entrada do número de esferas
printf("Quantas esferas? ");
scanf("%d", &n);
while (i <= n){
// raio da i-ésima esfera
printf("Raio: ");
scanf("%f", &r);
// incremento da variável contadora
i++;
}
}

Observações sobre a instrução while:

➢ Implementação de uma estrutura de repetição com
teste no início: o bloco de instruções poderá não
ser executado nenhuma vez (ou, equivalentemente,
poderá ser executado 0, 1 ou mais vezes!)
➢ A execução do bloco de instruções deve fazer com
que a <condição> se torne falsa depois de um certo
número de iterações: caso contrário, o programa
não sairá do laço de repetição (“loop infinito”)
➢ Caso haja apenas uma instrução a ser repetida, as
chaves ({}) delimitadoras do bloco poderão ser
omitidas

// cálculo da média de um conjunto de
Instrução // n valores de entrada
#include <stdio.h>
while main() {
float x, s, m; // x: valor, s: soma, m: média
int i, n;
// entrada do número de valores
printf("\nn (>= 1) : ");
scanf("%d", &n);
Exemplo: s = 0; // inicializa variável de soma
while (i <= n) {
Cálculo da média // le valor
de um conjunto de printf("\nx = ");
scanf("%f", &x);
n valores de // acumula valor lido em s
entrada s = s + x; // "acumula" valor lido em s
// valores da i-ésima iteração
printf("n = %d, x = %.1f, s = %.2f\n", n, x, s);
// próximo valor de x
i++;
}
// cálculo e saída da média
if (n > 0) {
m = s / n;
printf("\nMedia = %.2f/%d=%.2f\n", s, n, m);
}
}

#include <stdio.h>
main() {
int n; // variável de controle (contadora)
// entrada do primeiro valor
printf("\nx (>= 0) : ");
scanf("%f", &x);
Exemplo: n = 0; // inicializa variável contadora
Cálculo da média de s = 0; // inicializa variável de soma
while (x >= 0) {
um conjunto de n = n+1; // incrementa variável contadora
valores de entrada s = s+x; // "acumula" valor lido em s
positivos (número de // valores da i-ésima iteração
elementos // próximo valor de x
desconhecido) printf("\nx (>= 0) : ");
scanf("%f", &x);
}
if (n > 0) {
m = s / n;
}
}

Instrução while
#include <stdio.h>
main() {
printf("\nx (>= 0) : ");
scanf("%f", &x);
n = 0; // inicializa variável contadora
s = 0; // inicializa variável de soma
while (x >= 0) {
n = n+1; // incrementa variável contadora
s = s+x; // "acumula" valor lido em s
// valores da i-ésima iteração
// próximo valor de x
printf("\nx (>= 0) : ");
scanf("%f", &x);
}
if (n > 0) {
m = s / n;
}
}
// le linha de texto e gera saída
// dos caracteres de entrada em maúsculo
#include <stdio.h>
#define EOL '\n' // "end of line"
main() {
Exemplo: int i=0, n; //i: índice chars; n: nro caracteres
programa que char linha[80]; // armazena linha de entrada
converte os // entrada da linha de texto
puts("Entre com uma linha de texto:");
caracteres de linha[i] = getchar(); // leitura primeiro caractere
uma linha de // entrada dos demais caracteres
entrada para while(linha[i] != EOL){
maiúsculas i++; // atualiza índice
linha[i] = getchar(); // leitura próximo char
}
n = i; // nro chars = último valor de i
// saída da linha, caracteres maiúsculos
i=0;
while (i < n){
putchar(toupper(linha[i])); // saída char (maiúsculo)
i++; // atualiza índice
}
}
#include <stdio.h>
main() {
int i=0, n; //i: índice chars; n: nro caracteres
char linha[80]; // armazena linha de entrada
// entrada da linha de texto
linha[i] = getchar(); // leitura primeiro caractere
// entrada dos demais caracteres
while(linha[i] != EOL){
linha[i] = getchar(); // leitura próximo char
}
i=0;
while (i < n){
putchar(toupper(linha[i])); // saída char (maiúsculo)
}
}
Exemplo: programa que gera saída de uma linha de entrada com
caracteres maiúsculos (versão mais compacta do exemplo anterior)

#include <stdio.h>
main() {
int i=0, n; //i: índice chars; n: nro caracteres
char linha[80]; // armazena linha de entrada
// entrada da linha de texto
// leitura dos caracteres (até EOL)
while((linha[i++] = getchar()) != EOL);
i=0;
while (i < n) // toupper(): conv. p/ maiúsculo
putchar(toupper(linha[i++]));
}

Instrução do-while:
Forma Geral
do
(sintaxe): <bloco de instruções>
while (<condição>);
...
<instrução_n> }

Estruturas de repetição: do-while
do
while (<condição>);
Semântica:
1. O <bloco de instruções> é
executado
O controle retorna ao passo 1
4. Se o resultado for falso:
O controle é desviado para a
instrução seguinte ao do-while

Estruturas de repetição: instrução do-while
Exemplo: cálculo de n!
/* calcula e apresenta o valor de n! */
#include <stdio.h>
main() {
// declaração de variáveis
int n, fat, i; // fat: fatorial; i: contadora
// entrada/validação de n
do {
printf("\nEntre com n (n>=0): ");
scanf("%d", &n);
} while (n < 0);
// calculo do fatorial de n
// n! = 1 x 2 x 3 x ... x n
fat = 1; i = 1; // inicialização
printf("\n"); // para "pular" uma linha
do {
fat *= i; // multiplica valor da sequência
// mostra valores intermediários
printf("\ti = %d, fat = %d\n", i, fat);
i++; // próximo valor da sequência
} while (i <= n);
// saída
printf("\nFatorial de %d = %d\n", n, fat);
}

#include <stdio.h>
main() {
do {
scanf("%d", &n);
} while (n < 0);
// n! = 1 x 2 x 3 x ... x n
do {
fat *= i; // multiplica valor da sequência
printf("\ti = %d, fat = %d\n", i, fat);
i++; // próximo valor da sequência
} while (i <= n);
// saída
}
#include <stdio.h>
main() {
do {
scanf("%d", &n);
} while (n < 0);
do
fat *= i++; // multiplica valor da sequência
while (i <= n);
// saída
}

Observações sobre a instrução do-while:

➢ Implementação de uma estrutura de repetição com teste no
final: o bloco de instruções será executado pelo menos
uma vez (ou, equivalentemente, será executado 1 ou mais
vezes!)
➢ A execução do bloco de instruções deve fazer com que a
<condição> se torne falsa depois de um certo número de
iterações: caso contrário, o programa não sairá do laço
de repetição (“loop” ou laço infinito)
➢ Caso haja apenas uma instrução a ser repetida, as chaves
({}) delimitadoras do bloco poderão ser omitidas
➢ É obrigatório o uso de um “;” no final de uma instrução
do-while!

#include <stdio.h>
int main () {
int i;
do {
printf ("\n\nSobre que pensador quer se informar:\n\n");
printf ("\t(1) Adam Smith\n");
printf ("\t(2) Abraham Maslow\n");
printf ("\t(3) Jurgen Habermas\n\n"); // Jürgen Habermas:
scanf("%d", &i);
Exemplo: } while ((i<1)||(i>3));
Menu de switch(i) {
case 1:
opções com printf("\t\tAdam Smith: pai da economia\n");
printf("\t\tTeoria do liberalismo economico\n");
do-while break;
case 2:
printf("\t\tAbraham Maslow: psicologo (EUA)\n");
printf("\t\tHierarquia de necessidades de Maslow\n");
break;
case 3:
printf("\t\tJürgen Habermas: filosofo alemao\n");
printf("\t\tTeoria do agir comunicativo\n");
break;
}
}
Instrução do-while
#include <stdio.h>
int main () {
Exemplo:
int i; Menu de
do {
printf ("\n\nSobre que pensador quer se informar:\n\n");
opções com
printf ("\t(1) Adam Smith\n"); do-while
printf ("\t(2) Abraham Maslow\n");
printf ("\t(3) Jurgen Habermas\n\n"); // Jürgen Habermas:
scanf("%d", &i);
} while ((i<1)||(i>3));
switch(i) {
case 1:
printf("\t\tAdam Smith: pai da economia\n");
printf("\t\tTeoria do liberalismo economico\n");
break;
case 2:
printf("\t\tAbraham Maslow: psicologo (EUA)\n");
printf("\t\tHierarquia de necessidades de Maslow\n");
break;
case 3:
printf("\t\tJürgen Habermas: filosofo alemao\n");
printf("\t\tTeoria do agir comunicativo\n");
break;
}
}

Estruturas de repetição encadeadas (while, do-while)
#include <stdio.h>
#include <math.h>
main() {
int n, i; // i: variável contadora
// entrada de dados
Exemplo: printf("\nQuantas esferas? ");
Cálculo do volume scanf("%d", &n);
de n esferas c/ // calcula volumes de n esferas
validação do raio while (i <= n) {
// entrada/validação i-ésimo raio
do {
printf("Raio: ");
scanf("%f", &r);
} while (r <= 0);
i++; // incremento var. contadora
}
}

Estruturas de repetição encadeadas (while, do-while)
Exemplo: volume de n esferas c/ validação do raio
#include <stdio.h>
#include <math.h>
main() {
int n, i; // i: variável contadora
// entrada de dados
printf("\nQuantas esferas? ");
scanf("%d", &n);
while (i <= n) {
// entrada/validação i-ésimo raio
do {
printf("Raio: ");
scanf("%f", &r);
} while (r <= 0);
i++; // incremento var. contadora
}
}

Estruturas de repetição: o loop for
Instrução for: forma Geral (sintaxe):

for (<inicialização>; <condição>; <atualização>)
...
<instrução_n>; }
Repetição com variável de controle (contadora)

Instruções de controle: laço for
for (<inicialização>; <condição>; <atualização>)
Semântica:
1. A expressão de <inicialização> é
executada: a variável contadora é
inicializada
3. Se o resultado da avaliação for falso:
O controle será desviado para a
instrução seguinte ao for
a. O <bloco de instruções> será
executado
b. A expressão de <atualização> é
executada: incremento ou decremento
da variável de controle
c. O fluxo de execução retorna ao
passo 2
Estruturas de repetição: laço for
Exemplo:
Gera uma sequência de inteiros de 1 a n
#include <stdio.h>
int main()
{
int i, n;
printf("\nEntre com n: \n");
scanf("%d", &n);
// gera sequência de 1 a n
puts("Sequencia: ");
for (i=1; i<=n; i++) {
printf("%d\n", i);
}
}

Exemplo:
Gera a tabuada de um valor n (1<=n<=9)
// tabuada de n, 1 <= n <= 9

#include<stdio.h>
#include<stdlib.h>
main() {
int i, n; //declaração de variáveis
// entrada de n
do {
printf("\nEntre com n (entre 1 e 9): ");
scanf("%d", &n);
} while(n<1 || n>9);
// gera tabuada
printf("\nTabuada de %d: \n", n);
for (i = 1; i <=10; i++)
printf("\n%2d x %2d = %2d" , n, i, n*i);
}

Exemplo:
Gera a tabuada de um
valor n (1<=n<=9)
// tabuada de n, 1 <= n <= 9
#include<stdio.h>
#include<stdlib.h>
main() {
int i, n; //declaração de variáveis
// entrada de n
do {
printf("\nEntre com n (entre 1 e 9): ");
scanf("%d", &n);
} while(n<1 || n>9);
// gera tabuada
printf("\nTabuada de %d: \n", n);
for (i = 1; i <=10; i++)
printf("\n%2d x %2d = %2d" , n, i, n*i);
}
Exemplo:
Gera a saída dos múltiplos de 4, no intervalo: [4,100]
#include<stdio.h>
main() {
int i; // variável contadora
// gera e mostra os múltiplos
for (i = 4; i<=100 ; i += 4) {// incrementa de 3 em 3.
printf("%3d\t", i);
}
}

Exemplo:
Gera a saída dos múltiplos de 4, no intervalo: [4,100],
mostrando 5 valores em cada linha da saída
// mostra os múltiplos de 4
// entre 4 e 100
#include<stdio.h>
main() {
int i, j=0; // variável contadora
// gera e mostra os múltiplos
for (i = 4; i<=100 ; i += 4) { // incrementa de 4 em 4
printf("%3d\t", i);
// controle de saída: 5 valores por linha
j++;
if (j==5) {
printf("\n");
j=0;
}
}
}

Exemplo: /* calcula e apresenta o valor de n! */
#include <stdio.h>
Programa para o main() {
cálculo de n! // declaração de variáveis
int n, fat, j; // fat: fatorial; j: contadora
do {
scanf("%d", &n);
} while (n < 0);
// cálculo de n!
// n! = n x (n-1) x (n-2) x ... x 2 x 1
fat = 1; // inicialização
for (j=n; j>=1; j--) {
fat *= j; // multiplica valor da sequência
printf("\ti = %d, fat = %d\n", j, fat);
}
// saída
}

/* calcula e apresenta o valor de n! */ Exemplo:
#include <stdio.h>
main() { Programa para o
// declaração de variáveis cálculo de n!
do {
scanf("%d", &n);
} while (n < 0);
// cálculo de n!
// n! = n x (n-1) x (n-2) x ... x 2 x 1
fat = 1; // inicialização
for (j=n; j>=1; j--) {
fat *= j; // multiplica valor da sequência
printf("\ti = %d, fat = %d\n", j, fat);
}
// saída
}

Exemplo:
Programa para o cálculo de n!
/* inicialização/atribuição na instrução for */
#include <stdio.h>
main() {
do { Qualquer das 3 partes de um for:
<inicialização>,
printf("\nEntre com n (n>=0): "); <condição>, <atualização>
scanf("%d", &n); Pode conter mais de uma instrução
} while (n < 0);
// calculo de n!
(separadas por vírgula)
// n! = n x (n-1) x (n-2) x ... x 2 x 1
for (fat=1, j=n; j>=1; fat*=j, j--); // ou fat*=j--
// saída
}
Estruturas de repetição: laços for encaixados
Exemplo:
O laço for mais interno é executado
// for's "aninhados" (encaixados) repetidamente, para cada iteração do laço
// nested for loops for mais externo!
#include <stdio.h>
int main() {
int i, j; // declaração
// estruturas for "aninhadas"
for (i=0; i<2; i++) {
for (j=0; j<3; j++) {
printf("i = %d \t j = %d\n", i, j);
}
}
}

Estruturas de repetição: laços for aninhados
/* calcula e apresenta os valores de
fatorial de k, para k = 0, ..., n */
#include <stdio.h>
main() {
int n, fat, j, k;
Exemplo: printf("\nEntre com n (n>=0): ");
Programa para scanf("%d", &n);
// calculo do fatorial de k, k=0, ..., n
o cálculo de k!, // k == 0 => k! = 1;
k = 0, …, n // k != 0 => k! = k x (k-1) x ... x 2 x 1
for (k=0; k<=n; k++) {
fat=1;
for (j=k; j>=1; j--) {
fat*=j;
}
printf("Fatorial de %d = %d\n", k, fat);
}
}

Estruturas de repetição: laços for aninhados
Exemplo:
/* calcula e apresenta os valores de
fatorial de k, para k = 0, ..., n */
Programa para o cálculo de k!, k = 0, …, n
#include <stdio.h>
main() {
int n, fat, j, k;
scanf("%d", &n);
// calculo do fatorial de k, k=0, ..., n
// k == 0 => k! = 1;
// k != 0 => k! = k x (k-1) x ... x 2 x 1
for (k=0; k<=n; k++) {
fat=1;
for (j=k; j>=1; j--) {
fat*=j;
}
printf("Fatorial de %d = %d\n", k, fat);
}
}

Estruturas de repetição: laços for
// cálculo da média de um conjunto

// de valores de entrada (não negativos)
#include <stdio.h>
main() {
Exemplo: float x, s, m; // x: valor, s: soma, m: média
Programa para // entrada do primeiro valor
cálculo da média printf("\nx (>= 0) : ");
scanf("%f", &x);
de um conjunto for(n=0, s=0; x>=0; n++){
de valores de s+=x; // acumula x (>=0)
printf("\nx (>= 0) : "); // próximo valor
entrada scanf("%f", &x);
}
if (n > 0){
m = s / n;
}
}

// cálculo da média de um conjunto Exemplo:

// de valores de entrada (não negativos) Programa para cálculo da média de um
#include <stdio.h>
main() { conjunto de valores de entrada
printf("\nx (>= 0) : ");
scanf("%f", &x);
for(n=0, s=0; x>=0; n++){
s+=x; // acumula x (>=0)
printf("\nx (>= 0) : "); // próximo valor
scanf("%f", &x);
}
if (n > 0){
m = s / n;
}
}

Exemplo:
Programa que mostra o uso de uma variável do tipo char como
variável contadora em um laço for
#include<stdio.h>
/* mostra as letras minúsculas/maiúsculas
com os respectivos códigos ASCII */
main()
{
char ch, CH;
for (ch = 'a', CH = 'A'; ch <= 'z', CH <= 'Z'; ch++, CH++) {
printf("\nCaractere: %c Codigo (ASCII): %d", CH, (int) CH);
printf("\t\tCaractere: %c Codigo (ASCII): %d", ch, (int) ch);
}
}

Exemplo:
Variável do tipo char como variável contadora em um laço for

Instruções break/continue
Instrução break:
Finaliza a execução de um laço de repetição, desviando o controle para o
primeiro comando subsequente ao laço (ou, equivalentemente, para fora
do laço)
o No caso de várias estruturas de repetição “aninhadas”, o comando
break transferirá o controle para fora do laço que o contém, mas não
para fora de todas as estruturas de repetição externas
o Laços de repetição: while, do-while, for; utilizado também para sair de
um switch

#include <stdio.h>
#include <math.h>
main() {
int n, i;
float r, v;
// número de esferas
Exemplo: printf("Quantas esferas? ");
Cálculo do volume scanf("%d", &n);
i = 1;
de n esferas, // calcula volumes de n esferas
interropendo-se a while (i <= n) {
execução se raio <= 0 printf("Raio: ");
scanf("%f", &r);
if (r <= 0) {
puts("\nRaio invalido!");
break; // sai do laço while
}
v = (4./3.)*acos(-1.0)*pow(r,3); // pi=arccos(-1)
i++;
}
}

Instrução continue:
Durante a execução de um laço de repetição, caso o controle encontre
uma instrução continue, o restante do <bloco de instruções> do laço será
ignorado:
o Estruturas com while/do-while: o controle é desviado para a execução
da expressão de <condição> do laço
o Estrutura com for: o controle é desviado inicialmente para a execução
da expressão de <atualização> do laço e, depois, para a expressão de
<condição>

#include <stdio.h>
#include <math.h>
main() {
int n, i;
float r, v;
Exemplo: printf("Quantas esferas? ");
scanf("%d", &n);
Cálculo do volume i = 1; // inicializa contador
de n esferas // calcula volumes de n esferas
while (i <= n) {
(ignorando-se // raio da i-ésima esfera
valores de raios printf("Raio: ");
scanf("%f", &r);
negativos ou nulos) if (r <= 0) {
puts("Raio invalido!");
continue; // retorna ao teste do while
}
v = (4./3.)*acos(-1.0)*pow(r,3);
i++; // incrementa contador
}
}

#include <stdio.h>
#include <math.h>
Exemplo:
main() { Cálculo do volume
int n, i;
float r, v;
de n esferas
scanf("%d", &n);
i = 1; // inicializa contador
while (i <= n) {
printf("Raio: ");
scanf("%f", &r);
if (r <= 0) {
continue; // retorna ao teste do while
}
v = (4./3.)*acos(-1.0)*pow(r,3);
i++; // incrementa contador
}
}

// determinação volume de n esferas Exemplo:
#include <stdio.h>
#include <math.h> Cálculo do volume
main() { de n esferas,
int n, i;
float r, v; ignorando-se r <= 0
// número de esferas (solução com for)
scanf("%d", &n);
for (i=1; i<=n; i++) {
printf("Raio: ");
scanf("%f", &r);
if (r <= 0) {
continue;
}
v = (4./3.)*acos(-1.0)*pow(r,3);
}
}

#include <stdio.h> Exemplo:
#include <math.h>
main() { Cálculo do volume de n esferas,
int n, i; ignorando-se r <= 0 (solução com for)
float r, v;
scanf("%d", &n);
for (i=1; i<=n; i++) {
printf("Raio: ");
scanf("%f", &r);
if (r <= 0) {
i--; // volta 1a iteração no for
continue;
}
v = (4./3.)*acos(-1.0)*pow(r,3);
}
}

Aulas PC IC 2021 Unid6

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Aulas PC IC 2021 Unid6

Enviado por

Direitos autorais:

Formatos disponíveis

PROGRAMAÇÃO DE

© UNESP/Sena, G. J. PC-IC-2021 FEG/UNESP

© UNESP/Sena, G. J. PC-IC-2021 FEG/UNESP

© UNESP/Sena, G. J. PC-IC-2021 FEG/UNESP

© UNESP/Sena, G. J. PC-IC-2021 FEG/UNESP

Exemplo: Algoritmo: cálculo do volume de várias esferas

© UNESP/Sena, G. J. PC-IC-2021 FEG/UNESP

© UNESP/Sena, G. J. PC-IC-2021 FEG/UNESP

© UNESP/Sena, G. J. PC-IC-2021 FEG/UNESP

© UNESP/Sena, G. J. PC-IC-2021 FEG/UNESP

Observações sobre a instrução while:

© UNESP/Sena, G. J. PC-IC-2021 FEG/UNESP

© UNESP/Sena, G. J. PC-IC-2021 FEG/UNESP

© UNESP/Sena, G. J. PC-IC-2021 FEG/UNESP

// le linha de texto e gera saída

© UNESP/Sena, G. J. PC-IC-2021 FEG/UNESP

© UNESP/Sena, G. J. PC-IC-2021 FEG/UNESP

© UNESP/Sena, G. J. PC-IC-2021 FEG/UNESP

© UNESP/Sena, G. J. PC-IC-2021 FEG/UNESP

© UNESP/Sena, G. J. PC-IC-2021 FEG/UNESP

Observações sobre a instrução do-while:

© UNESP/Sena, G. J. PC-IC-2021 FEG/UNESP

© UNESP/Sena, G. J. PC-IC-2021 FEG/UNESP

© UNESP/Sena, G. J. PC-IC-2021 FEG/UNESP

© UNESP/Sena, G. J. PC-IC-2021 FEG/UNESP

Instrução for: forma Geral (sintaxe):

Repetição com variável de controle (contadora)

© UNESP/Sena, G. J. PC-IC-2021 FEG/UNESP

© UNESP/Sena, G. J. PC-IC-2021 FEG/UNESP

// tabuada de n, 1 <= n <= 9

© UNESP/Sena, G. J. PC-IC-2021 FEG/UNESP

© UNESP/Sena, G. J. PC-IC-2021 FEG/UNESP

© UNESP/Sena, G. J. PC-IC-2021 FEG/UNESP

© UNESP/Sena, G. J. PC-IC-2021 FEG/UNESP

© UNESP/Sena, G. J. PC-IC-2021 FEG/UNESP

© UNESP/Sena, G. J. PC-IC-2021 FEG/UNESP

© UNESP/Sena, G. J. PC-IC-2021 FEG/UNESP

© UNESP/Sena, G. J. PC-IC-2021 FEG/UNESP

// cálculo da média de um conjunto

© UNESP/Sena, G. J. PC-IC-2021 FEG/UNESP

// cálculo da média de um conjunto Exemplo:

© UNESP/Sena, G. J. PC-IC-2021 FEG/UNESP

© UNESP/Sena, G. J. PC-IC-2021 FEG/UNESP

© UNESP/Sena, G. J. PC-IC-2021 FEG/UNESP

© UNESP/Sena, G. J. PC-IC-2021 FEG/UNESP

© UNESP/Sena, G. J. PC-IC-2021 FEG/UNESP

© UNESP/Sena, G. J. PC-IC-2021 FEG/UNESP

© UNESP/Sena, G. J. PC-IC-2021 FEG/UNESP

© UNESP/Sena, G. J. PC-IC-2021 FEG/UNESP

© UNESP/Sena, G. J. PC-IC-2021 FEG/UNESP

© UNESP/Sena, G. J. PC-IC-2021 FEG/UNESP

Você também pode gostar