Introdução à Computação - IME-USPmcesar/Aulas_C_01_02_03.pdf · Algumas funções Matemáticas...

Mauro Cesar Bernardes

20/Maio/2014

Introdução à Computação - Linguagem C: aulas 01 , 02 e 03

Agenda

• Introdução à linguagem C

– Material de apoio • Livro: http://grauna.ime.usp.br/mod/url/view.php?id=1893

• Codeblocks: http://grauna.ime.usp.br/mod/url/view.php?id=1887

• Comandos Básicos: – printf

– scanf

– while

– for

– if ... Else

• Funções

Processos de tradução

Existem diversas linguagens de programação de alto nível.

Por exemplo: C, C++, Java, Pascal, Delphi, etc.

Os programas de computador são, geralmente, escritos utilizando uma linguagem de programação de alto nível (na qual um código ou programa fonte é criado) e são traduzidos para a linguagem de máquina

Os 2 principais processos que traduzem programas escritos em uma linguagem de alto nível para a linguagem de máquina são interpretação e compilação

Processo de Interpretação

Um interpretador é um programa que recebe como entrada um arquivo contendo um programa fonte

O interpretador lê linha a linha este arquivo de entrada, e executa uma a uma as instruções que estão nele codificadas segundo uma linguagem de programação.

Interpretador

Programa fonte

Exemplo: teste.py

interpretador Execução

Processo de Interpretação

Programa fonte Exemplo: teste.py

print("Olá mundo!")

Processo de Compilação

Um compilador é um programa (ou um conjunto de programas) que recebe como entrada um programa fonte e cria um novo arquivo executável como saída;

O arquivo de entrada é o código fonte escrito pelo programador

O arquivo que o compilador produz, é normalmente identificado como código objeto

Este código objeto contém instruções de baixo nível, traduzidas para a linguagem de máquina

Processo de Compilação

Compilador

Programa fonte Exemplo: teste.c

010011100110011101001011000111101010110011001001

Programa objeto

Arquitetura Execução

O código produzido não é portável para qualquer arquitetura

Diferentes compiladores são construídos para as diferentes arquiteturas de processadores (diferentes famílias de processadores possuem conjuntos diferentes de instruções)

O compilador somente gera corretamente o código objeto caso não tenha encontrado um erro de compilação

#include <stdio.h> #include <stdlib.h> main() { printf ("Alo mundo!"); system("PAUSE"); }

Compiladores e a

Linguagem C

9

Histórico da Linguagem C

• Criada por Denis Ritchie, na década de 1970, para uso em um computador DEC PDP-11 em Unix

• C++ é uma extensão da linguagem C

• O sistema Unix é escrito em C e C++

10

Estrutura básica de um

programa C

diretivas para o pré-processador

declaração de variáveis globais

main ()

{

declaração de variáveis locais da função main

comandos da função main

}

11

Diretivas para o processador

– Bibliotecas -

• Diretiva #include permite incluir uma biblioteca

• Bibliotecas contêm funções pré-definidas, utilizadas nos programas

• Exemplos

Funções de texto #include <string.h>

Funções matemáticas #include <math.h>

Funções padrão #include <stdlib.h>

Funções de entrada e saída #include <stdio.h>

12

Exemplo:

Algumas funções Matemáticas da biblioteca

math.h

Tangente de x tan(x) tan

Raiz quadrada de x sqrt(x) sqrt

Seno de x sin(x) sin

Calcula x elevado à potência y pow(x, y) pow

Logaritmo decimal de x log10(x) log10

Logaritmo natural de x log(x) log

Arredonda o número real para baixo; floor(3.2) é 3 floor(x) floor

Valor absoluto de x fabs(x) fabs

e elevado à potencia x exp(x) exp

Cosseno de x (x em radianos) cos(x) cos

Arredonda o número real para cima; ceil(3.2) é 4 ceil(x) ceil

Comentário Exemplo Função

#include <math.h>

13

CodeBlocks

Para saber mais: http://grauna.ime.usp.br/mod/url/view.php?id=1887

14

Usando o CodeBlocks #include <stdio.h>

#include <stdlib.h>

main()

{

printf ("Alo mundo!");

system("PAUSE");

}

15

Usando o CodeBlocks

16

Usando o CodeBlocks

Introdução à

Linguagem C

O esqueleto de um Programa em C

#include <stdio.h>

/* protótipos de funções */

int main()

{

/* declaração de variáveis */

/* lista de comandos */

return 0; /* comandos terminam com ; */

} /* blocos de comandos entre {} */

/* demais funções */

19

Exemplo 1

/* meu primeiro programa C */

#include <stdio.h>

#include <stdlib.h>

main()

{

printf ("Alo mundo!"); //mostra

system("PAUSE"); //fica parado

}

20

Declaração de

variáveis

21

Declaração de variáveis

• Uma variável é um local na memória do computador em que um valor pode ser armazenado para ser usado por um programa

• Antes de ser usada, uma variável precisa ser declarada por um nome e um tipo de dado, imediatamente após a chave { inicial do main();

• Os nomes das variáveis devem conter apenas letras, dígitos e o símbolo _ e iniciar sempre com letra ou _

• Os principais tipos são: int, float, double e char • Exemplos int n;

int quantidade_valores;

float x, y, somaValores;

char sexo;

char nome[40];

C diferencia letras maiúsculas de minúsculas! int n, N;

n é diferente de N!

Escopo de Variável em

linguagem C

Escopo de Variável

• Escopo define onde e quando uma variável pode ser usada em um programa.

• As variáveis podem ter escopo Local ou Global

• Uma variável é chamada local quando é declarada dentro de uma função. Nesse caso:

– Ela existe apenas dentro da função que a contém.

– Após o término da execução da função, ela deixa de existir.

• Uma variável é chamada global quando é declarada fora de qualquer função. Nesse caso:

– Pode ser acessada em qualquer parte do programa.

– Ela existe durante toda a execução do programa.

Escopo de Variável

• Variável Local (Escopo de função): variável declarada na lista de parâmetros da função ou definida dentro da função.

Exemplo: ...

int minha_fun (int x, int y) {

int i, j; /* x,y,i e j visíveis apenas dentro da função */

...

}

int main()

{

x = i+j; /* erro: x, i e j não definidos */ return x;

}

Escopo de Variável

• Variável Global: Variável declarada fora das funções tem escopo de arquivo:

Exemplo: #include <stdio.h>

int i; /* variavel global */

/* visivel em todo programa */

void incr_i() {

i++;

}

...

void main() {

printf(”%d”, i);

}

Escopo de Variável

• Boa prática de programação: – Deve-se evitar o uso de variáveis globais.

– As funções devem modificar apenas as suas variáveis locais e as variáveis passadas a elas como parâmetros.

#include <stdio.h>

#include <math.h>

#include <stdlib.h>

int f1(int a, int b);

int f2(int b, int a);


int main( ) {

int a=2, b=5, c=0;

float d=0;

printf("Ponto 1(main): a=%d b=%d c=%d d=%f \n", a, b, c, d);

c=f1(a, b);


return 0; }

int f1(int a, int b) {

int c;

float d;

a=a+1;

b=b*2;

c=f2(a, b);

d= (float) a/b;

printf("Ponto 4(f1): a=%d b=%d c=%d d=%f \n", a, b, c, d);

return a+b; }

int f2(int b, int a){

int c;

float d;

b=b+2;

a=a+1;

c=f3(b,a);

d= (float) a/b;


return a+c;}

int f3(int a, int b){

int c;

float d;

a=a+1;

b=b+1;

c=a+b;

d= (float) b/a;


return b+c; }

#include <stdio.h>

#include <math.h>

#include <stdlib.h>


int f2(int b, int a);


int main( ) {

int a=2, b=5, c=0;

float d=0;


c=f1(a, b);


return 0; }

int f1(int a, int b) {

int c;

float d;

a=a+1;

b=b*2;

c=f2(a, b);

d= (float) a/b;


return a+b; }

int f2(int b, int a){

int c;

float d;

b=b+2;

a=a+1;

c=f3(b,a);

d= (float) a/b;


return a+c;}

int f3(int a, int b){

int c;

float d;

a=a+1;

b=b+1;

c=a+b;

d= (float) b/a;


return b+c; }

a, b, c, d: variáveis locais da função main() Visíveis apenas no escopo da função main()

a, b, c, d: variáveis locais da função f1() Visíveis apenas no escopo de f1()



Comentários

1

2 /* Comentários são ignorados

3 pelo compilador C e não geram

4 nenhum tipo de código-objeto em

5 linguagem de máquina. Ou seja, o

6 computador não irá considerar os

7 comentários e nenhuma ação será

8 realizada em relação a eles

9 quando o programa for

10 executado. */

11 // comentário de uma única linha

12

Primeiro Programa em C

1

2 #include <stdio.h>

3

4 int main ()

5 {

6 printf("Bem-vindo ao C!\n");

7

8 return 0;

9

10 }

Utilizando o Codeblocks

Compilando e executando

Resultado

Primeiro Programa em C

1


3

4 int main ()

5 {

6 printf("Bem-vindo ao C!\n");

7

8 return 0;

9

10 }

system ("PAUSE");

#include <stdlib>

34

Exemplo simples:

• Algoritmo:

– Leia um número

– Leia outro número

– Some os dois números

– Apresente o resultado

Desenvolva um programa em C que leia

dois números e apresente o resultado

da soma entre eles.

35

Traduzindo em um programa C

int main ()

{

}

printf ("Digite o primeiro numero=");

printf ("Digite o segundo numero="); scanf("%d", &numero1);

scanf("%d", &numero2);

int numero1;

int numero2;

#include <stdio.h>

soma=numero1 + numero2;

int soma;

printf("A soma dos dois numeros eh= %d", soma);

system ("pause");

return 0;

#include <stdlib.h>

Onde estão os erros? #include <stdlib.h>

int main ()

{

int Numero1;

int Numero2;

int soma;

printf ("Digite o primeiro numero=“)

scanf("%d", numero1);

printf ("Digite o segundo numero=“)

scanf("%d", numero2);


printf("A soma dos dois numeros eh= soma”);

system (pause);

return 0;

}

Onde estão os erros? #include <stdlib.h>

#include <stdio.h>

int main ()

{

int numero1;

int numero2;

int soma;

printf ("Digite o primeiro numero=“);


printf ("Digite o segundo numero=“);



printf("A soma dos dois numeros eh= %d”,soma);

system (“pause”);

return 0;

}

• int idade atual;

• int valor_total;

• int 1salario;

• int numero1, numero2, numero3;

• int N1; N2; N3;

• int V1, V2, V3;

• int v1=5, v2=5, v3=5;

• int v1=v2=v3=5;

• int _salario;

Jogo dos erros

39

Comandos de atribuição

40

Comando de atribuição

• Atribui o valor da direita à variável da esquerda

• O valor pode ser:

– uma constante,

– uma variável ou

– uma expressão

• Exemplos x = 4; // lemos: x recebe 4

y = x + 2; // lemos: y recebe (x mais 2)

y = y + 4; // lemos: y recebe (y mais 4)

valor = 2.5; // lemos: valor recebe 2.5

41

Operadores de Atribuição

Equivale a x = x % y x %= y %=

Equivale a x = x / y x /= y /=

Equivale a x = x * y x *= y *=

Equivale a x = x – y x -= y -=

Equivale a x = x + y x += y +=

Atribui o valor de y a x x = y =

Comentário Exemplo Operador

42

Aritmética em C

43

Operação em C Operador Aritmético

Expressão Algébrica

Expressão em C

Adição + f + 7 f + 7

Subtração - p – c p - c

Multiplicação * bm b * m

Divisão / x/y ou ou x÷y

x/y

Módulo ou resto da

divisão entre 2 inteiros

%

r mod s

r % s

x y _

Operadores aritméticos

44

Entrada e Saída de

Dados

45

Entrada de Dados

• Função scanf() scanf ("formatos", &var1, &var2,...)

Exemplos: #include <stdlib.h>

#include <stdio.h>

int main(void)

{

int numero1, numero2, numero3, numero4, numero5;


scanf("%d %d", &numero2, &numero3);

scanf("%d,%d", &numero4, &numero5);

system("PAUSE");

}

46

Entrada de Dados

• Função scanf() scanf ("formatos", &var1, &var2,...)

Outros Exemplos:

int i, j;

float x;

char c, nome[20];

scanf("%d", &i);

scanf("%d %f", &j, &x);

scanf("%c", &c);

scanf("%s", &nome);

Discutiremos esse tópico com mais

detalhes em slides futuros...

47

Entrada de Dados

• Função scanf() Código Significado

%c Lê um único caractere %d Lê um decimal inteiro %i Lê um decimal inteiro (não pode ser octal ou hexadecimal)

%u Lê um decimal sem sinal %e Lê um número em ponto flutuante com sinal opcional

%f Lê um número em ponto flutuante com ponto opcional

%g Lê um número em ponto flutuante com expoente opcional (double)

%o Lê um número em base octal %s Lê uma string %x Lê um número em base hexadecimal %p Lê um ponteiro

48

Algoritmo

Na Linguagem C...

#include <stdio.h>

#include <stdlib.h>

int main()

{

int n1, n2;

scanf ("%d",&n1);

scanf ("%d",&n2);

system("PAUSE");

return 0;

}

ler n1

ler n2

ler n1 n2

scanf ("%d %d",&n1,&n2);

Entrada de Dados (Exemplo)

49

Saída de Dados

• Função printf() printf ("formatos", var1, var2,...)

Exemplos: int i, j;

float x;

char c;

printf("%d", i);

printf("%d %f", j, x);

printf("%c", c);

%d inteiro

%f float

%lf double

%c char

%s string

50

Saída de Dados (Exemplo)

#include <stdio.h>

#include <stdlib.h>

int main()

{

int i, j;

float x;

i = 1;

j = 2;

x = 3;

printf("%d", i);

printf("%d %f", j, x);

system("PAUSE");

return 0;

}

51

Saída de Dados (Exemplo)

#include <stdio.h>

#include <stdlib.h>

int main()

{

// definicao de variaveis

float n1, n2, n3, media;

// entrada de dados

scanf ("%f %f %f",&n1, &n2, &n3);

// operacao

media=(n1+n2+n3)/3;

// saida de dados

printf("%f", n1);

printf("%f", n2);

printf("%f", n3);

printf("%f", media);

system("PAUSE");

return 0;

}

52

Saída de Dados (Exemplo) #include <stdio.h>

#include <stdlib.h>

int main()

{

// definicao de variaveis

int i, j;

float x;

//entrada de dados

scanf("%d", &i);

scanf("%d %f", &j, &x);

// exibicao de dados

printf("I= %d\n", i);

printf("J= %d\nX= %f\n", j, x);

system("PAUSE");

return 0;

}

53

O que é exibido em cada instrução?

Considere que x=2; e y=3;

1 printf ("%d", x);

2 printf ("%d", x+y);

3 printf ("x=");

4 printf ("x=%d", x);

5 printf ("%d= %d", x+y, y+x);

6 z= x + y;

7 scanf ("%d %d", &x, &y);

8 /* printf ("x + y = %d", x+y); */

9 printf ("\n");

10 // printf("%d", x*y);

54

Entrada e Saída

Exemplo 8

#include <stdio.h>

#include <stdlib.h>

int main()

{


printf("Digite 3 notas: ");

scanf ("%f %f %f",&n1, &n2, &n3);

media=(n1+n2+n3)/3;

printf ("Media: %.2f\n",media);

system("PAUSE");

return 0;

}

Exemplo 7

#include <stdio.h>

#include <stdlib.h>

int main()

{


scanf("%f %f %f",&n1,&n2,&n3);

media=(n1+n2+n3)/3;

printf ("%f",media);

system("PAUSE");

return 0;

}

55

Algoritmo:

Ler primeiro número;

Ler segundo número;

Ler terceiro número

Calcular o produto

Apresentar resultado

Na Linguagem C...

Ler 3 números e calcular

o produto e apresentar o

resultado

Problema:

#include <stdio.h>

#include <stdlib.h>

int main()

{

int n1, n2, n3, produto;

system("PAUSE");

return 0;

}

56

Algoritmo:




Calcular o produto


Na Linguagem C...



resultado

Problema:

#include <stdio.h>

#include <stdlib.h>

int main()

{


printf("Forneca n1=“);

scanf("%d", &n1);


scanf("%d", &n2);


scanf("%d", &n3);

produto= n1*n2*n3;

printf(“Produto=%d”,produto);

system("PAUSE");

return 0;

}

57

Algoritmo:




Calcular o produto


Na Linguagem C... (outra forma) Problema:

#include <stdio.h>

#include <stdlib.h>

int main()

{


printf("Forneca n1 n2 n3=“);

scanf("%d %d %d", &n1, &n2, &n3);

produto= n1*n2*n3;


system("PAUSE");

return 0;

}



resultado

58

Algoritmo:




Calcular o produto


Na Linguagem C... (mais uma) Problema:

#include <stdio.h>

#include <stdlib.h>

int main()

{


printf("Forneca n1 n2 n3=“);

scanf("%d,%d,%d", &n1, &n2, &n3);

produto= n1*n2*n3;


system("PAUSE");

return 0;

}



resultado

59

Dicas...

• Preste MUITA atenção ao digitar o seu programa. É muito fácil “esquecer” um ponto-e-vírgula (;), ou esquecer de fechar chaves {} e parênteses ().

• Leia com cuidado as mensagens do compilador. A maioria das mensagens de warning são causadas por erros de lógica ou digitação. Por exemplo, ao digitar “=” ao invés de “==” em uma expressão relacional, o compilador gera um warning.

• Na linguagem C, caracteres minúsculos e maiúsculos são diferenciados.

• As variáveis num1, Num1, NUm1, e NUM1 são todas diferentes, mas essas diferenças são difíceis de notar.

• Procure utilizar nomes significativos para variáveis. Ao invés de a, b e c, você pode utilizar algo como idade, altura e peso.

• Você não pode utilizar palavras reservadas como int, if, for, while, etc., como nome de suas variáveis.

• Fonte: http://www.ime.usp.br/~hitoshi/introducao/03-Fundamentos.pdf

Dicas:

61

Expressão Relacional

62

Expressão Relacional

• Considere a seguinte declaração: int x=5, y=6, z=10;

• Qual o resultado para as seguintes expressões? (x>y)

(x>(y+z))

((x*2)<= z)

(z != (2*x))

((2*x) == z)

(y <= (z-4))

((-x+2 + (2*y+1) + z*2)!= 21)

F

F

V

F

V

V

V

63

Comando de Repetição

while()

...

while(<condição>)

{

<comando_1>;

<comando_2>;

<comando_3>;

}

...

Comando de Repetição: while()

/* permite repetir um conjunto de

comandos enquanto uma condição for

verdadeira. */

• Escreva um programa em C que leia um número inteiro positivo n e calcula o fatorial de n.

Atividade I:

Uma solução: Atividade I

#include <stdio.h>

int main() {

int n;

int i = 1;

int fat = 1;

printf("Digite n: ");

scanf ("%d", &n);

while (i <= n)

{

fat *= i;

i++;

}

printf("fat(%d) = %d\n", n, fat);

return 0;

}

67

Comando de Repetição

for()

/* Sintaxe */

for (<inicialização>; <condição>; <incremento>)

{

<comandos>

}

Comando de Repetição: for()

#include <stdio.h>

int main()

{

int i;

for (i=1;i<10;i++)

printf("valor de i: %d \n",i);

return 0;

}

Comando de Repetição: for() #include <stdio.h>

int main()

{

int i;

for (i=1;i<10;i++)

printf("valor de i: %d \n",i);

return 0;

}

#include <stdio.h>

int main ()

{

int n, cont, fat;

printf("numero para calculo: ");

scanf("%d", &n);

fat = 1;

for (cont = 1; cont <= n; cont=cont+1)

fat = fat * cont;

printf("fat(%d) = %d\n", n, fat);

return 0;

}

Outra solução: Atividade I

71

funções

#include <stdio.h>

int fat(int n);

int main()

{

int n, f;

printf("Digite n: ");

scanf ("%d", &n);

f = fat(n);

printf("fat(%d) = %d\n", n, f);

return 0;

}

int fat(int n)

{

int i, resultado = 1;

for (i = 1; i<=n; i++)

resultado *= i;

return resultado;

}

Outra solução: Atividade I

• Escreva um programa em C que apresente o quadrado dos n primeiros números.

Atividade II:

Atividade II:

Uma solução poderia ser: 1. Utilize a variável do tipo inteiro n para armazenar o

limite da contagem 2. Utilize a variável do tipo inteiro contador como um

contador de 1 a n; 3. Utilize uma variável do tipo inteiro quadrado para

armazenar o cálculo do quadrado; 4. Escreva uma mensagem para o usuário; 5. Leia o valor de n; 6. Inicialize contador com 1; 7. Enquanto contador menor ou igual a n faça:

(a) calcule o quadrado de n (b) apresente o valor de quadrado; (c) incremente em 1 a variável contador;

8. fim

Uma solução: Atividade II

#include <stdio.h>

#include <stdlib.h>

int main()

{

int contador=1, n, quadrado;

printf("Ate onde deseja calcular? (forneca um inteiro): ");

scanf("%d", &n);

while (contador <=n)

{

quadrado= contador * contador;

printf ("O quadrado de %d eh %d \n", contador, quadrado);

contador= contador+1;

}

system ("pause");

return 0;

}

• Escreva um programa em C que apresente os números ímpares até n.

Atividade III:

Atividade III:

Uma solução poderia ser: 1. Utilize a variável do tipo inteiro n para armazenar

o limite da contagem; 2. Utilize a variável do tipo inteiro contador

como um contador de 1 a n; 3. Imprima uma mensagem para o usuário; 4. Leia o valor de n; 5. Inicialize contador com 1; 6. Enquanto contador menor ou igual a n faça:

(a) apresente o valor de contador; (b) incremente em 2 a variável contador;

7. fim

Uma solução: Atividade III

#include <stdio.h>

#include <stdlib.h>

int main()

{

int contador=1, n;

printf("Ate onde deseja contar? (forneca um inteiro): ");

scanf("%d", &n);

while (contador <=n)

{

printf("%d \n", contador);

contador= contador+2;

}

system ("pause");

return 0;

}

• Escreva um programa em C para que calcule os quadrados e os cubos dos números de 0 a 10 e apresente os resultados

Atividade IV:

Atividade IV:

Uma solução poderia ser: 1. imprima uma mensagem com o título (numero quadrado cubo); 2. Utilize a variável to tipo inteiro contador

como um contador de 0 a 10 3. Inicialize contador com 0; 4. enquanto contador menor ou igual a 10 faça:

(a) calcule e apresente o quadrado de contador (b) calcule e apresente o cubo de contador (c) incremente em 1 a variável contador

5. fim

Uma solução: #include <stdio.h>

#include <stdlib.h>

int main ()

{

int contador, quadrado , cubo;

contador=0;

/* programa */

printf("numero quadrado cubo\n");

while ( contador <= 10)

{

quadrado= contador*contador;

cubo= contador*contador*contador;

printf(" %d %d %d\n", contador, quadrado, cubo);

contador=contador+1;

}

system ("pause");

return 0;

}

• Altere o programa anterior para respeitar as tabulações, conforme resultado abaixo

Desafio:

Dica: teste o uso de \t no printf

• Leia um número inteiro n e, em seguida, leia n números e calcule a soma. Exemplo:

Se n = 5 e os n(5) números forem: 5 12 8 7 3

Atividade V:

soma= 5 + 12 + 8 + 7 + 3

Atividade V

1. Declare variáveis para armazenar a quantidade de números (n) a serem lidos, a soma (soma)e cada número lido (num);

2. imprima uma mensagem para o usuário saber o que fazer 3. leia pelo teclado a quantidade de números a serem somados

e armazene na variável n 4. enquanto n maior que zero faça:

(a) leia pelo teclado o número na variável num (b) acumule na variável soma o número lido e armazenado em num (c) diminua 1 da variável n

5. imprima o conteúdo da variável soma 6. fim

Uma solução poderia ser:

#include <stdio.h>

#include <stdlib.h>

int main ()

{

int n, num , soma;

soma=0;

/* programa */

printf ("Digite a quantidade de numeros a serem somados: " );

scanf ("%d", &n );

while ( n > 0)

{

printf ("Digite um numero: " );

scanf ("%d", &num );

soma = soma + num;

n=n-1;

}

printf ("Soma dos numeros eh= %d \n" , soma);

system ("pause");

return 0;

}

Exemplo de Solução: atividade V

Desenvolva programas em C para:

1) Ler dois inteiros x e y. Calcular e apresentar o resultado de x .

2) Ler um inteiro x, calcular e apresentar o valor do fatorial de x;

3) Calcular e escrever o menor n tal que 1 + 2 + 3 + 4 + 5 + 6 +...+ n >1000.

4) Ler um inteiro x, calcular seu quadrado e apresentar o resultado até que seja fornecido o valor 0 para x.

5) Ler um inteiro x, calcular e apresentar os múltiplos do inteiro 2 menores que x (exemplo: 0, 2, 4, 6, 8, 10, 12, 14, 16, ...x).

Mais exercícios:

y

87

Comando de Seleção

Simples e Composta

Comando de Seleção Simples e

Composta

Seleção Simples Seleção Composta

if (<condição>)

{

<comando_1>;

<comando_2>;

...

<comando_n>

}

if (<condição>)

{

<comando_1>;

<comando_2>;

...

<comando_n>

}

else

{

<outro-comando_1>;

<outro-comando_2>;

...

<outro-comando_n>

}

Comando de Seleção Simples e

Composta

Seleção Simples Seleção Composta

if (<condição>)

<comando>;

if (<condição>)

<comando>;

else

<outro-comando>;

• Observação: Se dentro do if ou do else existir apenas um comando, não é necessário colocá-lo entre chaves.

Comando de Seleção Simples

...

if (<condição>)

{

<comando_1>;

<comando_2>;

...

<comando_n>

}

...

Fluxo do programa

V

F

Comando de Seleção Composta

...

if (<condição>)

{

<comando_1>;

<comando_2>;

...

<comando_n>

}

else

{

<comando_1>;

<comando_2>;

...

<comando_n>

}

...

Fluxo do programa

V

F

• Escreva um programa em C que leia um número inteiro n e chama uma função absoluto(n) devolve o seu valor absoluto.

• Uma solução poderia ser: 1. imprima uma mensagem para o usuário saber o que fazer; 2. leia pelo teclado um número inteiro em uma variável do

tipo inteiro n;

3. Chama a função absoluto() passando n como parâmetro

4. Na função

1. se n for negativo, transforme-o para positivo;

2. Retorne o valor para o programa principal

5. De volta ao programa principal 1. Imprimir resultado 2. fim

Exemplo 1

#include <stdio.h>

#include <stdlib.h>

int absoluto (int n1);

int main()

{

int n;

printf ("Digite um numero inteiro: ");

scanf ("%d", &n);

printf("%d \n", absoluto(n));

system ("pause");

return 0;

}

int absoluto (int n1)

{

if (n1<0)

return -n1;

else

return n1;

}

Exemplo 1: solução

Exemplo 1: resultado

• Escreva um programa em C que leia 2 números inteiros e imprima o maior.

• Uma solução poderia ser: 1. imprima uma mensagem para o usuário saber o que

fazer 2. leia pelo teclado dois números inteiros num1 e num2 3. se num1 maior que num2 (a) maior = num1 4. senão (a) maior = num2 5. imprime o conteúdo da variável maior 6. fim

Exemplo 2

#include <stdio.h>

#include <stdlib.h>

int main ()

{

int num1, num2, maior;

printf ("Forneca o primeiro numero:" );

scanf ("%d", &num1);

printf ("Forneca o segundo numero:" );


if ( num1 > num2 )

{

maior = num1;

}

else

{

maior = num2 ;

}

printf("O maior numero e: %d \n", maior);

system ("pause");

return 0;

}

Exemplo 2: solução

Exemplo 2: resultado

#include <stdio.h>

#include <stdlib.h>

int main ()

{

int num1, num2;





if ( num1 > num2 )

printf("O numero %d eh maior que %d. \n", num1, num2);

if (num1 < num2)


if (num1 == num2)

printf ("Os dois numeros lidos (%d) sao iguais. \n", num1);

system ("pause");

return 0;

}

Exemplo 2: outra solução

Exemplo 2: outra solução

#include <stdio.h>

#include <stdlib.h>

int main ()

{

int num1, num2;





if ( num1 != num2 )

{ if (num1 > num2)


else if (num1 < num2)


}

else

printf ("Os dois numeros lidos (%d) sao iguais. \n", num1);

system ("pause");

return 0;

}

Exemplo 2: uma solução mais

elaborada...

Exemplo 2: uma solução mais elaborada...

• Dados um número inteiro n>0 e uma sequência com n números inteiros, determinar a soma dos inteiros positivos da sequência.

• Por exemplo, para n=7 e para a sequência com n=7 números inteiros

6 −2 7 0 −5 8 4

• o seu programa deve escrever o número 25.

Exemplo 3

Exemplo 3 • Uma solução poderia ser:

1. imprima uma mensagem para o usuário saber o que fazer 2. leia pelo teclado a quantidade de números da sequencia na variável n 3. inicialize uma variável soma com zero 4. enquanto n maior que zero faça:

(a) leia pelo teclado o número da sequência na variável num

(b) se num maior que zero

i. acumule na variável soma o número lido

(c) diminua 1 da variável n

5. imprima na tela a soma final 6. fim


2 #include <stdlib.h>

3 int main ()

4 {

5 /* declarações */

6 int n, num , soma;

7 soma=0;

8 /* programa */

9 printf ("Digite a quantidade de numeros da sequencia : " );

10 scanf ("%d", &n );

11 while ( n > 0)

12 {

13 printf ("Digite um numero: " );

14 scanf ("%d", &num );

15 if ( num > 0)

16 soma = soma + num;

17 n=n-1;

18 }

19 printf ("Soma dos numeros positivos da sequencia = %d\n" , soma);

20 system ("pause");

21 return 0;

22 }

Exemplo 3: uma solução


1) Ler dois inteiros positivos x e y. Calcular e apresentar o resultado de x .




5) Ler um inteiro x, calcular e apresentar os múltiplos do inteiro 2 menores que x (exemplo:0, 2, 4, 6, 8, 10, 12, 14, 16, ...x).

Mais exercícios:

y

Exercício 1: uma solução #include <stdio.h>

#include <stdlib.h>

int main ()

{

int x, y, resultado=1,contador=1;

printf("Forneca o valor de x= ");

scanf ("%d", &x);

printf("Forneca o valor de y= ");

scanf ("%d", &y);

while (contador <= y)

{

resultado= resultado * x;

contador= contador + 1;

}

printf ("\n%d elevado a %d= %d \n",x, y, resultado);

system ("pause");

return 0;

}

Exercício 1: uma solução







Mais exercícios:

y

Exercício 2: uma solução #include <stdio.h>

#include <stdlib.h>

int main ()

{

int x, fatorial=1;

printf("Forneca o valor de x= ");

scanf ("%d", &x);

while (x > 1)

{

fatorial= fatorial * x;

x= x -1;

}

printf ("\nO fatorial eh: %d \n",fatorial);

system ("pause");

return 0;

}







Mais exercícios:

y


#include <stdio.h>

#include <stdlib.h>

int main ()

{

int n=0, soma=0;

while (soma < 1000)

{

soma= soma + n;

if (soma < 1000)

n= n +1;

}

printf ("\nO resultado eh: %d \n", n);

system ("pause");

return 0;

}







Mais exercícios:

y


#include <stdio.h>

#include <stdlib.h>

int main ()

{

int x;

printf ("forneca o valor de x= ");

scanf("%d", &x);

while (x != 0)

{

printf ("o quadrado de %d eh = %d", x, x*x);

printf ("\n\nforneca o valor de x= ");

scanf ("%d", &x);

}

system ("pause");

return 0;

}







Mais exercícios:

y


#include <stdio.h>

#include <stdlib.h>

int main ()

{

int x, contador=0, multiplo;


scanf("%d", &x);

printf ("os multiplos de 2 menores (<) que %d sao: \n", x);

while (multiplo < x)

{

multiplo= contador * 2;

if (multiplo < x)

printf (" %d ", multiplo);


}

system ("pause");

return 0;

} Atualizado em 22/08, 14h45min

• Ler um ano e verificar se ele é bissexto. Para calcular o Ano Bissexto, existem quatro regras principais. Como a última regra "só" acontece a cada 3300 anos, consideramos na prática apenas as três primeiras. Um ano é bissexto se o mês de fevereiro tem 29 dias. O dia (convencionadamente, 29 de fevereiro) que é acrescentado à contagem do ano solar (365 dias), em intervalos regulares de quatro anos (exceto nos de número múltiplo de 100 que não seja também múltiplo de 400). É uma forma de corrigir a discrepância entre o calendário convencional e o tempo de translação da Terra em torno do Sol. [Fonte: Dicionário Houaiss da Língua Portuguesa.] Em outras palavras: A regra concreta é que um ano é bissexto se é múltiplo de 4 (ex: 2008). A primeira exceção é que se for múltiplo de 4 mas também de 100, deixa de ser bissexto (ex: 2100). E a segunda exceção é que se for múltiplo de 4, de 100 e também de 400, então é bissexto (ex: 2000). Por exemplo, 1914 não foi bissexto; 2114 também não será, pois não são múltiplos de 4; mas 2004 foi ano bissexto, pois é múltiplo de 4. [Fonte: Wikipédia.] Logo, um ano bissexto deve ser múltiplo de 4 (ou múltiplo de 100 e também múltiplo de 400). Exemplo: 2000 foi um ano bissexto, mas 2100 não será bissexto.

O significado matemático das quatro regras principais: 1) "acrescentamos" 1 dia a cada 4 anos (quando o ano é múltiplo de 4); 2) "deixamos de acrescentar" 1 dia a cada 100 anos (último ano de cada século, cujos dígitos terminam com dois zeros, ou seja, um ano secular); 3) "acrescentamos" 1 dia a cada 400 anos (quando o ano é múltiplo de 400); 4) "deixamos de acrescentar" 1 dia a cada 3300 anos. Isso decorre da definição do Ano Solar: 1 Ano Solar ~ 365,242199 ~ 365 + 1/4 - 1/100 + 1/400 - 1/3300. O valor exato de 365 + 1/4 - 1/100 + 1/400 - 1/3300 é 365,24219696969696... Essa soma de frações é praticamente igual ao valor do Ano Solar: 365,242199.

Mais exercícios (*):

(*): Com colaboração do aluno Netanias Costa da Silva

• Ler um ano e verificar se ele é bissexto . A explicação do Ano Bissexto e dos cálculos está indicada com detalhes nos links abaixo. Link 1: Costa, J. R .V. Os anos bissextos. Astronomia no Zênite, dez. 2002. Disponível em: http://www.zenite.nu?anobissexto Link 2: http://pt.wikipedia.org/wiki/Ano_bissexto Link 3: http://books.google.com.br/books?id=IPWZCh1awFIC&lpg=PA30&ots=xo0C-hQNri&dq=365%2C2422&hl=pt-BR&pg=PA30#v=onepage&q=365,2422&f=false Link 4: http://astro.if.ufrgs.br/tempo/tempo.htm



http://www.zenite.nu/?anobissexto


http://pt.wikipedia.org/wiki/Ano_bissexto

http://books.google.com.br/books?id=IPWZCh1awFIC&lpg=PA30&ots=xo0C-hQNri&dq=365,2422&hl=pt-BR&pg=PA30















http://astro.if.ufrgs.br/tempo/tempo.htm

• Dizemos que um número natural é triangular se ele é produto de três números naturais consecutivos.

• Exemplo: 120 é triangular, pois 4*5*6 =120.

• Dado um inteiro não-negativo n, verificar se n é triangular.

Mais exercícios:

A solução para esses e outros exercícios você encontra na lista de exercícios em http://www.ime.usp.br/~macmulti/exercicios/inteiros/index.html.

123

Comando de Seleção

(if’s aninhados).

• A linguagem C padrão também permite o uso de if’s alinhados, obedecendo à forma:

If’s aninhados...

...

if (condicao1)

{

comando1;

comando2;

}

else if (condicao2)

{

comando3;

comando4;

}

else

{

comando5;

comando6;

}

...

ou

...

if (condição1)

comando1;

else if (condição2)

comando2;


comando3;

else

comando4;

...


If’s aninhados...

...

if (condicao1)

{

comando1;

comando2;

}

else if (condicao2)

{

comando3;

comando4;

}

else

{

comando5;

comando6;

}

...

ou

...

if (condição1)

comando1;


comando2;


comando3;

else

comando4;

...

V


If’s aninhados...

...

if (condicao1)

{

comando1;

comando2;

}

else if (condicao2)

{

comando3;

comando4;

}

else

{

comando5;

comando6;

}

...

ou

...

if (condição1)

comando1;


comando2;


comando3;

else

comando4;

...

F

V


If’s aninhados...

...

if (condicao1)

{

comando1;

comando2;

}

else if (condicao2)

{

comando3;

comando4;

}

else

{

comando5;

comando6;

}

...

ou

...

if (condição1)

comando1;


comando2;


comando3;

else

comando4;

...

F

F

Desenvolva uma calculadora simples em Linguagem C. Essa calculadora deve ser capaz de realizar as 4 operações básicas (+,-,*,/) sobre dois números lidos e apresentar o resultado

Para a resolução, declare três variáveis do tipo inteiro para armazenar os dois números a serem lidos e a operação a ser realizada, da seguinte forma:

1 para Somar

2 para Subtrair

3 para Multiplicar

4 para Dividir

Atividade 1

#include <stdio.h>

#include <stdlib.h>

int main ()

{

int n1, n2, operacao;

printf ("forneca o valor do primeiro numero:");

scanf("%d", &n1);

printf ("forneca o valor do segundo numero:");

scanf("%d", &n2);

printf ("\nEscolha a operacao");

printf ("\n1 para Somar");

printf ("\n2 para Subtrair");

printf ("\n3 para Multiplicar");

printf ("\n4 para Dividir");

scanf ("%d", &operacao);

if (operacao==1)

printf("o resultado da soma eh= %d \n", n1+n2);

else if (operacao==2)

printf("o resultado da subtracao eh= %d \n", n1-n2);


printf ("o resultado da multiplicacao eh= %d\n", n1*n2);


printf("o resultado da divisao eh= %d \n", n1/n2);

else printf("opcao invalida!");

system ("pause");

return 0;

}

Uma solução para a atividade 1

#include <stdio.h>

#include <stdlib.h>

int main ()

{



scanf("%d", &n1);


scanf("%d", &n2);







if (operacao==1)









system ("pause");

return 0;

}

Memória

0123456%&2345123’”231231asd 1234@%dfd!4%@#%qwerq21123 er1234123412341234qwerqwerwqerqwerqwerqwqr1241241414144111124asd21$#@121121#12asd

Saída

#include <stdio.h>

#include <stdlib.h>

int main ()

{



scanf("%d", &n1);


scanf("%d", &n2);







if (operacao==1)









system ("pause");

return 0;

}


Memória

Saída

#include <stdio.h>

#include <stdlib.h>

int main ()

{



scanf("%d", &n1);


scanf("%d", &n2);







if (operacao==1)









system ("pause");

return 0;

}

Memória


Saída

n1 n2 operacao

#include <stdio.h>

#include <stdlib.h>

int main ()

{



scanf("%d", &n1);


scanf("%d", &n2);







if (operacao==1)









system ("pause");

return 0;

}

Memória


Saída

forneca o valor do primeiro numero:

n1 n2 operacao

#include <stdio.h>

#include <stdlib.h>

int main ()

{



scanf("%d", &n1);


scanf("%d", &n2);







if (operacao==1)









system ("pause");

return 0;

}

Memória


Saída

forneca o valor do primeiro numero: 6

n1 n2 operacao

#include <stdio.h>

#include <stdlib.h>

int main ()

{



scanf("%d", &n1);


scanf("%d", &n2);







if (operacao==1)









system ("pause");

return 0;

}

Memória

6 &2345123’”231231asd 1234@%dfd!4%@#%qwerq21123 er1234123412341234qwerqwerwqerqwerqwerqwqr1241241414144111124asd21$#@121121#12asd

Saída

forneca o valor do primeiro numero: 6

n1 n2 operacao

#include <stdio.h>

#include <stdlib.h>

int main ()

{



scanf("%d", &n1);


scanf("%d", &n2);







if (operacao==1)









system ("pause");

return 0;

}

Memória

6 &2345123’”231231asd 1234@%dfd!4%@#%qwerq21123 er1234123412341234qwerqwerwqerqwerqwerqwqr1241241414144111124asd21$#@121121#12asd

Saída

forneca o valor do primeiro numero: 6 Forneca o valor do segundo numero:

n1 n2 operacao

#include <stdio.h>

#include <stdlib.h>

int main ()

{



scanf("%d", &n1);


scanf("%d", &n2);







if (operacao==1)









system ("pause");

return 0;

}

Memória

6 5 ”231231asd 1234@%dfd!4%@#%qwerq21123 er1234123412341234qwerqwerwqerqwerqwerqwqr1241241414144111124asd21$#@121121#12asd

Saída

forneca o valor do primeiro numero: 6 Forneca o valor do segundo numero: 5

n1 n2 operacao

#include <stdio.h>

#include <stdlib.h>

int main ()

{



scanf("%d", &n1);


scanf("%d", &n2);







if (operacao==1)









system ("pause");

return 0;

}

Memória


Saída

forneca o valor do primeiro numero: 6 Forneca o valor do segundo numero: 5 Escolha a operacao

n1 n2 operacao

#include <stdio.h>

#include <stdlib.h>

int main ()

{



scanf("%d", &n1);


scanf("%d", &n2);







if (operacao==1)









system ("pause");

return 0;

}

Memória


Saída

forneca o valor do primeiro numero: 6 Forneca o valor do segundo numero: 5 Escolha a operacao 1 para Somar

n1 n2 operacao

#include <stdio.h>

#include <stdlib.h>

int main ()

{



scanf("%d", &n1);


scanf("%d", &n2);







if (operacao==1)









system ("pause");

return 0;

}

Memória


Saída

forneca o valor do primeiro numero: 6 Forneca o valor do segundo numero: 5 Escolha a operacao 1 para Somar 2 para Subtrair

n1 n2 operacao

#include <stdio.h>

#include <stdlib.h>

int main ()

{



scanf("%d", &n1);


scanf("%d", &n2);







if (operacao==1)









system ("pause");

return 0;

}

Memória


Saída

forneca o valor do primeiro numero: 6 Forneca o valor do segundo numero: 5 Escolha a operacao 1 para Somar 2 para Subtrair 3 para Multiplicar

n1 n2 operacao

#include <stdio.h>

#include <stdlib.h>

int main ()

{



scanf("%d", &n1);


scanf("%d", &n2);







if (operacao==1)









system ("pause");

return 0;

}

Memória


Saída

forneca o valor do primeiro numero: 6 Forneca o valor do segundo numero: 5 Escolha a operacao 1 para Somar 2 para Subtrair 3 para Multiplicar 4 para Dividir

n1 n2 operacao

#include <stdio.h>

#include <stdlib.h>

int main ()

{



scanf("%d", &n1);


scanf("%d", &n2);







if (operacao==1)









system ("pause");

return 0;

}

Memória

6 5 3 1234@%dfd!4%@#%qwerq21123 er1234123412341234qwerqwerwqerqwerqwerqwqr1241241414144111124asd21$#@121121#12asd

Saída

forneca o valor do primeiro numero: 6 Forneca o valor do segundo numero: 5 Escolha a operacao 1 para Somar 2 para Subtrair 3 para Multiplicar 4 para Dividir3

n1 n2 operacao

#include <stdio.h>

#include <stdlib.h>

int main ()

{



scanf("%d", &n1);


scanf("%d", &n2);







if (operacao==1)









system ("pause");

return 0;

}

Memória

6 5 3 1234@%dfd!4%@#%qwerq21123 er1234123412341234qwerqwerwqerqwerqwerqwqr1241241414144111124asd21$#@121121#12asd

Saída

forneca o valor do primeiro numero: 6 Forneca o valor do segundo numero: 5 Escolha a operacao 1 para Somar 2 para Subtrair 3 para Multiplicar 4 para Dividir3 o resultado da multiplicacao eh= 30

n1 n2 operacao

O que precisa ser alterado no programa anterior para que haja repetição das operações até que seja digitado 0?

1 para Somar

2 para Subtrair

3 para Multiplicar

4 para Dividir

0 para sair

Desafio

Desafio: uma solução #include <stdio.h>

#include <stdlib.h>

int main ()

{

int n1, n2, operacao=1;


scanf("%d", &n1);


scanf("%d", &n2);

while (operacao != 0)

{






printf ("\n0 para sair");


if (operacao==1)









}

system ("pause");

return 0;

}

153

Resolução de

Exercícios


1) Ler dois inteiros positivos x e y. Calcular e apresentar o resultado de x .





Mais exercícios:

y


#include <stdio.h>

#include <stdlib.h>

int main ()

{

int n=0, soma=0;

while (soma < 1000)

{

soma= soma + n;

if (soma < 1000)

n= n +1;

}


system ("pause");

return 0;

}

Memória


Saída


#include <stdio.h>

#include <stdlib.h>

int main ()

{

int n=0, soma=0;

while (soma < 1000)

{

soma= soma + n;

if (soma < 1000)

n= n +1;

}


system ("pause");

return 0;

}

Memória

0 0 231231asd 1234@%dfd!4%@#%qwerq21123 er1234123412341234qwerqwerwqerqwerqwerqwqr1241241414144111124asd21$#@121121#12asd

Saída

n soma


#include <stdio.h>

#include <stdlib.h>

int main ()

{

int n=0, soma=0;

while (soma < 1000)

{

soma= soma + n;

if (soma < 1000)

n= n +1;

}


system ("pause");

return 0;

}

Memória


Saída

n soma

V


#include <stdio.h>

#include <stdlib.h>

int main ()

{

int n=0, soma=0;

while (soma < 1000)

{

soma= soma + n;

if (soma < 1000)

n= n +1;

}


system ("pause");

return 0;

}

Memória


Saída

n soma

V

1ª iteração


#include <stdio.h>

#include <stdlib.h>

int main ()

{

int n=0, soma=0;

while (soma < 1000)

{

soma= soma + n;

if (soma < 1000)

n= n +1;

}


system ("pause");

return 0;

}

Memória


Saída

n soma

V

V

1ª iteração


#include <stdio.h>

#include <stdlib.h>

int main ()

{

int n=0, soma=0;

while (soma < 1000)

{

soma= soma + n;

if (soma < 1000)

n= n +1;

}


system ("pause");

return 0;

}

Memória


Saída

n soma

V


#include <stdio.h>

#include <stdlib.h>

int main ()

{

int n=0, soma=0;

while (soma < 1000)

{

soma= soma + n;

if (soma < 1000)

n= n +1;

}


system ("pause");

return 0;

}

Memória


Saída

n soma

V

2ª iteração


#include <stdio.h>

#include <stdlib.h>

int main ()

{

int n=0, soma=0;

while (soma < 1000)

{

soma= soma + n;

if (soma < 1000)

n= n +1;

}


system ("pause");

return 0;

}

Memória


Saída

n soma

V

V

2ª iteração


#include <stdio.h>

#include <stdlib.h>

int main ()

{

int n=0, soma=0;

while (soma < 1000)

{

soma= soma + n;

if (soma < 1000)

n= n +1;

}


system ("pause");

return 0;

}

Memória


Saída

n soma

V


#include <stdio.h>

#include <stdlib.h>

int main ()

{

int n=0, soma=0;

while (soma < 1000)

{

soma= soma + n;

if (soma < 1000)

n= n +1;

}


system ("pause");

return 0;

}

Memória


Saída

n soma

V

3ª iteração


#include <stdio.h>

#include <stdlib.h>

int main ()

{

int n=0, soma=0;

while (soma < 1000)

{

soma= soma + n;

if (soma < 1000)

n= n +1;

}


system ("pause");

return 0;

}

Memória


Saída

n soma

V

V

3ª iteração


#include <stdio.h>

#include <stdlib.h>

int main ()

{

int n=0, soma=0;

while (soma < 1000)

{

soma= soma + n;

if (soma < 1000)

n= n +1;

}


system ("pause");

return 0;

}

Memória


Saída

n soma

V


#include <stdio.h>

#include <stdlib.h>

int main ()

{

int n=0, soma=0;

while (soma < 1000)

{

soma= soma + n;

if (soma < 1000)

n= n +1;

}


system ("pause");

return 0;

}

Memória


Saída

n soma

V

4ª iteração


#include <stdio.h>

#include <stdlib.h>

int main ()

{

int n=0, soma=0;

while (soma < 1000)

{

soma= soma + n;

if (soma < 1000)

n= n +1;

}


system ("pause");

return 0;

}

Memória


Saída

n soma

V

V

4ª iteração


#include <stdio.h>

#include <stdlib.h>

int main ()

{

int n=0, soma=0;

while (soma < 1000)

{

soma= soma + n;

if (soma < 1000)

n= n +1;

}


system ("pause");

return 0;

}

Memória


Saída

n soma

V


#include <stdio.h>

#include <stdlib.h>

int main ()

{

int n=0, soma=0;

while (soma < 1000)

{

soma= soma + n;

if (soma < 1000)

n= n +1;

}


system ("pause");

return 0;

}

Memória


Saída

n soma

V

5ª iteração


#include <stdio.h>

#include <stdlib.h>

int main ()

{

int n=0, soma=0;

while (soma < 1000)

{

soma= soma + n;

if (soma < 1000)

n= n +1;

}


system ("pause");

return 0;

}

Memória


Saída

n soma

V

V

5ª iteração


#include <stdio.h>

#include <stdlib.h>

int main ()

{

int n=0, soma=0;

while (soma < 1000)

{

soma= soma + n;

if (soma < 1000)

n= n +1;

}


system ("pause");

return 0;

}

Memória


Saída

n soma

V


#include <stdio.h>

#include <stdlib.h>

int main ()

{

int n=0, soma=0;

while (soma < 1000)

{

soma= soma + n;

if (soma < 1000)

n= n +1;

}


system ("pause");

return 0;

}

Memória


Saída

n soma

V

6ª iteração


#include <stdio.h>

#include <stdlib.h>

int main ()

{

int n=0, soma=0;

while (soma < 1000)

{

soma= soma + n;

if (soma < 1000)

n= n +1;

}


system ("pause");

return 0;

}

Memória


Saída

n soma

V

V

6ª iteração


#include <stdio.h>

#include <stdlib.h>

int main ()

{

int n=0, soma=0;

while (soma < 1000)

{

soma= soma + n;

if (soma < 1000)

n= n +1;

}


system ("pause");

return 0;

}

Memória


Saída

n soma

V


#include <stdio.h>

#include <stdlib.h>

int main ()

{

int n=0, soma=0;

while (soma < 1000)

{

soma= soma + n;

if (soma < 1000)

n= n +1;

}


system ("pause");

return 0;

}

Memória


Saída

n soma

V

7ª iteração


#include <stdio.h>

#include <stdlib.h>

int main ()

{

int n=0, soma=0;

while (soma < 1000)

{

soma= soma + n;

if (soma < 1000)

n= n +1;

}


system ("pause");

return 0;

}

Memória


Saída

n soma

V

V

7ª iteração


#include <stdio.h>

#include <stdlib.h>

int main ()

{

int n=0, soma=0;

while (soma < 1000)

{

soma= soma + n;

if (soma < 1000)

n= n +1;

}


system ("pause");

return 0;

}

Memória


Saída

n soma

V


#include <stdio.h>

#include <stdlib.h>

int main ()

{

int n=0, soma=0;

while (soma < 1000)

{

soma= soma + n;

if (soma < 1000)

n= n +1;

}


system ("pause");

return 0;

}

Memória


Saída

n soma

V

8ª iteração


#include <stdio.h>

#include <stdlib.h>

int main ()

{

int n=0, soma=0;

while (soma < 1000)

{

soma= soma + n;

if (soma < 1000)

n= n +1;

}


system ("pause");

return 0;

}

Memória


Saída

n soma

V

V

8ª iteração


#include <stdio.h>

#include <stdlib.h>

int main ()

{

int n=0, soma=0;

while (soma < 1000)

{

soma= soma + n;

if (soma < 1000)

n= n +1;

}


system ("pause");

return 0;

}

Memória


Saída

n soma

V


#include <stdio.h>

#include <stdlib.h>

int main ()

{

int n=0, soma=0;

while (soma < 1000)

{

soma= soma + n;

if (soma < 1000)

n= n +1;

}


system ("pause");

return 0;

}

Memória


Saída

n soma

V

9ª iteração


#include <stdio.h>

#include <stdlib.h>

int main ()

{

int n=0, soma=0;

while (soma < 1000)

{

soma= soma + n;

if (soma < 1000)

n= n +1;

}


system ("pause");

return 0;

}

Memória


Saída

n soma

V

V

9ª iteração


#include <stdio.h>

#include <stdlib.h>

int main ()

{

int n=0, soma=0;

while (soma < 1000)

{

soma= soma + n;

if (soma < 1000)

n= n +1;

}


system ("pause");

return 0;

}

Memória


Saída

n soma

V

após 44 iterações...


#include <stdio.h>

#include <stdlib.h>

int main ()

{

int n=0, soma=0;

while (soma < 1000)

{

soma= soma + n;

if (soma < 1000)

n= n +1;

}


system ("pause");

return 0;

}

Memória


Saída

n soma

V

45ª iteração


#include <stdio.h>

#include <stdlib.h>

int main ()

{

int n=0, soma=0;

while (soma < 1000)

{

soma= soma + n;

if (soma < 1000)

n= n +1;

}


system ("pause");

return 0;

}

V

V

Memória


Saída

n soma

45ª iteração


#include <stdio.h>

#include <stdlib.h>

int main ()

{

int n=0, soma=0;

while (soma < 1000)

{

soma= soma + n;

if (soma < 1000)

n= n +1;

}


system ("pause");

return 0;

}

Memória


Saída

n soma

V

V

45ª iteração


#include <stdio.h>

#include <stdlib.h>

int main ()

{

int n=0, soma=0;

while (soma < 1000)

{

soma= soma + n;

if (soma < 1000)

n= n +1;

}


system ("pause");

return 0;

}

Memória


Saída

n soma

V


#include <stdio.h>

#include <stdlib.h>

int main ()

{

int n=0, soma=0;

while (soma < 1000)

{

soma= soma + n;

if (soma < 1000)

n= n +1;

}


system ("pause");

return 0;

}

Memória


Saída

n soma

V

46ª iteração


#include <stdio.h>

#include <stdlib.h>

int main ()

{

int n=0, soma=0;

while (soma < 1000)

{

soma= soma + n;

if (soma < 1000)

n= n +1;

}


system ("pause");

return 0;

}

V

F

Memória


Saída

n soma

46ª iteração


#include <stdio.h>

#include <stdlib.h>

int main ()

{

int n=0, soma=0;

while (soma < 1000)

{

soma= soma + n;

if (soma < 1000)

n= n +1;

}


system ("pause");

return 0;

}

Memória


Saída

n soma

F


#include <stdio.h>

#include <stdlib.h>

int main ()

{

int n=0, soma=0;

while (soma < 1000)

{

soma= soma + n;

if (soma < 1000)

n= n +1;

}


system ("pause");

return 0;

}

Memória


Saída

O resultado eh: 45

n soma


#include <stdio.h>

#include <stdlib.h>

int main ()

{

int n=0, soma=0;

while (soma < 1000)

{

soma= soma + n;

if (soma < 1000)

n= n +1;

}


system ("pause");

return 0;

}

Memória


Saída

O resultado eh: 45 Pressione qualquer tecla para continuar...

n soma







Mais exercícios:

y


#include <stdio.h>

#include <stdlib.h>

int main ()

{

int x;


scanf("%d", &x);

while (x != 0)

{

printf ("o quadrado de %d eh = %d", x, x*x);

printf ("\n\nforneca o valor de x= ");

scanf ("%d", &x);

}

system ("pause");

return 0;

}







Mais exercícios:

y


#include <stdio.h>

#include <stdlib.h>

int main ()

{

int x, contador=0, multiplo;


scanf("%d", &x);

printf ("os multiplos de 2 menores (<) que %d sao: \n", x);

while (multiplo < x)

{

multiplo= contador * 2;

if (multiplo < x)

printf (" %d ", multiplo);


}

system ("pause");

return 0;

} Atualizado em 22/08, 14h45min Com contribuição do Aluno Vinícius Morelatto de Souza

• Ler um ano e verificar se ele é bissexto. Para calcular o Ano Bissexto, existem quatro regras principais. Como a última regra "só" acontece a cada 3300 anos, consideramos na prática apenas as três primeiras. Um ano é bissexto se o mês de fevereiro tem 29 dias. O dia (convencionadamente, 29 de fevereiro) que é acrescentado à contagem do ano solar (365 dias), em intervalos regulares de quatro anos (exceto nos de número múltiplo de 100 que não seja também múltiplo de 400). É uma forma de corrigir a discrepância entre o calendário convencional e o tempo de translação da Terra em torno do Sol. [Fonte: Dicionário Houaiss da Língua Portuguesa.] Em outras palavras: A regra concreta é que um ano é bissexto se é múltiplo de 4 (ex: 2008). A primeira exceção é que se for múltiplo de 4 mas também de 100, deixa de ser bissexto (ex: 2100). E a segunda exceção é que se for múltiplo de 4, de 100 e também de 400, então é bissexto (ex: 2000). Por exemplo, 1914 não foi bissexto; 2114 também não será, pois não são múltiplos de 4; mas 2004 foi ano bissexto, pois é múltiplo de 4. [Fonte: Wikipédia.] Logo, um ano bissexto deve ser múltiplo de 4 (ou múltiplo de 100 e também múltiplo de 400). Exemplo: 2000 foi um ano bissexto, mas 2100 não será bissexto.

O significado matemático das quatro regras principais: 1) "acrescentamos" 1 dia a cada 4 anos (quando o ano é múltiplo de 4); 2) "deixamos de acrescentar" 1 dia a cada 100 anos (último ano de cada século, cujos dígitos terminam com dois zeros, ou seja, um ano secular); 3) "acrescentamos" 1 dia a cada 400 anos (quando o ano é múltiplo de 400); 4) "deixamos de acrescentar" 1 dia a cada 3300 anos. Isso decorre da definição do Ano Solar: 1 Ano Solar ~ 365,242199 ~ 365 + 1/4 - 1/100 + 1/400 - 1/3300. O valor exato de 365 + 1/4 - 1/100 + 1/400 - 1/3300 é 365,24219696969696... Essa soma de frações é praticamente igual ao valor do Ano Solar: 365,242199.



• Ler um ano e verificar se ele é bissexto . A explicação do Ano Bissexto e dos cálculos está indicada com detalhes nos links abaixo. Link 1: Costa, J. R .V. Os anos bissextos. Astronomia no Zênite, dez. 2002. Disponível em: http://www.zenite.nu?anobissexto Link 2: http://pt.wikipedia.org/wiki/Ano_bissexto Link 3: http://books.google.com.br/books?id=IPWZCh1awFIC&lpg=PA30&ots=xo0C-hQNri&dq=365%2C2422&hl=pt-BR&pg=PA30#v=onepage&q=365,2422&f=false Link 4: http://astro.if.ufrgs.br/tempo/tempo.htm





http://pt.wikipedia.org/wiki/Ano_bissexto
















http://astro.if.ufrgs.br/tempo/tempo.htm


#include <stdlib.h>

int main ()

{

int ano;

printf ("forneca o ano:");

scanf("%d", &ano);

if ((ano%4)==0) //verifica se ano é múltiplo de 4

{


{


{

printf (“Ano %d eh bissexto!! (multiplo de 4, de 100 e de 400)", ano);

}

else

{

printf (“Ano %d nao eh bissexto!(mult. de 4, de 100 mas nao de 400)", ano);

}

}

else

{

printf(“Ano %d eh bissexto!! (multiplo de 4)", ano);

}

}

else

printf (“Ano %d nao eh bissexto!!", ano);

system ("pause");

return 0;

}

Uma solução (sem {} opcionais):

#include <stdio.h>

#include <stdlib.h>

int main ()

{

int ano;


scanf("%d", &ano);




printf (“Ano %d eh bissexto!!(mult. de 4, 100 e 400)", ano);

else

printf (“Ano %d nao bissexto!(mult.de 4 e 100 mas nao de 400)“,ano);

else


else


system ("pause");

return 0;

}


#include <stdio.h>

#include <stdlib.h>

int main ()

{

int ano;


scanf("%d", &ano);





else


else


else


system ("pause");

return 0;

}

Saída Forneca o ano:


#include <stdio.h>

#include <stdlib.h>

int main ()

{

int ano;


scanf("%d", &ano);





else


else


else


system ("pause");

return 0;

}

Saída Forneca o ano: 2012

Observação: 2012 % 4 == 0 2012 %100 != 0 2012 % 400 != 0


#include <stdio.h>

#include <stdlib.h>

int main ()

{

int ano;


scanf("%d", &ano);





else


else


else


system ("pause");

return 0;

}


Observação: 2012 % 4 == 0 2012 %100 != 0 2012 % 400 != 0

V


#include <stdio.h>

#include <stdlib.h>

int main ()

{

int ano;


scanf("%d", &ano);





else


else


else


system ("pause");

return 0;

}


Observação: 2012 % 4 == 0 2012 %100 != 0 2012 % 400 != 0

F


#include <stdio.h>

#include <stdlib.h>

int main ()

{

int ano;


scanf("%d", &ano);





else


else


else


system ("pause");

return 0;

}

Saída Forneca o ano: 2012 Ano 2012 eh bissexto!! (multiplo de 4)

Observação: 2012 % 4 == 0 2012 %100 != 0 2012 % 400 != 0


#include <stdio.h>

#include <stdlib.h>

int main ()

{

int ano;


scanf("%d", &ano);





else


else


else


system ("pause");

return 0;

}

Saída Forneca o ano: 2012 Ano 2012 eh bissexto!! (multiplo de 4) Pressione qualquer tecla para continuar...

Observação: 2012 % 4 == 0 2012 %100 != 0 2012 % 400 != 0


#include <stdio.h>

#include <stdlib.h>

int main ()

{

int ano;


scanf("%d", &ano);





else


else


else


system ("pause");

return 0;

}


#include <stdio.h>

#include <stdlib.h>

int main ()

{

int ano;


scanf("%d", &ano);





else


else


else


system ("pause");

return 0;

}

Saída Forneca o ano:


#include <stdio.h>

#include <stdlib.h>

int main ()

{

int ano;


scanf("%d", &ano);





else


else


else


system ("pause");

return 0;

}

Observação: 2100 % 4 == 0 2100 %100 == 0 2100 % 400 != 0



#include <stdio.h>

#include <stdlib.h>

int main ()

{

int ano;


scanf("%d", &ano);





else


else


else


system ("pause");

return 0;

}

Observação: 2100 % 4 == 0 2100 %100 == 0 2100 % 400 != 0

V



#include <stdio.h>

#include <stdlib.h>

int main ()

{

int ano;


scanf("%d", &ano);





else


else


else


system ("pause");

return 0;

}

V

Observação: 2100 % 4 == 0 2100 %100 == 0 2100 % 400 != 0



#include <stdio.h>

#include <stdlib.h>

int main ()

{

int ano;


scanf("%d", &ano);





else


else


else


system ("pause");

return 0;

}

F

Observação: 2100 % 4 == 0 2100 %100 == 0 2100 % 400 != 0



#include <stdio.h>

#include <stdlib.h>

int main ()

{

int ano;


scanf("%d", &ano);





else


else


else


system ("pause");

return 0;

}

Saída Forneca o ano: 2100 Ano 2100 nao bissexto!(mult.de 4 e 100 mas nao de 400)

Observação: 2100 % 4 == 0 2100 %100 == 0 2100 % 400 != 0


#include <stdio.h>

#include <stdlib.h>

int main ()

{

int ano;


scanf("%d", &ano);





else


else


else


system ("pause");

return 0;

}

Saída Forneca o ano: 2100 Ano 2100 nao bissexto!(mult.de 4 e 100 mas nao de 400) Pressione qualquer tecla para continuar...

Observação: 2100 % 4 == 0 2100 %100 == 0 2100 % 400 != 0

• Dizemos que um número natural é triangular se ele é produto de três números naturais consecutivos.

• Exemplo: 120 é triangular, pois 4*5*6 =120.

• Dado um inteiro não-negativo n, verificar se n é triangular.

Mais exercícios:

A solução para esses e outros exercícios você encontra na lista de exercícios em http://www.ime.usp.br/~macmulti/exercicios/inteiros/index.html.

Uma solução

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

#include <stdlib.h>

int main() {

int cont=1, n;

printf("Digite o valor de n: ");

scanf("%d",&n);

while ( (cont*(cont+1)*(cont+2)) < n )

cont= cont + 1;

if ( (cont*(cont+1)*(cont+2)) == n )

printf ("%d * %d * %d = %d. ogo, %d eh triangular!\n",

cont, cont+1, cont+2, n, n);

else

printf ("%d nao eh triangular!", n);

system ("pause");

return 0;

}


#include <stdlib.h>

int main() {

int cont=1, n;


scanf("%d",&n);


cont= cont + 1;




else


system ("pause");

return 0;

}

45323449¨%90!@2312@!#31asd 1234@%dfd!4%@#%qwerq21123 er1234123412341234qwerqwerwqerqwerqwerqwqr1241241414144111124asd21$#@121121#12asd

memória


#include <stdlib.h>

int main() {

int cont=1, n;


scanf("%d",&n);


cont= cont + 1;




else


system ("pause");

return 0;

}

1 %90!@2312@!#31asd 1234@%dfd!4%@#%qwerq21123 er1234123412341234qwerqwerwqerqwerqwerqwqr1241241414144111124asd21$#@121121#12asd

cont n

memória


#include <stdlib.h>

int main() {

int cont=1, n;


scanf("%d",&n);


cont= cont + 1;




else


system ("pause");

return 0;

}

1 %90!@2312@!#31asd 1234@%dfd!4%@#%qwerq21123 er1234123412341234qwerqwerwqerqwerqwerqwqr1241241414144111124asd21$#@121121#12asd

cont n

memória

Saída Digite o valor de n:


#include <stdlib.h>

int main() {

int cont=1, n;


scanf("%d",&n);


cont= cont + 1;




else


system ("pause");

return 0;

}

1 120 12@!#31asd 1234@%dfd!4%@#%qwerq21123 er1234123412341234qwerqwerwqerqwerqwerqwqr1241241414144111124asd21$#@121121#12asd

cont n

memória

Saída Digite o valor de n: 120


#include <stdlib.h>

int main() {

int cont=1, n;


scanf("%d",&n);


cont= cont + 1;




else


system ("pause");

return 0;

}


cont n

memória


V


#include <stdlib.h>

int main() {

int cont=1, n;


scanf("%d",&n);


cont= cont + 1;




else


system ("pause");

return 0;

}


cont n

memória


F


#include <stdlib.h>

int main() {

int cont=1, n;


scanf("%d",&n);


cont= cont + 1;




else


system ("pause");

return 0;

}


cont n

memória


V


#include <stdlib.h>

int main() {

int cont=1, n;


scanf("%d",&n);


cont= cont + 1;




else


system ("pause");

return 0;

}


cont n

memória

V

Saída Digite o valor de n: 120 4 * 5 * 6 = 120. Logo, 120 eh triangular!


#include <stdlib.h>

int main() {

int cont=1, n;


scanf("%d",&n);


cont= cont + 1;




else


system ("pause");

return 0;

}


cont n

memória

V

Saída Digite o valor de n: 120 4 * 5 * 6 = 120. Logo, 120 eh triangular! Pressione qualquer tecla para continuar ...

Abreviaturas do comando

de atribuição...

• Incremento e Decremento num = num + 1;

num = num - 1;

• Outras possibilidades

Abreviaturas do Comando de Atribuição

ou num++;

ou num--;

Trecho de um programa

atribuição

múltipla

...

int i, soma, cont;

i = 0;

soma = 0;

count = 0;

...

Atribuição Múltipla

...

int i, soma, cont;

i = soma = cont = 0;

...

Ou

Atribuição na declaração

de variáveis

Atribuição na declaração

Ou

Definição de

constantes

Definição de constantes

Para definir uma constante, você deve fazer: #define <NOME_DA_CONSTANTE> <VALOR>

Exemplo: #define ZERO 0

#define UM 1

#define PI 3.1415926535

Definição de constantes #include <stdio.h>

#include <stdlib.h>

#define UM 1

#define ZERO 0

int main ()

{

int num = UM , soma , n ;

printf ("Entre com n > 0: " ) ;

scanf ("%d", &n ) ;

soma = ZERO ;

while ( num < n )

{

if ( n % num == ZERO )

soma += num ;

num++;

}

if ( soma == n )

printf ("numero perfeito\n" ) ;

else

printf ("nao eh perfeito\n" ) ;

system("pause");

return 0;

}

Operadores

Lógicos

Expressões Lógicas: recordando... • Expressões Aritméticas: São expressões matemáticas envolvendo números inteiros, variáveis inteiras, e os operadores: "+" (soma), "-" (subtração), "/" (quociente de divisão inteira), "%" (resto de uma divisão inteira) e "*” (multiplicação).

• Expressões Relacionais: São expressões que envolvem comparações simples envolvendo operadores relacionais: "<" (menor), ">" (maior), "<=" (menor ou igual), ">=" (maior ou igual), "!=" (diferente) e "==" (igual).

Uma comparação simples:

Uma comparação simples só pode ser feita entre pares de expressões aritméticas da forma: <expr_aritmética_01> <oper_relacional> <expr_aritmética_02>

Onde:

<expr_aritmética_01> e <expr_aritmética_02> são expressões aritméticas

<oper_relacional>

é um operador relacional.

Expressões Lógicas:

Utilizado para criar condições mais complexas. Exemplo: Verificar se o conteúdo de uma variável

x é positivo (ou seja, x>0) e ao mesmo tempo menor que 10 (ou seja, x<10).

0 < x < 10

if ( (x>0)&&(x<10) )

Em Linguagem C:


Operador Lógico && (E)

<expressão_1>

<expressão_2>

<expressão_1>

&&

<expressão2>

verdadeiro verdadeiro verdadeiro

verdadeiro falso falso

falso verdadeiro falso

falso falso falso


Operador Lógico && (E)

<expressão_1>

<expressão_2>

<expressão_1>

&&

<expressão_2>

x<=5 y<(3+2) verdadeiro

Considere: int x=3, y=4, z=5;

(2*x)<(2*y) z>(x+y) falso

(z*x)>(x*y+5) (y+z)>(x+y) falso

(z+x*y)>(z*x+y) (y+z-4)>(x+y*2) falso


Operador Lógico || (OU)

<expressão_1>

<expressão_2>

<expressão_1>

||

<expressão_2>

verdadeiro verdadeiro verdadeiro

verdadeiro falso verdadeiro

falso verdadeiro verdadeiro

falso falso falso


Operador Lógico || (OU)

<expressão_1>

<expressão_2>

<expressão_1>

||

<expressão_2>

x<=5 y<(3+2) verdadeiro

Considere: int x=3, y=4, z=5;

(2*x)<(2*y) z>(x+y) verdadeiro

(z*x)>(x*y+5) (y+z)>(x+y) verdadeiro

(z+x*y)>(z*x+y) (y+z-4)>(x+y*2) falso

Outros Exemplos

Expressão Lógica Resultado

x >= y

x <= y

x >= (y − 2)

(x > 0) && (x < y)

(y>0) && (x>0) && (x>y)

(x<0) || (y>x) || (x==5)

(x<0) || (y>x) && (y<0)

falso

verdadeiro

verdadeiro

verdadeiro

falso

verdadeiro

falso

Considere: int x=1, y=2;

Simplificando a Lógica Booleana

!(!x) == x

x || !x == true

(!x || !y) == !(x && y) - DeMorgan's Theorem

(!x && !y) == !(x || y) - DeMorgan's Theorem

x && x == x

x && !x == false

x || y == y || x - Commutative Law

x && y == y && x - Commutative Law

(x || y) || z == x || (y || x) - Associative Law

(x && y) && z == x && (y && z) - Associative Law

x && y || x && z == x && (y || z) - Distributive Law

(x || y) && (x || x) == x || (y && z) - Distributive Law

x || x && y == x

x && y || x && !y == x

(x && y) || (!x && z) || (y && z) == (x && y) || (!x && z)

(x || y) && (!x || z) && (y || z) == (x || y) && (!x || z)

x && (x || y) == x

(x || y) && (x || !y) == x

x, y e z são variáveis que podem ser True ou False (Verdadeiro ou Falso) "!” significa "Not" (Não) - "||" significa "Or" (Ou) - "&&" significa - "And" (E) - "==" significa "Igual"

Considere: x=y=z=true;

Correção de

Exercícios

1. Dada uma sequência de números inteiros não-nulos, seguida por 0, imprimir seus quadrados.

2. Dado um número inteiro positivo n, calcular a soma dos n primeiros números naturais.

3. Dado um número inteiro positivo n, imprimir os n primeiros naturais ímpares. Exemplo: Para n=4 a saída deverá ser 1,3,5,7.

4. Dados um inteiro x e um inteiro não-negativo n, calcular x n.

5. Uma loja de discos anota diariamente durante o mês de março a quantidade de discos vendidos. Determinar em que dia desse mês ocorreu a maior venda e qual foi a quantidade de discos vendida nesse dia.

6. Dados o número n de alunos de uma turma de Introdução aos Autômatos a Pilha (MAC 414) e suas notas da primeira prova, determinar a maior e a menor nota obtidas por essa turma (Nota máxima = 100 e nota mínima = 0).

7. Dados n e uma sequência de n números inteiros, determinar a soma dos números pares.

8. Dado um inteiro não-negativo n, determinar n!

(*) Fonte: http://www.ime.usp.br/~macmulti/exercicios/inteiros/index.html


9. Dados n e dois números inteiros positivos i e j diferentes de 0, imprimir em ordem crescente os n primeiros naturais que são múltiplos de i ou de j e ou de ambos.

Exemplo: Para n = 6 , i = 2 e j = 3 a saída deverá ser : 0,2,3,4,6,8.

11. Dado um inteiro positivo p, verificar se p é primo.

12. Dados dois números inteiros positivos, determinar o máximo divisor comum entre eles usando o algoritmo de Euclides.

Exemplo:

13. Dizemos que um inteiro positivo n é perfeito se for igual à soma de seus divisores positivos diferentes de n. Exemplo: 6 é perfeito, pois 1+2+3 = 6.

Dado um inteiro positivo n, verificar se n é perfeito.


Mais exercícios(*)

12. Dados dois números inteiros positivos, determinar o máximo divisor comum entre eles usando o algoritmo de Euclides.

Exemplo:

Obtendo o mdc entre dois números naturais X e Y onde X > Y.

• Leia o valor de X e de Y;

• Divida X por Y e obtenha o resto R1.

–Se R1 for zero, o mdc entre X e Y é Y.

–Senão, se R1 não for zero, divida Y por R1 e obtenha o resto R2.

»Se R2 for zero, o mdc entre X e Y é R1.

» Senão, se R2 não for zero, divida R1 por R2 e obtenha o resto R3.

• Se R3 for zero, o mdc entre X e Y é R2.

• Senão se ...

• Se Rn não for zero, divida Rn-1 por Rn e obtenha o resto Rn+1.

• Se Rn+1 for zero, o mdc entre X e Y é Rn.

Roteiro

#include <stdio.h>

#include <stdlib.h>

int main ()

{

int atual, anterior, resto;

printf ("Forneca dois numeros:");

scanf ("%d %d", &anterior, &atual);

printf("MDC(%d,%d)= ", anterior, atual);

resto= anterior%atual;

while (resto != 0)

{

anterior=atual;

atual=resto;

resto=anterior%atual;

}

printf("%d\n", atual);

system("pause");

return 0;

}

Uma Solução...

#include <stdio.h>

#include <stdlib.h>

int main ()

{

int atual, anterior, resto;





while (resto != 0)

{

anterior=atual;

atual=resto;


}


system("pause");

return 0;

}

Uma Solução... atual anterior

resto

#include <stdio.h>

#include <stdlib.h>

int main ()

{

int anterior, atual, resto;





while (resto != 0)

{

anterior=atual;

atual=resto;


}


system("pause");

return 0;

}

Uma Solução...

Forneca dois numeros:

resto

atual anterior

#include <stdio.h>

#include <stdlib.h>

int main ()

{






while (resto != 0)

{

anterior=atual;

atual=resto;


}


system("pause");

return 0;

}

Uma Solução...

Forneca dois numeros: 24 15

atual anterior

resto

24 15

#include <stdio.h>

#include <stdlib.h>

int main ()

{






while (resto != 0)

{

anterior=atual;

atual=resto;


}


system("pause");

return 0;

}

Uma Solução...

Forneca dois numeros: 24 15 MDC(24,15)=

atual anterior

resto

24 15

#include <stdio.h>

#include <stdlib.h>

int main ()

{






while (resto != 0)

{

anterior=atual;

atual=resto;


}


system("pause");

return 0;

}

Uma Solução...


atual anterior

resto

24 15

9

1

#include <stdio.h>

#include <stdlib.h>

int main ()

{






while (resto != 0)

{

anterior=atual;

atual=resto;


}


system("pause");

return 0;

}

Uma Solução...


atual anterior

resto

24 15

9

1

V

#include <stdio.h>

#include <stdlib.h>

int main ()

{






while (resto != 0)

{

anterior=atual;

atual=resto;


}


system("pause");

return 0;

}

Uma Solução...


atual anterior

resto

24 15

9

1

V

9

#include <stdio.h>

#include <stdlib.h>

int main ()

{






while (resto != 0)

{

anterior=atual;

atual=resto;


}


system("pause");

return 0;

}

Uma Solução...


atual anterior

resto

24 15

9

1

V

9

6

1

#include <stdio.h>

#include <stdlib.h>

int main ()

{






while (resto != 0)

{

anterior=atual;

atual=resto;


}


system("pause");

return 0;

}

Uma Solução...


atual anterior

resto

24 15

9

1

V

9

6

1

6

#include <stdio.h>

#include <stdlib.h>

int main ()

{






while (resto != 0)

{

anterior=atual;

atual=resto;


}


system("pause");

return 0;

}

Uma Solução...


atual anterior

resto

24 15

9

1

V

9

6

1

6

3

1

#include <stdio.h>

#include <stdlib.h>

int main ()

{






while (resto != 0)

{

anterior=atual;

atual=resto;


}


system("pause");

return 0;

}

Uma Solução...


atual anterior

resto

24 15

9

1

V

9

6

1

6

3

3

1

#include <stdio.h>

#include <stdlib.h>

int main ()

{






while (resto != 0)

{

anterior=atual;

atual=resto;


}


system("pause");

return 0;

}

Uma Solução...


atual anterior

resto

24 15

9

1

V

9

6

1

6

3

3

0

1 2

#include <stdio.h>

#include <stdlib.h>

int main ()

{






while (resto != 0)

{

anterior=atual;

atual=resto;


}


system("pause");

return 0;

}

Uma Solução...


atual anterior

resto

24 15

9

1

F

9

6

1

6

3

3

0

1 2

#include <stdio.h>

#include <stdlib.h>

int main ()

{






while (resto != 0)

{

anterior=atual;

atual=resto;


}


system("pause");

return 0;

}

Uma Solução...

Forneca dois numeros: 24 15 MDC(24,15)= 3

atual anterior

resto

24 15

9

1

9

6

1

6

3

3

0

1 2

#include <stdio.h>

#include <stdlib.h>

int main ()

{






while (resto != 0)

{

anterior=atual;

atual=resto;


}


system("pause");

return 0;

}

Uma Solução...

Forneca dois numeros: 24 15 MDC(24,15)= 3 Pressione qualquer tecla para continuar...

atual anterior

resto

24 15

9

1

9

6

1

6

3

3

0

1 2

#include <stdio.h>

#include <stdlib.h>

int main ()

{






while (resto != 0)

{

anterior=atual;

atual=resto;


}


system("pause");

return 0;

}

Uma Solução...


E se a entrada for 15 e 24. Irá funcionar ??

#include <stdio.h>

#include <stdlib.h>

int main ()

{






while (resto != 0)

{

anterior=atual;

atual=resto;


}


system("pause");

return 0;

}

Uma Solução...

Forneca dois numeros: 15 24 MDC(15,24)= 3 Pressione qualquer tecla para continuar...

SIM !!!

14. Um matemático italiano da idade média conseguiu modelar o ritmo de crescimento da população de coelhos (1) através de uma sequência de números naturais que passou a ser conhecida como sequência de Fibonacci (2). O n-ésimo número da sequência de Fibonacci Fn é dado pela seguinte fórmula de recorrência:

Faça um programa que, dado n, calcula Fn.

15. Dizemos que um número i é congruente módulo m a j se i % m = j % m. Exemplo: 35 é congruente módulo 4 a 39, pois 35 % 4 = 3 = 39 % 4.

Dados inteiros positivos n, j e m, imprimir os n primeiros naturais congruentes a j módulo m.

16. Dado um número natural na base binária, transformá-lo para a base decimal.

Exemplo: Dado 10010 a saída será 18, pois 1. 2 4 + 0. 2 3 + 0. 2 2 + 1. 2 1 + 0. 2 0 = 18.


Mais exercícios(*) (próxima aula):

http://www.ime.usp.br/~macmulti/exercicios/inteiros/index.html






320

Dicas de Programação http://www.ime.usp.br/~hitoshi/introducao/09-DicasDeProgramacao.pdf

Leia um número inteiro positivo n.

Em seguida, leia n números inteiros e calcule a sua a soma. Apresente o resultado.

Exercício


#include <stdlib.h>

int main ()

{

int n, numero, contador, soma=0;

printf ("Forneca a qtd de numeros a serem somados:");

scanf ("%d", &n);

contador=1;

while (contador<=n)

{

printf("Forneca %do numero= ", contador);

scanf("%d", &numero);

soma=soma+numero;

contador=contador+1;

}

printf("\nResultado=%d\n", soma);

system("pause");

return 0;

}

• Dado um número inteiro n>0, determinar a soma dos dígitos de n.

Por exemplo: se n for igual a 63453, a soma dos dígitos de n será 21.

• Neste exercício, a sequência numérica é composta pelos dígitos de n. Neste caso, o seu programa deve ler pelo teclado o número n e a partir dele pegar cada número da sequência (um dígito de n) e acumulá-lo em uma variável soma.

Outro exercício

Para a solução: #include <stdio.h>

#include <stdlib.h>

int main ()

{

int n, d, soma=0;

printf ("Forneca o numero:");

scanf ("%d", &n);

while (n > 0)

{

}

printf("\nResultado= %d\n", soma);

system("pause");

return 0;

}

d = n % 10; /* último dígito de n */

soma = soma + d;

n = n / 10; /* ‘remove’ o último dígito de n */


#include <stdlib.h>

int main ()

{

int n, d, soma=0;


scanf ("%d", &n);

while (n > 0)

{

}


system("pause");

return 0;

}

d = n % 10;

soma = soma + d;

n = n / 10;


#include <stdlib.h>

int main ()

{

int n, d, soma=0;


scanf ("%d", &n);

while (n > 0)

{

}


system("pause");

return 0;

}

d = n % 10;

soma = soma + d;

n = n / 10;

132wqe341234124qweras 132wqe341234124qweras 0 132wqe341234124qweras 132wqe341234124qweras

Memória

Memória

n d

soma


#include <stdlib.h>

int main ()

{

int n, d, soma=0;


scanf ("%d", &n);

while (n > 0)

{

}


system("pause");

return 0;

}

d = n % 10;

soma = soma + d;

n = n / 10;

132wqe341234124qweras 132wqe341234124qweras 0 132wqe341234124qweras 132wqe341234124qweras

Memória

Memória

Forneca o numero:

n d

soma


#include <stdlib.h>

int main ()

{

int n, d, soma=0;


scanf ("%d", &n);

while (n > 0)

{

}


system("pause");

return 0;

}

d = n % 10;

soma = soma + d;

n = n / 10;

63453 132wqe341234124qweras 0 132wqe341234124qweras 132wqe341234124qweras

Memória

Memória

Forneca o numero: 63453

n d

soma


#include <stdlib.h>

int main ()

{

int n, d, soma=0;


scanf ("%d", &n);

while (n > 0)

{

}


system("pause");

return 0;

}

d = n % 10;

soma = soma + d;

n = n / 10;

63453 3 0 132wqe341234124qweras 132wqe341234124qweras

Memória

Memória


n d

soma


#include <stdlib.h>

int main ()

{

int n, d, soma=0;


scanf ("%d", &n);

while (n > 0)

{

}


system("pause");

return 0;

}

d = n % 10;

soma = soma + d;

n = n / 10;


Memória

Memória


n d

soma


#include <stdlib.h>

int main ()

{

int n, d, soma=0;


scanf ("%d", &n);

while (n > 0)

{

}


system("pause");

return 0;

}

d = n % 10;

soma = soma + d;

n = n / 10;


Memória

Memória

Forneca o numero: 63453 Resultado= 21

n d

soma


#include <stdlib.h>

int main ()

{

int n, d, soma=0;


scanf ("%d", &n);

while (n > 0)

{

}


system("pause");

return 0;

}

d = n % 10;

soma = soma + d;

n = n / 10;


Memória

Memória

Forneca o numero: 63453 Resultado= 21 Pressione qualquer tecla para continuar...

n d

soma

• Dado um número inteiro n>0, determinar a soma dos dígitos pares de n e a soma dos dígitos ímpares de n. Por exemplo, dado 63453

soma dos dígitos pares= 10

soma dos dígitos ímpares= 11

Modificando o exercício anterior


#include <stdlib.h>

int main ()

{

int n, d, somapar=0, somaimpar=0;


scanf ("%d", &n);

while (n > 0)

{

d = n % 10; /* último dígito de n */

if ( d%2 == 0)

somapar = somapar + d ;

else

somaimpar= somaimpar +d;

n = n / 10; /* arranca o último dígito de n */

}

printf("\nSoma pares= %d\nSoma impares= %d\n", somapar, somaimpar);

system("pause");

return 0;

}

Números Reais

Tipo double, float

Variável do tipo Real

• Os tipos de dados inteiros servem muito bem para a maioria dos programas, contudo alguns programas orientados para aplicações matemáticas frequentemente fazem uso de números reais (ou em ponto flutuante).

• Para este tipo de dados, em C, podemos utilizar os tipos float e double.

Variável do tipo Real: double

• O tipo double

– Utiliza 8 bytes para guardar um número em ponto flutuante

– (53 bits para a mantissa e 11 bits para o expoente);

– Os valores double são números que podem, em valor absoluto, serem tão grandes com 1.7 × 10308 ou tão pequenos quanto 1.7 × 10-308.

– O tamanho da mantissa para este tipo de dado é 15 dígitos decimais.

Variável do tipo Real: float

• O tipo float

– Utiliza 4 bytes para guardar um número em ponto flutuante.

– (24 bits para a mantissa e 8 bits para o expoente).

– Os valores do tipo float são números que podem, em valor absoluto, serem tão grandes com 3.4 × 1038

ou tão pequenos quanto 3.4 × 10-38.

– O tamanho da mantissa para este tipo de dado é 6 dígitos decimais.


• Assim, o tipo float tem uma precisão de 6 a 7 casas decimais com o expoente variando entre 10−37 a 10+38

• O tipo double tem uma precisão de 15 casas decimais com expoente variando entre 10−308 a 10+308 ocupando um espaço maior para armazenar um valor na memória.

• Isto significa que um número como 123456.78901234 será armazenado apenas como 1.234567E6 em uma variável do tipo float ficando o restante além da precisão possível para a representação.


• Declaração de variável e Leitura de um número inteiro

...

int x;

printf(“Entre com um numero inteiro:”);

scanf (“%d”, &x);

...

• Declaração de variável e Leitura de um número real

...

float x;

printf(“Entre com um numero real:”);

scanf (“%f”, &x);

...


• Leitura e Impressão de um número inteiro

...

int x;

printf(“Entre com um numero inteiro:”);

scanf (“%d”, &x);

printf(“Numero lido= %d \n”, x);

...

• Leitura e Impressão de um número real

...

float x;

printf(“Entre com um numero real:”);

scanf (“%f”, &x);

printf(“Numero lido= %f \n”, x);

...

Variável do tipo Real Formatação Resultado %e imprime um valor real em notação científica %f imprime um valor real em notação decimal

#include <stdio.h>

#include <stdlib.h>

int main ()

{

float pi = 3.141592654;

printf ("formato e: pi=%e \n", pi);

printf ("formato f: pi=%f \n", pi);

system("pause");

return 0;

}


#include <stdio.h>

#include <stdlib.h>

int main ()

{

float x = 314.1595426;

printf ("x = |%-8.2f|\n", x);

printf ("x = |%8.2f|\n", x);

printf ("x = |%8.4f|\n", x);

printf ("x = |%8.3f|\n", x * 1000);

system("pause");

return 0;

}

Formatação % d % f

um sinal de menos: especifica ajustamento à esquerda (o normal é à direita)

um número inteiro: especifica o tamanho mínimo do campo.

um ponto seguido de um número: especifica o tamanho máximo de casas decimais a serem impressos após o ponto decimal.

Variável do tipo Real Escrita: float x = 3.141595426;

float y = 1.23e−23;

Na definição de números reais pode-se omitir: • sinais positivos, • parte de expoente • a parte inteira ou fracionária. #include <stdio.h>

#include <stdlib.h>

int main ()

{

float x = 3.1415954,

y=.141595,

z=3e6,

w=.8e-6,

u=100;

printf ("x = %f \n", x);

printf ("y = %f \n", y);

printf ("z = %f \n", z);

printf ("w = %f \n", w);

printf ("u = %f \n", u);

system("pause");

return 0;

}

Variável do tipo Real:

Expressões Aritméticas Observações quanto à divisão

...

int i=5 , j=2 ;

float y ;

i = 7/3; /*divisão inteira: resultado=2 (5 e 3 são inteiros) */

y = 7/3; /*divisão inteira: resultado=2.0 (y é real) */

y = 5.0/2; /*divisão tem como resultado 2.5 (o numerador é real) */

y = 5/2.0; /*divisão tem como resultado 2.5 (o denominador é real) */

y = i/2; /*divisão inteira: resultado=1.0 (i=2 e 2 são inteiros) */

y = i/2.0; /*divisão ponto flutuante: resultado 1.0(denominador real)*/

y = i/j; /*divisão inteira: resultado=1.0(i e j são inteiros) */

y = (1.0*i)/j; /*divisão em ponto flutuante (numerador real) */

y = 1.0*(i/j); /*divisão inteira (i e j são inteiros) */

i = y/2; /*parte inteira da divisão em i(divisão real,mas i é inteiro)*/

...

#include <stdio.h>

#include <stdlib.h>

int main () {

int i=4;

int j=5;

int k;

float f = 5.0;

float g;

k = 6*(j/i);

g = 6*(f/i);

printf ("1: k=%d g=%f\n", k, g);

g = 6 *(j/i);

k = 6 *(f/i);

printf ("2: k=%d g=%f\n" , k , g ) ;

system("pause");

return 0;

}


Expressões Aritméticas

#include <stdio.h>

#include <stdlib.h>

int main(){

int x=5, y=2;

float z;

z = 5/2;

printf ("z= %f\n", z);

system("pause");

return 0;

}

Type casting

(float)

Z= 2.000000 Z= 2.500000

#include <stdio.h>

#include <stdlib.h>

int main () {

int i=4;

int j=5;

int k ;

float f = 5.0;

float g ;

k = 6 *(j/i) ;

g = 6 *((int) f/i) ;

printf ("1: k=%d g=%f\n" , k , g ) ;

g = (float )6*j/i ;

k = 6 *(f/i) ;

printf ("2: k=%d g=%f\n" , k , g ) ;

system("pause");

return 0;

}


Expressões Aritméticas

Funções

Introdução

Função

• Você pode escrever funções que definam tarefas específicas que poderão ser usadas em muitos pontos de um programa.

• Elas também são chamadas funções definidas pelo programador.

• As instruções que definem a função são escritas apenas uma vez.

• As funções são chamadas (ou invocadas) por uma chamada de função, que especifica o nome da função e oferece informações (como argumentos) de que a função chamada precisa para realizar sua tarefa designada.

Criando uma Função

float pot=1, base;

int contador, expoente;

base= ;

expoente= ;

for(contador=1; contador<=expoente; contador++)

pot = pot * base;

/*no final pot contém base elevado a expoente */

potencia (float bas, int exp)

Escolher um nome para a função

Definir os argumentos que a função irá receber para realizar a tarefa designada

Delimitar o trecho de código que pertence à função

Retornar um valor para o programa

return pot;

Definir o tipo de valor a função irá retornar

float

{

}

bas

exp

Toda vez que quisermos utilizar o código acima, simplesmente usaríamos seu nome que é potencia

Estutura para utilização da função #include <stdio.h>

#include <stdlib.h>

/*declaração do protótipo das funções definidas pelo programador*/

float potencia (float b, int exp);

/* função principal */

int main()

{

...

pot= potencia(base, expoente);

...

}

/* função definida pelo programador */

float potencia (float b, int exp)

{

/*codigo da função definida pelo programador */

return valor;

}

#include <stdio.h>

#include <stdlib.h>

float potencia (float base, int exp);

int main()

{

float x,y, potx, poty, potxy, resultado;

int a,b;

printf("Forneca o valor de x:");

scanf("%f", &x);

printf("Forneca o valor de y:");

scanf("%f", &y);

printf("Forneca o valor de a:");

scanf("%d", &a);

printf("Forneca o valor de b:");

scanf("%d", &b);

potx=potencia(x,a);

poty=potencia(y,b);

potxy=potencia(x-y, a+b);

resultado= potx + poty + potxy;

printf("\nResultado= %f \n" , resultado);

system("pause");

return 0;

}

float potencia (float base, int exp) {

float pot=1;

int contador;

for(contador=1; contador<=exp; contador++)

pot = pot * base;

return pot;

}

#include <stdio.h>

#include <stdlib.h>


int main()

{


int a,b;


scanf("%f", &x);


scanf("%f", &y);


scanf("%d", &a);


scanf("%d", &b);

potx=potencia(x,a);

poty=potencia(y,b);




system("pause");

return 0;

}


float pot=1;

int contador;


pot = pot * base;

return pot;

}

O comando potencia(x,a)coloca o conteúdo das variáveis x e a (seus valores) nas variáveis base e exp respectivamente, como indicado pelas setas (vermelha e roxa).

Ao térmico da execução da função, o comando return pot; retorna o conteúdo da variável pot (seu valor) em um acumulador, que em seguida é atribuído a potx como indicado pela seta (verde).

#include <stdio.h>

#include <stdlib.h>


int main()

{


int a,b;


scanf("%f", &x);


scanf("%f", &y);


scanf("%d", &a);


scanf("%d", &b);

potx=potencia(x,a);

poty=potencia(y,b);




system("pause");

return 0;

}


float pot=1;

int contador;


pot = pot * base;

return pot;

}

#include <stdio.h>

#include <stdlib.h>


int main()

{


int a,b;


scanf("%f", &x);


scanf("%f", &y);


scanf("%d", &a);


scanf("%d", &b);

/* potx=potencia(x,a);

poty=potencia(y,b);

potxy=potencia(x-y, a+b); */

resultado= potencia(x,a)+ potencia(y,b) + potencia(x-y, a+b);

printf("\nO valor de x^a + y^b + (x-y)^(a+b)= %f \n" , resultado);

system("pause");

return 0;

}


float pot=1;

int contador;


pot = pot * base;

return pot;

}

Outra solução...

#include <stdio.h>

#include <stdlib.h>


int main()

{


int a,b;


scanf("%f", &x);


scanf("%f", &y);


scanf("%d", &a);


scanf("%d", &b);

/* potx=potencia(x,a);

poty=potencia(y,b);


resultado= potencia(x,a)+ potencia(y,b) + potencia(x-y, a+b); */

printf("\Resultado= %f \n" , potencia(x,a)+ potencia(y,b) + potencia(x-y, a+b));

system("pause");

return 0;

}


float pot=1;

int contador;


pot = pot * base;

return pot;

}

Mais uma solução...

#include <stdio.h>

#include <stdlib.h>


int main()

{


int a,b;


scanf("%f", &x);


scanf("%f", &y);


scanf("%d", &a);


scanf("%d", &b);

potx=potencia(x,a);

poty=potencia(y,b);




system("pause");

return 0;

}


float pot=1;

int contador;


pot = pot * base;

return pot;

}

Memória

Entre com o valor de n>0: 3 O numero harmonico h3 = 1.833333

51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241

Saída

51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241

#include <stdio.h>

#include <stdlib.h>


int main()

{


int a,b;


scanf("%f", &x);


scanf("%f", &y);


scanf("%d", &a);


scanf("%d", &b);

potx=potencia(x,a);

poty=potencia(y,b);




system("pause");

return 0;

}


float pot=1;

int contador;


pot = pot * base;

return pot;

}

x y

potx poty

potxy

resultado

Memória


Saída

51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241

#include <stdio.h>

#include <stdlib.h>


int main()

{


int a,b;


scanf("%f", &x);


scanf("%f", &y);


scanf("%d", &a);


scanf("%d", &b);

potx=potencia(x,a);

poty=potencia(y,b);




system("pause");

return 0;

}


float pot=1;

int contador;


pot = pot * base;

return pot;

}

x y

potx poty

potxy resultado

Memória


a

b

Saída

51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241

#include <stdio.h>

#include <stdlib.h>


int main()

{


int a,b;


scanf("%f", &x);


scanf("%f", &y);


scanf("%d", &a);


scanf("%d", &b);

potx=potencia(x,a);

poty=potencia(y,b);




system("pause");

return 0;

}


float pot=1;

int contador;


pot = pot * base;

return pot;

}

x y

potx poty

potxy resultado

Memória

Forneca o valor de x: O numero harmonico h3 = 1.833333

Saída

a

b

Saída

3.000000 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241

#include <stdio.h>

#include <stdlib.h>


int main()

{


int a,b;


scanf("%f", &x);


scanf("%f", &y);


scanf("%d", &a);


scanf("%d", &b);

potx=potencia(x,a);

poty=potencia(y,b);




system("pause");

return 0;

}


float pot=1;

int contador;


pot = pot * base;

return pot;

}

x y

potx poty

potxy resultado

Memória

Forneca o valor de x: 3 O numero harmonico h3 = 1.833333

a

b

Saída

3.000000 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241

#include <stdio.h>

#include <stdlib.h>


int main()

{


int a,b;


scanf("%f", &x);


scanf("%f", &y);


scanf("%d", &a);


scanf("%d", &b);

potx=potencia(x,a);

poty=potencia(y,b);




system("pause");

return 0;

}


float pot=1;

int contador;


pot = pot * base;

return pot;

}

x y

potx poty

potxy resultado

Memória

Forneca o valor de x: 3 Forneca o valor de y: = 1.833333

a

b

Saída

3.000000 2.000000 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241

#include <stdio.h>

#include <stdlib.h>


int main()

{


int a,b;


scanf("%f", &x);


scanf("%f", &y);


scanf("%d", &a);


scanf("%d", &b);

potx=potencia(x,a);

poty=potencia(y,b);




system("pause");

return 0;

}


float pot=1;

int contador;


pot = pot * base;

return pot;

}

x y

potx poty

potxy resultado

Memória

Forneca o valor de x: 3 Forneca o valor de y: 2= 1.833333

a

b

Saída

3.000000 2.000000 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241

#include <stdio.h>

#include <stdlib.h>


int main()

{


int a,b;


scanf("%f", &x);


scanf("%f", &y);


scanf("%d", &a);


scanf("%d", &b);

potx=potencia(x,a);

poty=potencia(y,b);




system("pause");

return 0;

}


float pot=1;

int contador;


pot = pot * base;

return pot;

}

x y

potx poty

potxy resultado

Memória

Forneca o valor de x: 3 Forneca o valor de y: 2= 1.833333 Forneca o valor de a:

a

b

Saída

3.000000 2.000000 51234!2341241 51234!2341241 51234!2341241 51234!2341241 2 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241

#include <stdio.h>

#include <stdlib.h>


int main()

{


int a,b;


scanf("%f", &x);


scanf("%f", &y);


scanf("%d", &a);


scanf("%d", &b);

potx=potencia(x,a);

poty=potencia(y,b);




system("pause");

return 0;

}


float pot=1;

int contador;


pot = pot * base;

return pot;

}

x y

potx poty

potxy resultado

Memória

Forneca o valor de x: 3 Forneca o valor de y: 2= 1.833333 Forneca o valor de a: 2

a

b

Saída

3.000000 2.000000 51234!2341241 51234!2341241 51234!2341241 51234!2341241 2 51234!2341241 51234!2341241 51234!2341241 51234!2341241 51234!2341241

#include <stdio.h>

#include <stdlib.h>


int main()

{


int a,b;


scanf("%f", &x);


scanf("%f", &y);


scanf("%d", &a);


scanf("%d", &b);

potx=potencia(x,a);

poty=potencia(y,b);




system("pause");

return 0;

}


float pot=1;

int contador;


pot = pot * base;

return pot;

}

x y

potx poty

potxy resultado

Memória

Forneca o valor de x: 3 Forneca o valor de y: 2= 1.833333 Forneca o valor de a: 2 Forneca o valor de b:

a

b

Saída

3.000000 2.000000 51234!2341241 51234!2341241 51234!2341241 51234!2341241 2 2 51234!2341241 51234!2341241 51234!2341241 51234!2341241

#include <stdio.h>

#include <stdlib.h>


int main()

{


int a,b;


scanf("%f", &x);


scanf("%f", &y);


scanf("%d", &a);


scanf("%d", &b);

potx=potencia(x,a);

poty=potencia(y,b);




system("pause");

return 0;

}


float pot=1;

int contador;


pot = pot * base;

return pot;

}

x y

potx poty

potxy resultado

Memória

Forneca o valor de x: 3 Forneca o valor de y: 2= 1.833333 Forneca o valor de a: 2 Forneca o valor de b: 2

a

b

Saída

3.000000 2.000000 51234!2341241 51234!2341241 51234!2341241 51234!2341241 2 2 3.000000 2 51234!2341241 51234!2341241

#include <stdio.h>

#include <stdlib.h>


int main()

{


int a,b;


scanf("%f", &x);


scanf("%f", &y);


scanf("%d", &a);


scanf("%d", &b);

potx=potencia(x,a);

poty=potencia(y,b);




system("pause");

return 0;

}


float pot=1;

int contador;


pot = pot * base;

return pot;

}

x y

potx poty

potxy resultado

Memória


a

b base

exp

Saída

3.000000 2.000000 51234!2341241 51234!2341241 51234!2341241 51234!2341241 2 2 3.000000 2 1.000000 51234!2341241

#include <stdio.h>

#include <stdlib.h>


int main()

{


int a,b;


scanf("%f", &x);


scanf("%f", &y);


scanf("%d", &a);


scanf("%d", &b);

potx=potencia(x,a);

poty=potencia(y,b);




system("pause");

return 0;

}


float pot=1;

int contador;


pot = pot * base;

return pot;

}

x y

potx poty

potxy resultado

Memória


Saída

a

b base

exp pot

3.000000 2.000000 51234!2341241 51234!2341241 51234!2341241 51234!2341241 2 2 3.000000 2 1.000000 51234!2341241

#include <stdio.h>

#include <stdlib.h>


int main()

{


int a,b;


scanf("%f", &x);


scanf("%f", &y);


scanf("%d", &a);


scanf("%d", &b);

potx=potencia(x,a);

poty=potencia(y,b);




system("pause");

return 0;

}


float pot=1;

int contador;


pot = pot * base;

return pot;

}

x y

potx poty

potxy resultado

Memória


Saída

a

b base

exp pot

contador

3.000000 2.000000 51234!2341241 51234!2341241 51234!2341241 51234!2341241 2 2 3.000000 2 1.000000 1

#include <stdio.h>

#include <stdlib.h>


int main()

{


int a,b;


scanf("%f", &x);


scanf("%f", &y);


scanf("%d", &a);


scanf("%d", &b);

potx=potencia(x,a);

poty=potencia(y,b);




system("pause");

return 0;

}


float pot=1;

int contador;


pot = pot * base;

return pot;

}

x y

potx poty

potxy resultado

Memória


Saída

a

b base

exp pot

contador

3.000000 2.000000 51234!2341241 51234!2341241 51234!2341241 51234!2341241 2 2 3.000000 2 3.000000 1

#include <stdio.h>

#include <stdlib.h>

float potencia (float b, int exp);

int main()

{


int a,b;


scanf("%f", &x);


scanf("%f", &y);


scanf("%d", &a);


scanf("%d", &b);

potx=potencia(x,a);

poty=potencia(y,b);




system("pause");

return 0;

}


float pot=1;

int contador;


pot = pot * base;

return pot;

}

x y

potx poty

potxy resultado

Memória


Saída

a

b base

exp pot

contador

3.000000 2.000000 51234!2341241 51234!2341241 51234!2341241 51234!2341241 2 2 3.000000 2 3.000000 2

#include <stdio.h>

#include <stdlib.h>


int main()

{


int a,b;


scanf("%f", &x);


scanf("%f", &y);


scanf("%d", &a);


scanf("%d", &b);

potx=potencia(x,a);

poty=potencia(y,b);




system("pause");

return 0;

}


float pot=1;

int contador;


pot = pot * base;

return pot;

}

x y

potx poty

potxy resultado

Memória


Saída

a

b base

exp pot

contador

3.000000 2.000000 51234!2341241 51234!2341241 51234!2341241 51234!2341241 2 2 3.000000 2 9.000000 2

#include <stdio.h>

#include <stdlib.h>


int main()

{


int a,b;


scanf("%f", &x);


scanf("%f", &y);


scanf("%d", &a);


scanf("%d", &b);

potx=potencia(x,a);

poty=potencia(y,b);




system("pause");

return 0;

}


float pot=1;

int contador;


pot = pot * base;

return pot;

}

x y

potx poty

potxy resultado

Memória


Saída

a

b base

exp pot

contador

3.000000 2.000000 51234!2341241 51234!2341241 51234!2341241 51234!2341241 2 2 3.000000 2 9.000000 3

#include <stdio.h>

#include <stdlib.h>


int main()

{


int a,b;


scanf("%f", &x);


scanf("%f", &y);


scanf("%d", &a);


scanf("%d", &b);

potx=potencia(x,a);

poty=potencia(y,b);




system("pause");

return 0;

}


float pot=1;

int contador;


pot = pot * base;

return pot;

}

x y

potx poty

potxy resultado

Memória


Saída

a

b base

exp pot

contador

3.000000 2.000000 9.000000 51234!2341241 51234!2341241 51234!2341241 2 2 3.000000 2 9.000000 3

#include <stdio.h>

#include <stdlib.h>


int main()

{


int a,b;


scanf("%f", &x);


scanf("%f", &y);


scanf("%d", &a);


scanf("%d", &b);

potx=potencia(x,a);

poty=potencia(y,b);




system("pause");

return 0;

}


float pot=1;

int contador;


pot = pot * base;

return pot;

}

x y

potx poty

potxy resultado

Memória


Saída

a

b

3.000000 2.000000 9.000000 51234!2341241 51234!2341241 51234!2341241 2 2 2.000000 2 9.000000 3

#include <stdio.h>

#include <stdlib.h>


int main()

{


int a,b;


scanf("%f", &x);


scanf("%f", &y);


scanf("%d", &a);


scanf("%d", &b);

potx=potencia(x,a);

poty=potencia(y,b);




system("pause");

return 0;

}


float pot=1;

int contador;


pot = pot * base;

return pot;

}

x y

potx poty

potxy resultado

Memória


Saída

a

b base

exp

3.000000 2.000000 9.000000 51234!2341241 51234!2341241 51234!2341241 2 2 2.000000 2 1.000000 3

#include <stdio.h>

#include <stdlib.h>


int main()

{


int a,b;


scanf("%f", &x);


scanf("%f", &y);


scanf("%d", &a);


scanf("%d", &b);

potx=potencia(x,a);

poty=potencia(y,b);




system("pause");

return 0;

}


float pot=1;

int contador;


pot = pot * base;

return pot;

}

x y

potx poty

potxy resultado

Memória


Saída

a

b base

exp pot

3.000000 2.000000 9.000000 51234!2341241 51234!2341241 51234!2341241 2 2 2.000000 2 1.000000 3

#include <stdio.h>

#include <stdlib.h>


int main()

{


int a,b;


scanf("%f", &x);


scanf("%f", &y);


scanf("%d", &a);


scanf("%d", &b);

potx=potencia(x,a);

poty=potencia(y,b);




system("pause");

return 0;

}


float pot=1;

int contador;


pot = pot * base;

return pot;

}

x y

potx poty

potxy resultado

Memória


Saída

a

b base

exp pot

contador

3.000000 2.000000 9.000000 51234!2341241 51234!2341241 51234!2341241 2 2 2.000000 2 1.000000 1

#include <stdio.h>

#include <stdlib.h>


int main()

{


int a,b;


scanf("%f", &x);


scanf("%f", &y);


scanf("%d", &a);


scanf("%d", &b);

potx=potencia(x,a);

poty=potencia(y,b);




system("pause");

return 0;

}


float pot=1;

int contador;


pot = pot * base;

return pot;

}

x y

potx poty

potxy resultado

Memória


Saída

a

b base

exp pot

contador

3.000000 2.000000 9.000000 51234!2341241 51234!2341241 51234!2341241 2 2 2.000000 2 2.000000 1

#include <stdio.h>

#include <stdlib.h>


int main()

{


int a,b;


scanf("%f", &x);


scanf("%f", &y);


scanf("%d", &a);


scanf("%d", &b);

potx=potencia(x,a);

poty=potencia(y,b);




system("pause");

return 0;

}


float pot=1;

int contador;


pot = pot * base;

return pot;

}

x y

potx poty

potxy resultado

Memória


Saída

a

b base

exp pot

contador

3.000000 2.000000 9.000000 51234!2341241 51234!2341241 51234!2341241 2 2 2.000000 2 2.000000 2

#include <stdio.h>

#include <stdlib.h>


int main()

{


int a,b;


scanf("%f", &x);


scanf("%f", &y);


scanf("%d", &a);


scanf("%d", &b);

potx=potencia(x,a);

poty=potencia(y,b);




system("pause");

return 0;

}


float pot=1;

int contador;


pot = pot * base;

return pot;

}

x y

potx poty

potxy resultado

Memória


Saída

a

b base

exp pot

contador

3.000000 2.000000 9.000000 51234!2341241 51234!2341241 51234!2341241 2 2 2.000000 2 4.000000 2

#include <stdio.h>

#include <stdlib.h>


int main()

{


int a,b;


scanf("%f", &x);


scanf("%f", &y);


scanf("%d", &a);


scanf("%d", &b);

potx=potencia(x,a);

poty=potencia(y,b);




system("pause");

return 0;

}


float pot=1;

int contador;


pot = pot * base;

return pot;

}

x y

potx poty

potxy resultado

Memória


Saída

a

b base

exp pot

contador

3.000000 2.000000 9.000000 51234!2341241 51234!2341241 51234!2341241 2 2 2.000000 2 4.000000 3

#include <stdio.h>

#include <stdlib.h>


int main()

{


int a,b;


scanf("%f", &x);


scanf("%f", &y);


scanf("%d", &a);


scanf("%d", &b);

potx=potencia(x,a);

poty=potencia(y,b);




system("pause");

return 0;

}


float pot=1;

int contador;


pot = pot * base;

return pot;

}

x y

potx poty

potxy resultado

Memória


Saída

a

b base

exp pot

contador

3.000000 2.000000 9.000000 4.000000 51234!2341241 51234!2341241 2 2 2.000000 2 4.000000 3

#include <stdio.h>

#include <stdlib.h>


int main()

{


int a,b;


scanf("%f", &x);


scanf("%f", &y);


scanf("%d", &a);


scanf("%d", &b);

potx=potencia(x,a);

poty=potencia(y,b);




system("pause");

return 0;

}


float pot=1;

int contador;


pot = pot * base;

return pot;

}

x y

potx poty

potxy resultado

Memória


Saída

a

b

3.000000 2.000000 9.000000 4.000000 51234!2341241 51234!2341241 2 2 1.000000 4 4.000000 3

#include <stdio.h>

#include <stdlib.h>


int main()

{


int a,b;


scanf("%f", &x);


scanf("%f", &y);


scanf("%d", &a);


scanf("%d", &b);

potx=potencia(x,a);

poty=potencia(y,b);




system("pause");

return 0;

}


float pot=1;

int contador;


pot = pot * base;

return pot;

}

x y

potx poty

potxy resultado

Memória


Saída

a

b base

exp

3.000000 2.000000 9.000000 4.000000 51234!2341241 51234!2341241 2 2 1.000000 4 1.000000 3

#include <stdio.h>

#include <stdlib.h>


int main()

{


int a,b;


scanf("%f", &x);


scanf("%f", &y);


scanf("%d", &a);


scanf("%d", &b);

potx=potencia(x,a);

poty=potencia(y,b);




system("pause");

return 0;

}


float pot=1;

int contador;


pot = pot * base;

return pot;

}

x y

potx poty

potxy resultado

Memória


Saída

a

b base

exp pot

3.000000 2.000000 9.000000 4.000000 51234!2341241 51234!2341241 2 2 1.000000 4 1.000000 3

#include <stdio.h>

#include <stdlib.h>


int main()

{


int a,b;


scanf("%f", &x);


scanf("%f", &y);


scanf("%d", &a);


scanf("%d", &b);

potx=potencia(x,a);

poty=potencia(y,b);




system("pause");

return 0;

}


float pot=1;

int contador;


pot = pot * base;

return pot;

}

x y

potx poty

potxy resultado

Memória


Saída

a

b base

exp pot

contador

3.000000 2.000000 9.000000 4.000000 51234!2341241 51234!2341241 2 2 1.000000 4 1.000000 1

#include <stdio.h>

#include <stdlib.h>


int main()

{


int a,b;


scanf("%f", &x);


scanf("%f", &y);


scanf("%d", &a);


scanf("%d", &b);

potx=potencia(x,a);

poty=potencia(y,b);




system("pause");

return 0;

}


float pot=1;

int contador;


pot = pot * base;

return pot;

}

x y

potx poty

potxy resultado

Memória


Saída

a

b base

exp pot

contador

3.000000 2.000000 9.000000 4.000000 51234!2341241 51234!2341241 2 2 1.000000 4 1.000000 2

#include <stdio.h>

#include <stdlib.h>


int main()

{


int a,b;


scanf("%f", &x);


scanf("%f", &y);


scanf("%d", &a);


scanf("%d", &b);

potx=potencia(x,a);

poty=potencia(y,b);




system("pause");

return 0;

}


float pot=1;

int contador;


pot = pot * base;

return pot;

}

x y

potx poty

potxy resultado

Memória


Saída

a

b base

exp pot

contador

3.000000 2.000000 9.000000 4.000000 51234!2341241 51234!2341241 2 2 1.000000 4 1.000000 3

#include <stdio.h>

#include <stdlib.h>


int main()

{


int a,b;


scanf("%f", &x);


scanf("%f", &y);


scanf("%d", &a);


scanf("%d", &b);

potx=potencia(x,a);

poty=potencia(y,b);




system("pause");

return 0;

}


float pot=1;

int contador;


pot = pot * base;

return pot;

}

x y

potx poty

potxy resultado

Memória


Saída

a

b base

exp pot

contador

3.000000 2.000000 9.000000 4.000000 51234!2341241 51234!2341241 2 2 1.000000 4 1.000000 4

#include <stdio.h>

#include <stdlib.h>


int main()

{


int a,b;


scanf("%f", &x);


scanf("%f", &y);


scanf("%d", &a);


scanf("%d", &b);

potx=potencia(x,a);

poty=potencia(y,b);




system("pause");

return 0;

}


float pot=1;

int contador;


pot = pot * base;

return pot;

}

x y

potx poty

potxy resultado

Memória


Saída

a

b base

exp pot

contador

3.000000 2.000000 9.000000 4.000000 51234!2341241 51234!2341241 2 2 1.000000 4 1.000000 5

#include <stdio.h>

#include <stdlib.h>


int main()

{


int a,b;


scanf("%f", &x);


scanf("%f", &y);


scanf("%d", &a);


scanf("%d", &b);

potx=potencia(x,a);

poty=potencia(y,b);




system("pause");

return 0;

}


float pot=1;

int contador;


pot = pot * base;

return pot;

}

x y

potx poty

potxy resultado

Memória


Saída

a

b base

exp pot

contador

3.000000 2.000000 9.000000 4.000000 1.000000 51234!2341241 2 2 1.000000 4 1.000000 5

#include <stdio.h>

#include <stdlib.h>


int main()

{


int a,b;


scanf("%f", &x);


scanf("%f", &y);


scanf("%d", &a);


scanf("%d", &b);

potx=potencia(x,a);

poty=potencia(y,b);




system("pause");

return 0;

}


float pot=1;

int contador;


pot = pot * base;

return pot;

}

x y

potx poty

potxy resultado

Memória


Saída

a

b

3.000000 2.000000 9.000000 4.000000 1.000000 14.000000 2 2 1.000000 4 1.000000 5

#include <stdio.h>

#include <stdlib.h>


int main()

{


int a,b;


scanf("%f", &x);


scanf("%f", &y);


scanf("%d", &a);


scanf("%d", &b);

potx=potencia(x,a);

poty=potencia(y,b);




system("pause");

return 0;

}


float pot=1;

int contador;


pot = pot * base;

return pot;

}

x y

potx poty

potxy resultado

Memória


Saída

a

b

3.000000 2.000000 9.000000 4.000000 1.000000 14.000000 2 2 1.000000 4 1.000000 5

#include <stdio.h>

#include <stdlib.h>


int main()

{


int a,b;


scanf("%f", &x);


scanf("%f", &y);


scanf("%d", &a);


scanf("%d", &b);

potx=potencia(x,a);

poty=potencia(y,b);




system("pause");

return 0;

}


float pot=1;

int contador;


pot = pot * base;

return pot;

}

x y

potx poty

potxy resultado

Memória

Forneca o valor de x: 3 Forneca o valor de y: 2= 1.833333 Forneca o valor de a: 2 Forneca o valor de b: 2 Resultado= 14.000000

Saída

a

b

3.000000 2.000000 9.000000 4.000000 1.000000 14.000000 2 2 1.000000 4 1.000000 5

#include <stdio.h>

#include <stdlib.h>


int main()

{


int a,b;


scanf("%f", &x);


scanf("%f", &y);


scanf("%d", &a);


scanf("%d", &b);

potx=potencia(x,a);

poty=potencia(y,b);




system("pause");

return 0;

}


float pot=1;

int contador;


pot = pot * base;

return pot;

}

x y

potx poty

potxy resultado

Memória

Forneca o valor de x: 3 Forneca o valor de y: 2= 1.833333 Forneca o valor de a: 2 Forneca o valor de b: 2 Resultado= 14.000000 Pressione qualquer tecla para continuar..

Saída

a

b

Exercício 3:

Desenvolva um programa em linguagem C que leia

dois inteiros x e y e utilize a função abaixo

para o cálculo de x+y

int soma (int a, int b);


#include <stdlib.h>

int soma(int a, int b);

int main()

{

int x, y, z;


scanf("%d", &x);


scanf("%d", &y);

z= soma(x, y);

printf (“O valor de z= %d:“, z);

system("pause");

return 0;

}

int soma (int a, int b)

{

int w;

w= a+b;

return w;

}

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

#include <stdlib.h>

int soma(int a, int b);

int main()

{

int x, y, z;


scanf("%d", &x);


scanf("%d", &y);

z= soma(x, y);

printf (“O valor de z= %d:“, z);

system("pause");

return 0;

}

int soma (int a, int b)

{

return a+b;

}

Vetores

Declaração de Vetores

• A declaração de um vetor é feita da seguinte forma:

<tipo_do_vetor> <nome_do_vetor> [<tamanho_do_vetor>];

Exemplo:

int v[10];

float x[12];

0 1 2 3 4 5 6 7 8 9

v

0 1 2 3 4 5 6 7 8 9 10 11

x

Declaração de Vetores

Observação Importante:

1. Na declaração de vetor, o que está entre colchetes deve ser um número constante.

2. Assim, não é possível fazer algo deste tipo: ...

int n = 20;

float x[n]; /*nao é permitido declarar

/*colocando um tamanho variável */

ou

int n ;

printf ("Entre com n>0: ");

scanf ("%d", &n);

float x [n];

Exemplo de Uso de Vetores

#include <stdio.h>

#include <stdlib.h>

int main () {

int v [80], i;

v[3] = 4; /*casa de índice 3 do vetor v recebe o inteiro 4*/

i = 2;

v[i] = 3; /*casa de índice 2 do vetor v recebe o inteiro 3*/

v[v[v[i]]] = 10;

/*vc saberia dizer qual casa do vetor v recebe o inteiro 10?*/

return 0;

}

?

0

?

1

?

2

?

3

?

4

?

5

?

6

?

7

?

8

?

9

v ?

78

?

79

... 4 3 10

Outro exemplo do uso de

Vetores


#include <stdio.h>

#include <stdlib.h>

int main () {

float x [80];

int i;

for (i=0; i<80; i++)

x[i] = 0;

return 0;

}

?

0

?

1

?

2

?

3

?

4

?

5

?

6

?

7

?

8

?

9

x ?

78

?

79

...


#include <stdio.h>

#include <stdlib.h>

int main () {

float x [80];

int i;

for (i=0; i<80; i++)

x[i] = 0;

return 0;

}


#include <stdio.h>

#include <stdlib.h>

int main () {

float x [80];

int i;

for (i=0; i<80; i++)

x[i] = 0;

return 0;

}

?

0

?

1

?

2

?

3

?

4

?

5

?

6

?

7

?

8

?

9

x ?

78

?

79

...


#include <stdio.h>

#include <stdlib.h>

int main () {

float x [80];

int i;

for (i=0; i<80; i++)

x[i] = 0;

return 0;

}

?

0

?

1

?

2

?

3

?

4

?

5

?

6

?

7

?

8

?

9

x ?

78

?

79

... ?

0

?

1

?

2

?

3

?

4

?

5

?

6

?

7

?

8

?

9

x ?

78

?

79

...

? i


#include <stdio.h>

#include <stdlib.h>

int main () {

float x [80];

int i;

for (i=0; i<80; i++)

x[i] = 0;

return 0;

}

?

0

?

1

?

2

?

3

?

4

?

5

?

6

?

7

?

8

?

9

x ?

78

?

79

... ?

0

?

1

?

2

?

3

?

4

?

5

?

6

?

7

?

8

?

9

x ?

78

?

79

...

0 i


#include <stdio.h>

#include <stdlib.h>

int main () {

float x [80];

int i;

for (i=0; i<80; i++)

x[i] = 0;

return 0;

}

?

0

?

1

?

2

?

3

?

4

?

5

?

6

?

7

?

8

?

9

x ?

78

?

79

... 0.0

0

?

1

?

2

?

3

?

4

?

5

?

6

?

7

?

8

?

9

x ?

78

?

79

...

0 i


#include <stdio.h>

#include <stdlib.h>

int main () {

float x [80];

int i;

for (i=0; i<80; i++)

x[i] = 0;

return 0;

}

?

0

?

1

?

2

?

3

?

4

?

5

?

6

?

7

?

8

?

9

x ?

78

?

79

... 0.0

0

?

1

?

2

?

3

?

4

?

5

?

6

?

7

?

8

?

9

x ?

78

?

79

...

1 i


#include <stdio.h>

#include <stdlib.h>

int main () {

float x [80];

int i;

for (i=0; i<80; i++)

x[i] = 0;

return 0;

}

?

0

?

1

?

2

?

3

?

4

?

5

?

6

?

7

?

8

?

9

x ?

78

?

79

... 0.0

0

0.0

1

?

2

?

3

?

4

?

5

?

6

?

7

?

8

?

9

x ?

78

?

79

...

1 i


#include <stdio.h>

#include <stdlib.h>

int main () {

float x [80];

int i;

for (i=0; i<80; i++)

x[i] = 0;

return 0;

}

?

0

?

1

?

2

?

3

?

4

?

5

?

6

?

7

?

8

?

9

x ?

78

?

79

... 0.0

0

0.0

1

?

2

?

3

?

4

?

5

?

6

?

7

?

8

?

9

x ?

78

?

79

...

2 i


#include <stdio.h>

#include <stdlib.h>

int main () {

float x [80];

int i;

for (i=0; i<80; i++)

x[i] = 0;

return 0;

}

?

0

?

1

?

2

?

3

?

4

?

5

?

6

?

7

?

8

?

9

x ?

78

?

79

... 0.0

0

0.0

1

0.0

2

?

3

?

4

?

5

?

6

?

7

?

8

?

9

x ?

78

?

79

...

2 i


#include <stdio.h>

#include <stdlib.h>

int main () {

float x [80];

int i;

for (i=0; i<80; i++)

x[i] = 0;

return 0;

}

?

0

?

1

?

2

?

3

?

4

?

5

?

6

?

7

?

8

?

9

x ?

78

?

79

... 0.0

0

0.0

1

0.0

2

?

3

?

4

?

5

?

6

?

7

?

8

?

9

x ?

78

?

79

...

3 i


#include <stdio.h>

#include <stdlib.h>

int main () {

float x [80];

int i;

for (i=0; i<80; i++)

x[i] = 0;

return 0;

}

?

0

?

1

?

2

?

3

?

4

?

5

?

6

?

7

?

8

?

9

x ?

78

?

79

... 0.0

0

0.0

1

0.0

2

0.0

3

?

4

?

5

?

6

?

7

?

8

?

9

x ?

78

?

79

...

3 i


#include <stdio.h>

#include <stdlib.h>

int main () {

float x [80];

int i;

for (i=0; i<80; i++)

x[i] = 0;

return 0;

}

?

0

?

1

?

2

?

3

?

4

?

5

?

6

?

7

?

8

?

9

x ?

78

?

79

... 0.0

0

0.0

1

0.0

2

0.0

3

?

4

?

5

?

6

?

7

?

8

?

9

x ?

78

?

79

...

4 i


#include <stdio.h>

#include <stdlib.h>

int main () {

float x [80];

int i;

for (i=0; i<80; i++)

x[i] = 0;

return 0;

}

?

0

?

1

?

2

?

3

?

4

?

5

?

6

?

7

?

8

?

9

x ?

78

?

79

... 0.0

0

0.0

1

0.0

2

0.0

3

0.0

4

?

5

?

6

?

7

?

8

?

9

x ?

78

?

79

...

4 i


#include <stdio.h>

#include <stdlib.h>

int main () {

float x [80];

int i;

for (i=0; i<80; i++)

x[i] = 0;

return 0;

}

?

0

?

1

?

2

?

3

?

4

?

5

?

6

?

7

?

8

?

9

x ?

78

?

79

... 0.0

0

0.0

1

0.0

2

0.0

3

0.0

4

?

5

?

6

?

7

?

8

?

9

x ?

78

?

79

...

5 i


#include <stdio.h>

#include <stdlib.h>

int main () {

float x [80];

int i;

for (i=0; i<80; i++)

x[i] = 0;

return 0;

}

?

0

?

1

?

2

?

3

?

4

?

5

?

6

?

7

?

8

?

9

x ?

78

?

79

... 0.0

0

0.0

1

0.0

2

0.0

3

0.0

4

0.0

5

?

6

?

7

?

8

?

9

x ?

78

?

79

...

5 i


#include <stdio.h>

#include <stdlib.h>

int main () {

float x [80];

int i;

for (i=0; i<80; i++)

x[i] = 0;

return 0;

}

?

0

?

1

?

2

?

3

?

4

?

5

?

6

?

7

?

8

?

9

x ?

78

?

79

... 0.0

0

0.0

1

0.0

2

0.0

3

0.0

4

0.0

5

?

6

?

7

?

8

?

9

x ?

78

?

79

...

6 i


#include <stdio.h>

#include <stdlib.h>

int main () {

float x [80];

int i;

for (i=0; i<80; i++)

x[i] = 0;

return 0;

}

?

0

?

1

?

2

?

3

?

4

?

5

?

6

?

7

?

8

?

9

x ?

78

?

79

... 0.0

0

0.0

1

0.0

2

0.0

3

0.0

4

0.0

5

0.0

6

?

7

?

8

?

9

x ?

78

?

79

...

6 i


#include <stdio.h>

#include <stdlib.h>

int main () {

float x [80];

int i;

for (i=0; i<80; i++)

x[i] = 0;

return 0;

}

?

0

?

1

?

2

?

3

?

4

?

5

?

6

?

7

?

8

?

9

x ?

78

?

79

... 0.0

0

0.0

1

0.0

2

0.0

3

0.0

4

0.0

5

0.0

6

?

7

?

8

?

9

x ?

78

?

79

...

7 i


#include <stdio.h>

#include <stdlib.h>

int main () {

float x [80];

int i;

for (i=0; i<80; i++)

x[i] = 0;

return 0;

}

?

0

?

1

?

2

?

3

?

4

?

5

?

6

?

7

?

8

?

9

x ?

78

?

79

... 0.0

0

0.0

1

0.0

2

0.0

3

0.0

4

0.0

5

0.0

6

0.0

7

?

8

?

9

x ?

78

?

79

...

7 i


#include <stdio.h>

#include <stdlib.h>

int main () {

float x [80];

int i;

for (i=0; i<80; i++)

x[i] = 0;

return 0;

}

?

0

?

1

?

2

?

3

?

4

?

5

?

6

?

7

?

8

?

9

x ?

78

?

79

... 0.0

0

0.0

1

0.0

2

0.0

3

0.0

4

0.0

5

0.0

6

0.0

7

?

8

?

9

x ?

78

?

79

...

8 i


#include <stdio.h>

#include <stdlib.h>

int main () {

float x [80];

int i;

for (i=0; i<80; i++)

x[i] = 0;

return 0;

}

?

0

?

1

?

2

?

3

?

4

?

5

?

6

?

7

?

8

?

9

x ?

78

?

79

... 0.0

0

0.0

1

0.0

2

0.0

3

0.0

4

0.0

5

0.0

6

0.0

7

0.0

8

?

9

x ?

78

?

79

...

8 i


#include <stdio.h>

#include <stdlib.h>

int main () {

float x [80];

int i;

for (i=0; i<80; i++)

x[i] = 0;

return 0;

}

?

0

?

1

?

2

?

3

?

4

?

5

?

6

?

7

?

8

?

9

x ?

78

?

79

... 0.0

0

0.0

1

0.0

2

0.0

3

0.0

4

0.0

5

0.0

6

0.0

7

0.0

8

?

9

x ?

78

?

79

...

9 i


#include <stdio.h>

#include <stdlib.h>

int main () {

float x [80];

int i;

for (i=0; i<80; i++)

x[i] = 0;

return 0;

}

?

0

?

1

?

2

?

3

?

4

?

5

?

6

?

7

?

8

?

9

x ?

78

?

79

... 0.0

0

0.0

1

0.0

2

0.0

3

0.0

4

0.0

5

0.0

6

0.0

7

0.0

8

0.0

9

x ?

78

?

79

...

9 i


#include <stdio.h>

#include <stdlib.h>

int main () {

float x [80];

int i;

for (i=0; i<80; i++)

x[i] = 0;

return 0;

}

?

0

?

1

?

2

?

3

?

4

?

5

?

6

?

7

?

8

?

9

x ?

78

?

79

... 0.0

0

0.0

1

0.0

2

0.0

3

0.0

4

0.0

5

0.0

6

0.0

7

0.0

8

0.0

9

x 0,0

78

?

79

...

79 i

Algumas iterações depois...


#include <stdio.h>

#include <stdlib.h>

int main () {

float x [80];

int i;

for (i=0; i<80; i++)

x[i] = 0;

return 0;

}

?

0

?

1

?

2

?

3

?

4

?

5

?

6

?

7

?

8

?

9

x ?

78

?

79

... 0.0

0

0.0

1

0.0

2

0.0

3

0.0

4

0.0

5

0.0

6

0.0

7

0.0

8

0.0

9

x 0,0

78

0.0

79

...

79 i

Algumas iterações depois...

Mais um exemplo do uso de

Vetores


#include <stdio.h>

#include <stdlib.h>

int main () {

float x[80];

int i ;

for(i=110; i<190; i++)

x[i−110] = 0;

return 0;

}

?

0

?

1

?

2

?

3

?

4

?

5

?

6

?

7

?

8

?

9

x ?

78

?

79

... ?

0

?

1

?

2

?

3

?

4

?

5

?

6

?

7

?

8

?

9

x ?

78

?

79

...

? i

O índice do vetor pode ser uma expressão aritmética!

Percorrendo vetores

A posição i do vetor v, ou seja, v[i], é utilizada da mesma forma que utilizamos

qualquer variável até o momento.

Leitura de um Vetor #include <stdio.h>

#include <stdlib.h>

int main () {

float v[100];

int i, n;

printf ("Entre com 0<n<=100: ") ;

scanf ("%d", &n);

/* percorrer o vetor v de 0 a n−1 colocando o valor

lido pelo teclado */

for ( i=0; i<n ; i++) {

printf ("Entre com v[%d] = ", i);

scanf ("%f", &v[i]);

}

system("pause");

return 0;

}

?

0

?

1

?

2

?

3

?

4

?

5

?

6

?

7

?

8

?

9

v ?

98

?

99

...

Impressão de um Vetor #include <stdio.h>

#include <stdlib.h>

int main () {

float v[100];

int i, n;

printf ("Entre com 0<n<=100: ") ;

scanf ("%d", &n);

for ( i=0; i<n ; i++) {


scanf ("%f", &v[i]);

}

for ( i=0; i<n ; i++) {

printf ("v[%d] = %f", i, v[i]);

}

system("pause");

return 0;

}

A posição i do vetor v, ou seja, v[i], é impressa a cada iteração do comando for

Exercício:

• Dada uma sequência de 0<n<100 números inteiros, fazer a leitura dos n elementos armazenando-os em um vetor.

• Imprimir o conteúdo do vetor na ordem inversa à da leitura.

• Exemplo: Para n=5, e a sequência 11, 12, 3, 41, 321, o programa deve imprimir a saída 321, 41, 3, 12, 11.


#include <stdlib.h>

int main () {

int v [100], n, i;

printf ("Entre com 0<n<100: ");

scanf ("%d", &n ) ;

for (i=0; i<n ; i++) {


scanf ("%d", &v[i]);

}

for ( i=n−1; i>=0; i−−) {

printf ("v[%d] = %d\n" , i, v[i]);

}

system("pause");

return 0;

}


#include <stdlib.h>

int main () {

int v [100], n, i;


scanf ("%d", &n ) ;

for (i=0; i<n ; i++) {



}

for ( i=n−1; i>=0; i−−) {

printf ("v[%d] = %d\n" , i, v[i]);

}

system("pause");

return 0;

}

Entre com o 0<n<100: 5 Entre com v[0] = 21 Ponto 3(f2): a=11 b=5 c=30 d=2.2000000 Ponto 4(f1): a=3 b=10 c=41 d=0.3000000

Saída:


#include <stdlib.h>

int main () {

int v [100], n, i;


scanf ("%d", &n ) ;

for (i=0; i<n ; i++) {



}

for ( i=n−1; i>=0; i−−) {

printf ("v[%d] = %d\n" , i, v[i]);

}

system("pause");

return 0;

}

?

0

?

1

?

2

?

3

?

4

?

5

?

6

?

7

?

8

?

9

v ?

98

?

99

...

? n ? i


Saída:


#include <stdlib.h>

int main () {

int v [100], n, i;


scanf ("%d", &n ) ;

for (i=0; i<n ; i++) {



}

for ( i=n−1; i>=0; i−−) {

printf ("v[%d] = %d\n" , i, v[i]);

}

system("pause");

return 0;

}

?

0

?

1

?

2

?

3

?

4

?

5

?

6

?

7

?

8

?

9

v ?

98

?

99

...

5 n ? i

Entre com o 0<n<100: 5 Entre com v[0] = Ponto 3(f2): a=11 b=5 c=30 d=2.2000000 Ponto 4(f1): a=3 b=10 c=41 d=0.3000000

Saída:


#include <stdlib.h>

int main () {

int v [100], n, i;


scanf ("%d", &n ) ;

for (i=0; i<n ; i++) {



}

for ( i=n−1; i>=0; i−−) {

printf ("v[%d] = %d\n" , i, v[i]);

}

system("pause");

return 0;

}

?

0

?

1

?

2

?

3

?

4

?

5

?

6

?

7

?

8

?

9

v ?

98

?

99

...

5 n 0 i


Saída:


#include <stdlib.h>

int main () {

int v [100], n, i;


scanf ("%d", &n ) ;

for (i=0; i<n ; i++) {



}

for ( i=n−1; i>=0; i−−) {

printf ("v[%d] = %d\n" , i, v[i]);

}

system("pause");

return 0;

}


21

0

?

1

?

2

?

3

?

4

?

5

?

6

?

7

?

8

?

9

v ?

98

?

99

...

5 n 0 i

Saída:


#include <stdlib.h>

int main () {

int v [100], n, i;


scanf ("%d", &n ) ;

for (i=0; i<n ; i++) {



}

for ( i=n−1; i>=0; i−−) {

printf ("v[%d] = %d\n" , i, v[i]);

}

system("pause");

return 0;

}

21

0

?

1

?

2

?

3

?

4

?

5

?

6

?

7

?

8

?

9

v ?

98

?

99

...

5 n 1 i


Saída:


#include <stdlib.h>

int main () {

int v [100], n, i;


scanf ("%d", &n ) ;

for (i=0; i<n ; i++) {



}

for ( i=n−1; i>=0; i−−) {

printf ("v[%d] = %d\n" , i, v[i]);

}

system("pause");

return 0;

}

21

0

?

1

?

2

?

3

?

4

?

5

?

6

?

7

?

8

?

9

v ?

98

?

99

...

5 n 1 i

Entre com o 0<n<100: 5 Entre com v[0] = 21 Entre com v[1] = 15 Ponto 3(f2): a=11 b=5 c=30 d=2.2000000 Ponto 4(f1): a=3 b=10 c=41 d=0.3000000

Saída:


#include <stdlib.h>

int main () {

int v [100], n, i;


scanf ("%d", &n ) ;

for (i=0; i<n ; i++) {



}

for ( i=n−1; i>=0; i−−) {

printf ("v[%d] = %d\n" , i, v[i]);

}

system("pause");

return 0;

}

21

0

15

1

?

2

?

3

?

4

?

5

?

6

?

7

?

8

?

9

v ?

98

?

99

...

5 n 1 i


Saída:


#include <stdlib.h>

int main () {

int v [100], n, i;


scanf ("%d", &n ) ;

for (i=0; i<n ; i++) {



}

for ( i=n−1; i>=0; i−−) {

printf ("v[%d] = %d\n" , i, v[i]);

}

system("pause");

return 0;

}

21

0

15

1

?

2

?

3

?

4

?

5

?

6

?

7

?

8

?

9

v ?

98

?

99

...

5 n 2 i


Saída:


#include <stdlib.h>

int main () {

int v [100], n, i;


scanf ("%d", &n ) ;

for (i=0; i<n ; i++) {



}

for ( i=n−1; i>=0; i−−) {

printf ("v[%d] = %d\n" , i, v[i]);

}

system("pause");

return 0;

}

21

0

15

1

?

2

?

3

?

4

?

5

?

6

?

7

?

8

?

9

v ?

98

?

99

...

5 n 2 i

Entre com o 0<n<100: 5 Entre com v[0] = 21 Entre com v[1] = 15 Entre com v[2] = 15 Ponto 3(f2): a=11 b=5 c=30 d=2.2000000 Ponto 4(f1): a=3 b=10 c=41 d=0.3000000

Saída:


#include <stdlib.h>

int main () {

int v [100], n, i;


scanf ("%d", &n ) ;

for (i=0; i<n ; i++) {



}

for ( i=n−1; i>=0; i−−) {

printf ("v[%d] = %d\n" , i, v[i]);

}

system("pause");

return 0;

}

21

0

15

1

13

2

?

3

?

4

?

5

?

6

?

7

?

8

?

9

v ?

98

?

99

...

5 n 2 i


Saída:


#include <stdlib.h>

int main () {

int v [100], n, i;


scanf ("%d", &n ) ;

for (i=0; i<n ; i++) {



}

for ( i=n−1; i>=0; i−−) {

printf ("v[%d] = %d\n" , i, v[i]);

}

system("pause");

return 0;

}

21

0

15

1

13

2

?

3

?

4

?

5

?

6

?

7

?

8

?

9

v ?

98

?

99

...

5 n 3 i


Saída:


#include <stdlib.h>

int main () {

int v [100], n, i;


scanf ("%d", &n ) ;

for (i=0; i<n ; i++) {



}

for ( i=n−1; i>=0; i−−) {

printf ("v[%d] = %d\n" , i, v[i]);

}

system("pause");

return 0;

}

21

0

15

1

13

2

?

3

?

4

?

5

?

6

?

7

?

8

?

9

v ?

98

?

99

...

5 n 3 i

Entre com o 0<n<100: 5 Entre com v[0] = 21 Entre com v[1] = 15 Entre com v[2] = 1315 Entre com v[3] = 1315 Ponto 3(f2): a=11 b=5 c=30 d=2.2000000 Ponto 4(f1): a=3 b=10 c=41 d=0.3000000

Saída:


#include <stdlib.h>

int main () {

int v [100], n, i;


scanf ("%d", &n ) ;

for (i=0; i<n ; i++) {



}

for ( i=n−1; i>=0; i−−) {

printf ("v[%d] = %d\n" , i, v[i]);

}

system("pause");

return 0;

}

21

0

15

1

13

2

17

3

?

4

?

5

?

6

?

7

?

8

?

9

v ?

98

?

99

...

5 n 3 i


Saída:


#include <stdlib.h>

int main () {

int v [100], n, i;


scanf ("%d", &n ) ;

for (i=0; i<n ; i++) {



}

for ( i=n−1; i>=0; i−−) {

printf ("v[%d] = %d\n" , i, v[i]);

}

system("pause");

return 0;

}

21

0

15

1

13

2

17

3

?

4

?

5

?

6

?

7

?

8

?

9

v ?

98

?

99

...

5 n 4 i


Saída:


#include <stdlib.h>

int main () {

int v [100], n, i;


scanf ("%d", &n ) ;

for (i=0; i<n ; i++) {



}

for ( i=n−1; i>=0; i−−) {

printf ("v[%d] = %d\n" , i, v[i]);

}

system("pause");

return 0;

}

21

0

15

1

13

2

17

3

?

4

?

5

?

6

?

7

?

8

?

9

v ?

98

?

99

...

5 n 4 i

Entre com o 0<n<100: 5 Entre com v[0] = 21 Entre com v[1] = 15 Entre com v[2] = 1315 Entre com v[3] = 17 Entre com v[4] = 17 Ponto 3(f2): a=11 b=5 c=30 d=2.2000000 Ponto 4(f1): a=3 b=10 c=41 d=0.3000000

Saída:


#include <stdlib.h>

int main () {

int v [100], n, i;


scanf ("%d", &n ) ;

for (i=0; i<n ; i++) {



}

for ( i=n−1; i>=0; i−−) {

printf ("v[%d] = %d\n" , i, v[i]);

}

system("pause");

return 0;

}

21

0

15

1

13

2

17

3

18

4

?

5

?

6

?

7

?

8

?

9

v ?

98

?

99

...

5 n 4 i


Saída:


#include <stdlib.h>

int main () {

int v [100], n, i;


scanf ("%d", &n ) ;

for (i=0; i<n ; i++) {



}

for ( i=n−1; i>=0; i−−) {

printf ("v[%d] = %d\n" , i, v[i]);

}

system("pause");

return 0;

}

21

0

15

1

13

2

17

3

18

4

?

5

?

6

?

7

?

8

?

9

v ?

98

?

99

...

5 n 5 i


Saída:


#include <stdlib.h>

int main () {

int v [100], n, i;


scanf ("%d", &n ) ;

for (i=0; i<n ; i++) {



}

for ( i=n−1; i>=0; i−−) {

printf ("v[%d] = %d\n" , i, v[i]);

}

system("pause");

return 0;

}

21

0

15

1

13

2

17

3

18

4

?

5

?

6

?

7

?

8

?

9

v ?

98

?

99

...

5 n 4 i


Saída:


#include <stdlib.h>

int main () {

int v [100], n, i;


scanf ("%d", &n ) ;

for (i=0; i<n ; i++) {



}

for ( i=n−1; i>=0; i−−) {

printf ("v[%d] = %d\n" , i, v[i]);

}

system("pause");

return 0;

}

21

0

15

1

13

2

17

3

18

4

?

5

?

6

?

7

?

8

?

9

v ?

98

?

99

...

5 n 4 i

Entre com o 0<n<100: 5 Entre com v[0] = 21 Entre com v[1] = 15 Entre com v[2] = 1315 Entre com v[3] = 17 Entre com v[4] = 1817 v[4] = 18 Ponto 3(f2): a=11 b=5 c=30 d=2.2000000 Ponto 4(f1): a=3 b=10 c=41 d=0.3000000

Saída:


#include <stdlib.h>

int main () {

int v [100], n, i;


scanf ("%d", &n ) ;

for (i=0; i<n ; i++) {



}

for ( i=n−1; i>=0; i−−) {

printf ("v[%d] = %d\n" , i, v[i]);

}

system("pause");

return 0;

}

21

0

15

1

13

2

17

3

18

4

?

5

?

6

?

7

?

8

?

9

v ?

98

?

99

...

5 n 3 i

Entre com o 0<n<100: 5 Entre com v[0] = 21 Entre com v[1] = 15 Entre com v[2] = 1315 Entre com v[3] = 17 Entre com v[4] = 1817 v[4] = 18 Ponto 3(f2): a=11 b=5 c=30 d=2.2000000 Ponto 4(f1): a=3 b=10 c=41 d=0.3000000

Saída:


#include <stdlib.h>

int main () {

int v [100], n, i;


scanf ("%d", &n ) ;

for (i=0; i<n ; i++) {



}

for ( i=n−1; i>=0; i−−) {

printf ("v[%d] = %d\n" , i, v[i]);

}

system("pause");

return 0;

}

21

0

15

1

13

2

17

3

18

4

?

5

?

6

?

7

?

8

?

9

v ?

98

?

99

...

5 n 3 i

Entre com o 0<n<100: 5 Entre com v[0] = 21 Entre com v[1] = 15 Entre com v[2] = 1315 Entre com v[3] = 17 Entre com v[4] = 1817 v[4] = 18 v[3] = 17 Ponto 3(f2): a=11 b=5 c=30 d=2.2000000 Ponto 4(f1): a=3 b=10 c=41 d=0.3000000

Saída:


#include <stdlib.h>

int main () {

int v [100], n, i;


scanf ("%d", &n ) ;

for (i=0; i<n ; i++) {



}

for ( i=n−1; i>=0; i−−) {

printf ("v[%d] = %d\n" , i, v[i]);

}

system("pause");

return 0;

}

21

0

15

1

13

2

17

3

18

4

?

5

?

6

?

7

?

8

?

9

v ?

98

?

99

...

5 n 2 i

Entre com o 0<n<100: 5 Entre com v[0] = 21 Entre com v[1] = 15 Entre com v[2] = 1315 Entre com v[3] = 17 Entre com v[4] = 1817 v[4] = 18 v[3] = 17 Ponto 3(f2): a=11 b=5 c=30 d=2.2000000 Ponto 4(f1): a=3 b=10 c=41 d=0.3000000

Saída:


#include <stdlib.h>

int main () {

int v [100], n, i;


scanf ("%d", &n ) ;

for (i=0; i<n ; i++) {



}

for ( i=n−1; i>=0; i−−) {

printf ("v[%d] = %d\n" , i, v[i]);

}

system("pause");

return 0;

}

21

0

15

1

13

2

17

3

18

4

?

5

?

6

?

7

?

8

?

9

v ?

98

?

99

...

5 n 2 i

Entre com o 0<n<100: 5 Entre com v[0] = 21 Entre com v[1] = 15 Entre com v[2] = 1315 Entre com v[3] = 17 Entre com v[4] = 1817 v[4] = 18 v[3] = 17 v[2] = 13 Ponto 3(f2): a=11 b=5 c=30 d=2.2000000 Ponto 4(f1): a=3 b=10 c=41 d=0.3000000

Saída:


#include <stdlib.h>

int main () {

int v [100], n, i;


scanf ("%d", &n ) ;

for (i=0; i<n ; i++) {



}

for ( i=n−1; i>=0; i−−) {

printf ("v[%d] = %d\n" , i, v[i]);

}

system("pause");

return 0;

}

21

0

15

1

13

2

17

3

18

4

?

5

?

6

?

7

?

8

?

9

v ?

98

?

99

...

5 n 1 i

Entre com o 0<n<100: 5 Entre com v[0] = 21 Entre com v[1] = 15 Entre com v[2] = 1315 Entre com v[3] = 17 Entre com v[4] = 1817 v[4] = 18 v[3] = 17 v[2] = 13 Ponto 3(f2): a=11 b=5 c=30 d=2.2000000 Ponto 4(f1): a=3 b=10 c=41 d=0.3000000

Saída:


#include <stdlib.h>

int main () {

int v [100], n, i;


scanf ("%d", &n ) ;

for (i=0; i<n ; i++) {



}

for ( i=n−1; i>=0; i−−) {

printf ("v[%d] = %d\n" , i, v[i]);

}

system("pause");

return 0;

}

21

0

15

1

13

2

17

3

18

4

?

5

?

6

?

7

?

8

?

9

v ?

98

?

99

...

5 n 1 i

Entre com o 0<n<100: 5 Entre com v[0] = 21 Entre com v[1] = 15 Entre com v[2] = 1315 Entre com v[3] = 17 Entre com v[4] = 1817 v[4] = 18 v[3] = 17 v[2] = 13 v[1] = 15 Ponto 3(f2): a=11 b=5 c=30 d=2.2000000 Ponto 4(f1): a=3 b=10 c=41 d=0.3000000

Saída:


#include <stdlib.h>

int main () {

int v [100], n, i;


scanf ("%d", &n ) ;

for (i=0; i<n ; i++) {



}

for ( i=n−1; i>=0; i−−) {

printf ("v[%d] = %d\n" , i, v[i]);

}

system("pause");

return 0;

}

21

0

15

1

13

2

17

3

18

4

?

5

?

6

?

7

?

8

?

9

v ?

98

?

99

...

5 n 0 i

Entre com o 0<n<100: 5 Entre com v[0] = 21 Entre com v[1] = 15 Entre com v[2] = 1315 Entre com v[3] = 17 Entre com v[4] = 1817 v[4] = 18 v[3] = 17 v[2] = 13 v[1] = 15 Ponto 3(f2): a=11 b=5 c=30 d=2.2000000 Ponto 4(f1): a=3 b=10 c=41 d=0.3000000

Saída:


#include <stdlib.h>

int main () {

int v [100], n, i;


scanf ("%d", &n ) ;

for (i=0; i<n ; i++) {



}

for ( i=n−1; i>=0; i−−) {

printf ("v[%d] = %d\n" , i, v[i]);

}

system("pause");

return 0;

}

21

0

15

1

13

2

17

3

18

4

?

5

?

6

?

7

?

8

?

9

v ?

98

?

99

...

5 n 0 i

Entre com o 0<n<100: 5 Entre com v[0] = 21 Entre com v[1] = 15 Entre com v[2] = 1315 Entre com v[3] = 17 Entre com v[4] = 1817 v[4] = 18 v[3] = 17 v[2] = 13 v[1] = 15 v[0] = 21 Ponto 3(f2): a=11 b=5 c=30 d=2.2000000 Ponto 4(f1): a=3 b=10 c=41 d=0.3000000

Saída:


#include <stdlib.h>

int main () {

int v [100], n, i;


scanf ("%d", &n ) ;

for (i=0; i<n ; i++) {



}

for ( i=n−1; i>=0; i−−) {

printf ("v[%d] = %d\n" , i, v[i]);

}

system("pause");

return 0;

}

21

0

15

1

13

2

17

3

18

4

?

5

?

6

?

7

?

8

?

9

v ?

98

?

99

...

5 n -1 i

Entre com o 0<n<100: 5 Entre com v[0] = 21 Entre com v[1] = 15 Entre com v[2] = 1315 Entre com v[3] = 17 Entre com v[4] = 1817 v[4] = 18 v[3] = 17 v[2] = 13 v[1] = 15 v[0] = 21 Ponto 3(f2): a=11 b=5 c=30 d=2.2000000 Ponto 4(f1): a=3 b=10 c=41 d=0.3000000

Saída:


#include <stdlib.h>

int main () {

int v [100], n, i;


scanf ("%d", &n ) ;

for (i=0; i<n ; i++) {



}

for ( i=n−1; i>=0; i−−) {

printf ("v[%d] = %d\n" , i, v[i]);

}

system("pause");

return 0;

}

21

0

15

1

13

2

17

3

18

4

?

5

?

6

?

7

?

8

?

9

v ?

98

?

99

...

5 n -1 i

Entre com o 0<n<100: 5 Entre com v[0] = 21 Entre com v[1] = 15 Entre com v[2] = 1315 Entre com v[3] = 17 Entre com v[4] = 1817 v[4] = 18 v[3] = 17 v[2] = 13 v[1] = 15 v[0] = 21 Pressione qualquer tecla para c

Ponto 3(f2): a=11 b=5 c=30 d=2.2000000 Ponto 4(f1): a=3 b=10 c=41 d=0.3000000

Saída:

Erros comuns • Ao desenvolver seus programas com vetores, preste atenção aos

seguintes detalhes: – índices inválidos: tome muito cuidado, especialmente dentro de um while

ou for, de não utilizar índices negativos ou maiores que o tamanho máximo do vetor.

– Definição do tamanho do vetor se faz na declaração do vetor. O tamanho é constante, só mudando a sua declaração é que podemos alterar o seu tamanho. Isso significa que podemos estar “desperdiçando” algum espaço da memória que fica no final do vetor.

• Não cometa o erro de ler n, onde n seria o tamanho do vetor, e tentar “declarar” o vetor em seguida.

int n ;

printf ("Entre com n>0: ");

scanf ("%d", &n);

int v[n];

Exercícios:

Fonte: http://www.ime.usp.br/~hitoshi/introducao/18-vetor.pdf

Exercícios: 2. Dados dois vetores x e y, ambos com n elementos, n<50,

determinar o produto escalar desses vetores.

Passos: Para a solução deste exercício, você deverá : a) Declarar duas variáveis vetores do tipo inteiro (x e y) com 50 posições

cada; b) Declarar uma variável do tipo inteiro para armazenar o valor de n; c) Declarar uma variável do tipo inteiro para armazenar o valor de um

contador para percorrer os vetores de 0 a para n; d) Declarar uma variável do tipo inteiro para armazenar o produto escalar

dos vetores; e) Ler o valor para n; f) Ler n elementos para cada vetor (x e y) ; g) Percorrer os vetores (x e y) de contador=0 a contador<n fazendo o

produto = produto + x[contador] * y[contador];

12

0

51

1

14

2

15

3

16

4

11

5

52

6

41

7

y 12

48

53

49

... 21

0

15

1

13

2

17

3

18

4

10

5

5

6

4

7

x 1

48

5

49

...

Produto escalar=x[0].y[0] + x[1].y[1] + x[2].y[2] + ... x[n].y[n]

Resultado Esperado: exemplo


#include <stdlib.h>

int main() {

int x[50], y[50], n, contador, produto;

printf("Digite o valor para n: ");

scanf("%d", &n);

printf("\nDigite os componentes do vetor x: \n");

for (contador = 0; contador < n; contador++) {

printf("Forneca x[%d]=", contador);

scanf("%d", &x[contador]);

}

printf("\nDigite os componentes do vetor y: \n");

for (contador = 0; contador < n; contador++){

printf("Forneca y[%d]=", contador);

scanf("%d", &y[contador]);

}

produto = 0;

for (contador = 0; contador < n; contador++)


printf("\nProduto escalar desses vetores: %d\n", produto);

system("pause");

return 0;

}

Outra solução: #include <stdio.h>

#include <stdlib.h>

#define MAX 50

int main() {

int x[MAX], y[MAX], n, contador, produto;

printf("Digite o valor para n: ");

scanf("%d", &n);

printf("\nDigite os componentes do vetor x: \n");

for (contador = 0; contador < n; contador++) {

printf("Forneca x[%d]=", contador);

scanf("%d", &x[contador]);

}

printf("\nDigite os componentes do vetor y: \n");

for (contador = 0; contador < n; contador++){

printf("Forneca y[%d]=", contador);

scanf("%d", &y[contador]);

}

produto = 0;

for (contador = 0; contador < n; contador++)


printf("\nProduto escalar desses vetores: %d\n", produto);

system("pause");

return 0;

}

Matrizes

Matrizes:

Matrizes são estruturas indexadas em forma matricial (como ilustrado na figura abaixo) utilizadas para armazenar dados de um mesmo tipo: int, char, float ou double.

Figura 1: Uma matriz contem elementos de um mesmo tipo, com início em (0,0).

Declaração de Matrizes:

A declaração de uma matriz é feita da seguinte forma:

<tipo_da_matriz> <nome_da_matriz> [<numero_de_linhas>][<numero_de_colunas>];

Exemplos: Declaração de um vetor

int v[10];

0 1 2 3 4 5 6 7 8 9

v

Declaração de uma matriz

int m[5][10];

0 1 2 3 4 5 6 7 8 9

0

1

2

3

4

m

Declaração de Matrizes:

Declaração de uma matriz

int m[5][10];

0 1 2 3 4 5 6 7 8 9

0

1

2

3

4

m

Número de linhas: 5

Número de colunas: 10

int n[4][8];

0 1 2 3 4 5 6 7

0

1

2

3

n Número de linhas: 4


Uso de Matrizes:

int n[4][8];

5

0 1 2 3 4 5 6 7

0

1

2

3

n Número de linhas: 4


• São usados índices para acessar uma linha e uma coluna de uma matriz.

• Os índices são números naturais. • O índice da primeira linha é sempre zero. • O índice da primeira coluna é sempre zero.

n[0][0]=5;

5

n[1][2]=3;

3

n[3][5]=7;

7

Exemplo de Uso de Matrizes:

int A[4][8];

0 1 2 3 4 5 6 7

0

1

2

3

A Número de linhas: 4


#include <stdio.h>

#include <stdlib.h>

int main () {

int A[4][8], lin, col;

A[1][2]= 4;

lin= 2;

col= 3;

A[lin][col]=5;

A[A[lin−1][col−1]−1] [A[lin][col]]= 10;

printf(“%d”, A[3][5]);

system (“pause”);

return 0;

}

4

5

10

Percorrendo Matrizes:

/* para uma linha fixa lin */

for (col=0; col<nC; col++) {

/*comandos usando a matriz A[lin][col] */

}

Exemplo: ...

cont = 0;

lin = 1;

/* para uma linha fixa lin */

for (col=0; col < nC ; col++) {

A[lin][col] = cont ;

cont++;

}

...

Percorrendo Matrizes:

Um padrão para percorrer completamente a matriz A (isto é, as nL linhas e as nC colunas) por linhas é usar dois comandos de repetição (no caso, vamos usar o comando for) com duas variáveis inteiras lin e col, uma para percorrer as linhas e a outra para percorrer as colunas da matriz A:

for (lin=0; lin < nL; lin++) {

for (col=0; col<nC; col++) {

/*comandos usando a matriz A[lin][col]*/

}

}

Exemplo: for (lin=0; lin < nL ; lin++) {

for (col=0; col < nC; col++) {

A[lin][col] = 0;

}

}

Leitura de uma Matriz: #include <stdio.h>

#include <stdlib.h>

#define MAX_L 100

#define MAX_C 200

int main () {

float A[MAX_L][MAX_C];

int lin , col , nL , nC ;

printf ("Entre com 0<nL <%d: ", MAX_L);

scanf ("%d", &nL);

printf ("Entre com 0<nC <%d: ", MAX_C );

scanf ("%d", &nC );

/* percorrer a matriz A elemento a elemento */

/* colocando o valor lido pelo teclado */

for (lin=0; lin < nL ; lin++) {


printf ("Entre com A[%d][%d] = ", lin, col);

scanf ("%f", &A [lin][col]);

}

}

system(“pause”);

return 0;

}

Impressão de uma Matriz: #include <stdio.h>

#include <stdlib.h>

#define MAX_L 100

#define MAX_C 200

int main () {

float A[MAX_L][MAX_C];

int lin , col , nL , nC ;

printf ("Entre com 0<nL <%d: ", MAX_L);

scanf ("%d", &nL);

printf ("Entre com 0<nC <%d: ", MAX_C );

scanf ("%d", &nC );

/* percorrer a matriz A elemento a elemento */

/* imprimindo o valor lido pelo teclado */

for (lin=0; lin < nL ; lin++) {


printf (“%f", A[lin][col]);

}

printf(“\n”);

}


return 0;

}

Exercício

Desenvolva um programa para ler todos os elementos de uma matriz 5x5 e imprimir os valores da diagonal principal. (A diagonal principal é determinada por linha=coluna).

Declaração da matriz

int A[5][5];

0 1 2 3 4

0

1

2

3

4

A


#include <stdlib.h>

#define MAX_L 5

#define MAX_C 5

int main () {

int A[MAX_L][MAX_C];

int lin , col;

for (lin=0; lin < 5 ; lin++) {

for (col=0; col < 5 ; col++) {


scanf ("%d", &A [lin][col]);

}

}

for (lin=0; lin<5; lin++)

printf ("A[%d][%d] = %d ", lin, lin, A[lin][lin]);


return 0;

}

0 1 2 3 4

0

1

2

3

4

A

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

#include <stdlib.h>

#define MAX_L 5

#define MAX_C 5

int main () {

int A[MAX_L][MAX_C];

int lin , col;

for (lin=0; lin < 5 ; lin++) {



scanf ("%d", &A [lin][col]);

}

}

for (lin=0; lin<5; lin++) {


if (lin==col)

printf ("A[%d][%d] = %d ", lin, lin, A[lin][lin]);

}

}


return 0;

}

• Exercícios com Matrizes – http://www.ime.usp.br/~macmulti/exercicios/matrizes/index.html

Exercícios:

http://www.ime.usp.br/~macmulti/exercicios/funcoes2/index.html

http://www.ime.usp.br/~macmulti/exercicios/funcoes2/index.html

Introdução à Computação - IME-USPmcesar/Aulas_C_01_02_03.pdf · Algumas funções Matemáticas...

Documents

Transcript of Introdução à Computação - IME-USPmcesar/Aulas_C_01_02_03.pdf · Algumas funções Matemáticas...