algprog2sem 9

(1)

RESUMO DA AULA 21 Continuaremos a falar, nesta aula, sobre vetores.

Repetindo o conteúdo da aula passada, podemos associar um vetor a um prédio. O nome do vetor corresponde ao nome do prédio.

A cada andar deste prédio guardamos uma informação distinta.

Isto significa que para chegarmos a uma informação, devemos escolher o prédio e o andar onde esta informação está armazenada.

Quando escrevemos predio[andar] estamos querendo dizer que queremos acessar o conteúdo de determinado andar de um prédio.

Lembre-se que, no nosso caso, o andar mais baixo do prédio é numerado como sendo 0!!!!!

Um vetor é uma variável com muitos conteúdos distintos. Cada conteúdo é acessado quando definimos o andar do mesmo. Um vetor corresponde a várias variáveis.

Um vetor corresponde a várias variáveis mas as mesmas são diferenciadas pelo índice (andar) e não pelo nome!!!!!

Um vetor é uma tabela que armazena, simultaneamente, vários conteúdos distintos. Isto é feito armazenando, em cada andar, um conteúdo diferente.

Um vetor permite que o usuário armazene todas as informações que necessite enquanto o programa está sendo executado.

Como vimos na aula passada, há casos em que todos os dados digitados pelo usuário devem estar disponíveis enquanto o programa está sendo executado.

Usar vetores é uma maneira de deixar todas as informações disponíveis enquanto o programa está sendo usado. Isto pode ser necessário. Veja os exercícios 3207 modificação 1 e 3207

modificação 2 da aula passada.

Embora estejamos trabalhando com vetores, continuaremos a fazer contas que envolvam:  Contadores

 Acumuladores  Médias

 Percentagens  Busca do maior

 Busca da posição do maior  Busca do menor

 Busca da posição do menor Vamos passar ao problema 4206

(2)

Exercício4206 - Proposto - Vetores

Objetivos: manipulação de dados em vetores: inserção e acesso a dados a partir da manipulação de índices. Uso de contadores e acumuladores.

Enunciado: uma loja faz uso de 4 vetores para saber seu faturamento diário. Os mesmos são descritos a seguir:

 Estoque_i: Este vetor armazena os valores dos estoques iniciais de cada um dentre 5 produtos, numerados de 0 até 4. Assim Estoque_i[i] corresponde ao estoque inicial do produto i.

 Estoque_f: Este vetor armazena os valores dos estoques finais de cada um dentre 5 produtos, numerados de 0 até 4. Assim Estoque_f[i] corresponde ao estoque final do produto i.

 Valor_c: Este vetor armazena os valores dos custos unitários de cada um dentre 5 produtos, numerados de 0 até 4. Assim Valor_c[i] corresponde ao custo unitário do produto i.

 Valor_v: Este vetor armazena os valores dos preços unitários de venda para cada um dentre 5 produtos, numerados de 0 até 4. Assim Valor_v[i] corresponde ao preço unitário de venda para produto i.

Faça um programa em que leia cada um dos 4 vetores acima, calcule e mostre o total faturado pela loja para o dia em que são válidos os dados digitados.

Exemplo: Se as entradas fossem:

0 1 2 3 4

Estoque_i 13 8 7 9 6

Estoque_f 7 6 5 9 1

Valor_c 3.50 4.30 2.80 5.10 4.70

Valor_v 4.10 5.10 3.20 6.20 5.30

A saída deveria ser: 6*0.60 + 2*0.80 + 2*0.40 + 0*1.10 + 5*0.60 = 9.00

Antes de partir para a solução, vamos entender o problema. Uma loja possui 5 produtos distintos.

Esta loja faz controle de lucro diariamente.

Vamos responder a duas perguntas que nos ajudarão a resolver nosso problema. PERGUNTA 1

Conseguimos saber quanto foi vendido de cada produto?

Ao iniciar o dia, ela tem a posição do estoque inicial, sabemos qual a quantidade dos produtos ao início do dia.

A figura 21.1 mostra isso.

0 1 2 3 4

Estoque_i 13 8 7 9 6

(3)

Armazenamos as informações num vetor.

A cada posição corresponde o estoque inicial de um único produto. Analogamente, ao final do dia, a loja tem a posição do estoque final. Sabemos qual a quantidade dos produtos no final do dia.

A figura 21.2 mostra isso.

0 1 2 3 4

Estoque_f 7 6 5 9 1

Figura 21.2: forma de guardar informações de quantidade da loja ao final do dia Armazenamos as informações num vetor.

A cada posição corresponde o estoque final de um produto. Conseguimos saber quanto foi vendido de cada produto? Para o produto 0 faríamos (estoque_i[0] – estoque_f[0]). Para o produto 1 faríamos (estoque_i[1] – estoque_f[1]). Para o produto 2 faríamos (estoque_i[2] – estoque_f[2]). Para o produto 3 faríamos (estoque_i[3] – estoque_f[3]). Para o produto 4 faríamos (estoque_i[4] – estoque_f[4]).

Repare que estas fórmulas possuem algo em comum. Há uma regra geral para elas. Repare que a regra geral é:

Para um produto no endereço iindice a fórmula é (estoque_i[iindice] – estoque_f[iindice]). Se fizermos iindice = 0 obteremos (estoque_i[0] – estoque_f[0]).

Se fizermos iindice = 1 obteremos (estoque_i[1] – estoque_f[1]). Se fizermos iindice = 2 obteremos (estoque_i[2] – estoque_f[2]). Se fizermos iindice = 3 obteremos (estoque_i[3] – estoque_f[3]). Se fizermos iindice = 4 obteremos (estoque_i[4] – estoque_f[4]).

Basta variar iindice de 0 até 4 para gerarmos, automaticamente, a quantidade vendida de cada produto.

Isto é obtido fazendo-se uso de um comando de repetição que altere, de um em um, o valor da variável iindice.

Com o que foi explicado sabemos, a cada produto, quantas peças foram vendidas. PERGUNTA 2

Conseguimos saber quanto lucramos a cada peça vendida de produto?

Basta perceber que o lucro a cada peça, para determinado produto, é a diferença entre o valor de venda e o valor de compra.

A figura 21.3 mostra, exemplificando, os valores de compra de cada um dos 5 produtos .da loja A cada endereço temos o valor de custo para uma peça de determinado produto.

O índice identifica o produto.

0 1 2 3 4

Valor_c 3.50 4.30 2.80 5.10 4.70

(4)

A figura 214 mostra, exemplificando, os valores de venda de cada peça para os 5 produtos. da loja

A cada endereço temos o valor de venda de uma peça para cada um dos 5 produtos. O índice identifica o produto.

0 1 2 3 4

Valor_v 4.10 5.10 3.20 6.20 5.30

Figura 21.4: forma de guardar informações de preços de venda da loja Conseguimos saber quanto ganhamos a cada peça vendida de determinado produto? Para o produto 0 faríamos (valor_v[0] – valor_c[0]).

Para o produto 1 faríamos (valor_v[1] – valor_c[1]). Para o produto 2 faríamos (valor_v[2] – valor_c[2]). Para o produto 3 faríamos (valor_v[3] – valor_c[3]). Para o produto 4 faríamos (valor_v[4] – valor_c[4]).

Repare que estas fórmulas possuem algo em comum. Há uma regra geral para elas. Repare que a regra geral é:

Para uma peça de determinado produto contida no endereço iindice, a fórmula geral obtida é (valor_v[iindice] – valor_c[iindice]).

Se fizermos iindice = 0 obteremos (valor_v[0] – valor_c[0]). Se fizermos iindice = 1 obteremos (valor_v[1] – valor_c[1]). Se fizermos iindice = 2 obteremos (valor_v[2] – valor_c[2]). Se fizermos iindice = 3 obteremos (valor_v[3] – valor_c[3]). Se fizermos iindice = 4 obteremos (valor_v[4] – valor_c[4]).

Basta variar iindice de 0 até 4 para gerarmos, automaticamente, o lucro unitário a cada produto. Isto é obtido fazendo-se uso de um comando de repetição que altere, de um em um, o valor da variável iindice.

Com o que foi explicado sabemos, a cada produto, qual o lucro obtido a cada peça vendida. Após respondermos as perguntas 1 e 2, podemos responder a seguinte pergunta.

Pergunta 3:

Quanto ganhamos, em dinheiro, pela venda de cada um dos produtos?

Para o produto 0 faríamos (estoque_i[0] – estoque_f[0]) * (valor_v[0] – valor_c[0]). Para o produto 1 faríamos (estoque_i[1] – estoque_f[1]) * (valor_v[1] – valor_c[1]). Para o produto 2 faríamos (estoque_i[2] – estoque_f[2]) * (valor_v[2] – valor_c[2]). Para o produto 3 faríamos (estoque_i[3] – estoque_f[3]) * (valor_v[3] – valor_c[3]). Para o produto 4 faríamos (estoque_i[4] – estoque_f[4]) * (valor_v[4] – valor_c[4]). A cada produto, para saber o quanto vendemos, devemos fazer a multiplicação entre:

 quantidade vendida. A mesma corresponde à diferença de estoques inicial e final  lucro por peça. O mesmo corresponde à diferença de preços de venda e de compra. Genericamente, o lucro em dinheiro de um determinado produto é:

(estoque_i[iindice] – estoque_f[iindice]) * (valor_v[iindice] – valor_c[iindice]) Basta variar iindice de 0 até 4 para gerarmos, automaticamente, o lucro a cada produto.

(5)

Isto é obtido fazendo-se uso de um comando de repetição que altere, de um em um, o valor da variável iindice.

Esquematicamente, o problema é descrito na figura 21.5. soma = 0;

iindice = 0 soma = soma + (estoque_i[0] – estoque_f[0]) * (valor_v[0] – valor_c[0]) iindice = 1 soma = soma + (estoque_i[1] – estoque_f[1]) * (valor_v[1] – valor_c[1]) iindice = 2 soma = soma + (estoque_i[2] – estoque_f[2]) * (valor_v[2] – valor_c[2]) iindice = 3 soma = soma + (estoque_i[3] – estoque_f[2]) * (valor_v[3] – valor_c[3]) iindice = 4 soma = soma + (estoque_i[4] – estoque_f[2]) * (valor_v[4] – valor_c[4])

Figura 21.5: cálculos a serem executados pelo programa O exercício 4206 é um exercício que faz uso de acumuladores.

Podemos descrever o algoritmo para o problema 4206 da maneira descrita na figura 21.6. para (iindice = 0 ; iindice <= 4 ; iindice = iindice + 1)

leia ( iestoque_i[iindice]); leia ( iestoque_f[iindice]); leia ( dvalor_c[iindice]); leia (dvalor_v[iindice]); fim-para dsoma = 0 iindice = 0 enquanto ( iindice <=4 )

dsoma = dsoma + (iestoque_i[iindice] - iestoque_f[iindice]) * (dvalor_v[iindice] - dvalor_c[iindice])

iindice = iindice +1 fim-enquanto

imprima ( dsoma )

Figura 21.6: algoritmo para o exercício 4206 Para este mesmo problema, a descrição C é mostrada na figura 21.7

(6)

#include <conio.h> #include <stdio.h> #include <stdlib.h> int main ( )

{

int iindice , iestoque_i[5] , iestoque_f [5]; float dvalor_v [5] , dvalor_c[5] , dsoma;

for (iindice = 0 ; iindice <= 4 ; iindice = iindice + 1) {

printf("\n dar estoque inicial peca %d \n",iindice); scanf("%d",&iestoque_i[iindice]);

printf("\n dar etoque fina peca %d \n",iindice); scanf("%d",&iestoque_f[iindice]);

printf("\n dar preco de venda do produto %d \n",iindice); scanf("%f",&dvalor_v[iindice]);

printf("\n dar o preco de compra do produto %d \n",iindice); scanf("%f",&dvalor_c[iindice]); } iindice = 0; dsoma = 0; while ( iindice <=4 ) {

dsoma = dsoma + (iestoque_i[iindice] - iestoque_f[iindice]) * (dvalor_v[iindice] - dvalor_c[iindice]);

iindice = iindice +1; }

printf("\n o caixa possui %.2f \n", dsoma); system("pause");

return 0; }

Figura 21.7: descrição C para o exercício 4206 Vamos passar, agora, para o exercício 4208.

(7)

Objetivos: manipulação (Inserção)de dados em vetores. Uso de contadores. Enunciado: dizemos que um vetor de dimensão tamanho 10 é:

 Ordenado estritamente crescente se e somente se o conteúdo de uma posição de memória vale menos que o conteúdo de memória imediatamente seguinte;  Ordenado estritamente decrescente se e somente se o conteúdo de uma posição

de memória vale mais que o conteúdo de memória imediatamente seguinte;  Sobra caso não possa ser classificado em uma das opções acima.

Exemplo: se as entradas fossem:

0 1 2 3 4 5 6 7 8 9

1.3 1.7 2.1 2.7 3.1 4.4 5.5 6.7 7.9 10.1

A saída deveria ser: vetor ordenado estritamente crescente. Vamos continuar exemplificando.

A figura 21.8 mostra um vetor ordenado estritamente decrescente.

0 1 2 3 4 5 6 7 8 9

-1.3 -1.7 -2.1 -2.7 -3.1 -4.4 -5.5 -6.7 -7.9 -10.1 Figura 21.8: vetor classificado como estritamente decrescente A figura 21.9 mostra um vetor do tipo sobra.

0 1 2 3 4 5 6 7 8 9

1.3 1.7 2.1 2.7 -3.1 4.4 5.5 6.7 7.9 10.1

Figura 21.9: vetor classificado como sobra A figura 21.10 mostra um vetor do tipo sobra.

0 1 2 3 4 5 6 7 8 9

1.3 1.7 2.1 2.7 4.4 4.4 5.5 6.7 7.9 10.1

Figura 21.10: vetor classificado como sobra Como percebemos se um vetor lido é crescente ou decrescente ou sobra?

Para sabermos se um vetor é crescente, decrescente ou sobra, parece claro que devemos comparar 2 posições consecutivas no respectivo vetor:

Devemos comparar dvetor [0] com dvetor[1]. Devemos comparar dvetor [1] com dvetor[2]. Devemos comparar dvetor [2] com dvetor[3]. Devemos comparar dvetor [3] com dvetor[4]. Devemos comparar dvetor [4] com dvetor[5]. Devemos comparar dvetor [5] com dvetor[6]. Devemos comparar dvetor [6] com dvetor[7]. Devemos comparar dvetor [7] com dvetor[8]. Devemos comparar dvetor [8] com dvetor[9].

(8)

Note que há nove comparações distintas a serem feitas.

Genericamente, poderíamos escrever que queremos comparar duas posições consecutivas escrevendo uma expressão que envolva dvetor [iindice] e dvetor[iindice +1].

Conforme variamos iindice de 0 até 8, geramos todas as comparações possíveis.

Note que para podermos fazer operações envolvendo o endereço de uma posição do vetor. Temos a expressão geral de comparação que envolve dvetor [iindice] e dvetor[iindice +1]. Novamente

Quando iindice = 0 devemos comparar dvetor [0] com dvetor[1]. Quando iindice = 1 devemos comparar dvetor [1] com dvetor[2]. Quando iindice = 2 devemos comparar dvetor [2] com dvetor[3]. Quando iindice = 3 devemos comparar dvetor [3] com dvetor[4]. Quando iindice = 4 devemos comparar dvetor [4] com dvetor[5]. Quando iindice = 5 devemos comparar dvetor [5] com dvetor[6]. Quando iindice = 6 devemos comparar dvetor [6] com dvetor[7]. Quando iindice = 7 devemos comparar dvetor [7] com dvetor[8]. Quando iindice = 8 devemos comparar dvetor [8] com dvetor[9].

Podemos fazer a conta iindice + 1 para acessar um endereço no vetor dvetor. Há, portanto, sentido em escrevermos dvetor[iindice+1].

Note que para fazermos a comparação, devemos acessar simultaneamente os endereços iindice e (iindice + 1).

Voltando ao problema, a dificuldade está em como usar estas comparações para verificar se um vetor é crescente, decrescente ou sobra.

Novamente, note que há nove comparações distintas a serem feitas.

Um vetor é crescente se nas nove comparações tivermos (dvetor [iindice] < dvetor[iindice +1]). Devemos fazer iindice variar de 0 até 8.

Assim, basta percorrer o vetor fazendo a pergunta (dvetor [iindice] < dvetor[iindice +1]). A cada vez que a resposta for verdadeira, podemos contar este fato numa variável chamda isobe. Um vetor é decrescente se nas nove comparações tivermos (dvetor [iindice] e

dvetor[iindice +1 ]), supondo iindice variando de 0 até 8. Devemos fazer iindice variar de 0 até 8.

Assim, basta percorrer o vetor fazendo a pergunta (dvetor [iindice] > dvetor[iindice +1]). A cada vez que a resposta for verdadeira, podemos contar este fato numa variável chamda idesce.

Um vetor é dito crescente se isobe valer 9. Um vetor é dito decrescente se idesce valer 9.

Quando isobe não vale 9 e idesce não vale 9, o vetor é isobra. Vamos exemplificar. Acompanhe a figura 21.11 com a simulação1

0 1 2 3 4 5 6 7 8 9

1.3 1.7 2.1 2.7 3.1 4.4 5.5 6.7 7.9 10.1

iindice 0 1 2 3 4 5 6 7 8

isobe 0 1 2 3 4 5 6 7 8 9

idesce 0 0 0 0 0 0 0 0 0 0

(9)

Como isobe vale 9, o vetor é estritamente crescente.

Vamos novamente exemplificar. Acompanhe a figura 21.12 com a simulação2

0 1 2 3 4 5 6 7 8 9

-1.3 -1.7 -2.1 -2.7 -3.1 -4.4 -5.5 -6.7 -7.9 -10.1

iindice 0 1 2 3 4 5 6 7 8

isobe 0 0 0 0 0 0 0 0 0 0

idesce 0 1 2 3 4 5 6 7 8 9

Figura 21.12: simulação2 para o problema 4208 Como idesce vale 9, o vetor é estritamente decrescente.

0 1 2 3 4 5 6 7 8 9

1.3 1.7 2.1 2.7 -3.1 4.4 5.5 6.7 7.9 10.1

iindice 0 1 2 3 4 5 6 7 8

isobe 0 1 2 3 3 4 5 6 7 8

idesce 0 0 0 0 1 1 1 1 1 1

Figura 21.13: simulação3 para o problema 4208 Como isobe não vale 9 e idesce não vale 9, o vetor é sobra.

0 1 2 3 4 5 6 7 8 9

1.3 1.7 2.1 2.7 4.4 4.4 5.5 6.7 7.9 10.1

iindice 0 1 2 3 4 5 6 7 8

isobe 0 1 2 3 3 4 5 6 7 8

idesce 0 0 0 0 1 1 1 1 1 1

Figura 21.14: simulação4 para o problema 4208 Como isobe não vale 9 e idesce não vale 9, o vetor é sobra.

Este exercício envolve contagem.

(10)

para (iindice = 0 ; iindice <= 9 ; iindice = iindice + 1) leia (dvetor[iindice]); fim-para isobe =0 idesce = 0 iindice = 0 enquanto (iindice <=8) se ( dvetor[iindice] < dvetor[iindice+1]) isobe = isobe + 1 fim-se senão se ( dvetor[iindice] > dvetor[iindice+1]) idesce = idesce + 1 fim-se fim-senão iindice = iindice + 1 fim-enquanto se (isobe == 9 ) imprima (“sobe”) fim-se senão se (idesce == 9 ) imprima(“desce”) fim-se senão imprima(“sobra”) fim-senão fim-senão

Figura 21.15: algoritmo para o problema 4208 A descrição C é mostrada na figura 21.16

(11)

#include <conio.h> #include <stdio.h> #include <stdlib.h> int main( ) { float dvetor [10];

int iindice , isobe , idesce ;

printf("\n dar o elemento %d \n",iindice); scanf("%f",&dvetor[iindice]);

};

isobe = 0 ; idesce = 0; iindice = 0 ; while (iindice <=8) { if ( dvetor[iindice] < dvetor[iindice+1]) { isobe = isobe + 1; } else { if ( dvetor[iindice] > dvetor[iindice+1]) { idesce = idesce + 1; } } iindice = iindice + 1; }; if (isobe == 9 ) { printf("\n sobe \n"); } else { if (idesce == 9 ) { printf("\n desce\n"); } else { printf("\n sobra \n"); }; }; system ("pause"); return 0; }

(12)

Objetivos: manipulação de dados em vetores: inserção e manipulação de índices. Uso de contadores, acumuladores.

Enunciado: faça um programa que leia pelo teclado um vetor numérico real, de tamanho 12, calcule e exiba o valor de R onde:

R = (V[11]*V[0]) + (V[10]*V[1]) + (V[9]*V[2]) +...+ (V[1]*V[10]) + (V[0]*V[11]) Exemplo: se as entradas fossem:

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

3 1 4 2 5 6 0 -1 -3 -2 4 5

A saída seria: 0. Note que devemos :

Fazer o produto x[11]*x[0] Fazer o produto x[10]*x[1] . Fazer o produto x[9]*x[2] . Fazer o produto x[8]*x[3] . Fazer o produto x[7]*x[4] . Fazer o produto x[6]*x[5] . Fazer o produto x[5]*x[6] . Fazer o produto x[4]*x[7] . Fazer o produto x[3]*x[8] . Fazer o produto x[2]*x[9] . Fazer o produto x[1]*x[10] . Fazer o produto x[0]*x[11] .

Todas estas parcelas devem ser somadas.

Há uma maneira de gerar automaticamente estas 12 parcelas que devem ser somadas? Repare que estas fórmulas possuem algo em comum. Há uma regra geral para elas. Repare que a regra geral é:

x[11-iindice] * x[iindice] Note que quando iindice = 0 temos x[11] * x[0].

Note que quando iindice = 1 temos x[10] * x[1]. Note que quando iindice = 2 temos x[9] * x[2]. Note que quando iindice = 3 temos x[8] * x[3]. Note que quando iindice = 4 temos x[7] * x[4]. Note que quando iindice = 5 temos x[6] * x[5]. Note que quando iindice = 6 temos x[5] * x[6]. Note que quando iindice = 7 temos x[4] * x[7]. Note que quando iindice = 8 temos x[3] * x[8]. Note que quando iindice = 9 temos x[2] * x[9]. Note que quando iindice = 10 temos x[1] * x[10]. Note que quando iindice = 11 temos x[0] * x[11].

(13)

A cada rodada, isto é, a cada valor de iindice devemos gerar a parcela e acumularmos as mesmas numa variável chamada, por exemplo, dsoma.

Este exercício faz uso de acumuladores.

Note que precisamos fazer manipulações para acessar simultaneamente vários endereços. No nosso caso , acessamos simultaneamente os endereço iindice e ( 11 – iindice ).

A figura 21.17 descreve o algoritmo para o problema 42.10. para (iindice = 0 ; iindice <=11 ; iindice = iindice + 1)

leia (dvetor[iindice]); fim-para

dsoma =0 iindice = 0

enquanto (iindice <=11)

dsoma = dsoma + dvetor[iindice]*dvetor[11-iindice] iindice = iindice + 1

fim-enquanto imprima (dsoma)

Figura 21.17: algoritmo para o problema 4210. A descrição C deste problema é mostrada na figura 21.18

#include <conio.h> #include <stdio.h> #include <stdlib.h> int main ( ) { int iindice ;

float dvetor [12 ] , dsoma ;

for (iindice = 0 ; iindice <=11 ; iindice = iindice + 1) {

printf("\n dar o elemento %d \n", iindice); scanf("%f",&dvetor[iindice]);

};

dsoma =0; iindice = 0; while (iindice <=11) {

dsoma = dsoma + dvetor[iindice]*dvetor[11-iindice]; iindice = iindice + 1;

};

printf("\n a soma vale %f \n", dsoma ); system ("pause");

return 0; }

(14)

Figura 21.18: descrição C para o exercício 4210. Vamos ao exercício 4207.

Objetivos: manipulação de dados em vetores: inserção e acesso a dados a partir da manipulação de índices . Uso de contadores.

Enunciado: faça um programa que leia pelo teclado um vetor inteiro, de tamanho 10, e informe quantas TRIPLAS de números seguidos estão no conjunto dos dados teclados. Dica: para verificar se 3 números estão em P.A., basta testar se o segundo é igual à média

aritmética do primeiro com o terceiro número. Exemplo: se as entradas fossem:

0 1 2 3 4 5 6 7 8 9

3 10 20 30 7 2 4 6 8 15

20 = (10+30)/2 6 = (4+8)/2

4 = (2+6)/2 A saída seria:

(15)

Pelo exemplo dado percebemos que:

 3 10 12 não estão em P.A. pois 2*10 não vale (3+12)  10 20 30 estão em P.A. pois 2*20 vale (10+30)  20 30 7 não estão em P.A.pois 2*30 não vale (20 +7)  30 7 2 não estão em P.A. pois 2*7 não vale (30+2)  7 2 4 não estão em P.A pois 2*2 não vale (7+4)  2 4 6 estão em P.A. pois 2*4 vale (2+6)

 4 6 8 estão em P.A pois 2*6 vale (4+8)

 6 8 15 não estão em P.A. pois 2*8 não vale (6+15)

Para o nosso caso vale:

Comparar (dvetor[0] + dvetor[2]) com (2*dvetor[1]). Comparar (dvetor[1] + dvetor[3]) com (2*dvetor[2]). Comparar (dvetor[2] + dvetor[4]) com (2*dvetor[3]). Comparar (dvetor[3] + dvetor[5]) com (2*dvetor[4]). Comparar (dvetor[4] + dvetor[6]) com (2*dvetor[5]). Comparar (dvetor[5] + dvetor[7]) com (2*dvetor[6]). Comparar (dvetor[6] + dvetor[8]) com (2*dvetor[7]). Comparar (dvetor[7] + dvetor[9]) com (2*dvetor[8]).

Sempre que o resultado da comparação for verdadeiro, devemos contar que achamos mais 1 P.A.

Há uma maneira de gerar automaticamente estas 8 comparações?

Repare que estas fórmulas possuem algo em comum. Há uma regra geral para elas. Repare que a regra geral é comparar :

(dvetor[iindice] + dvetor[iindice +2]) com (2*dvetor[iindice +1]). Note que quando iindice = 0 temos (dvetor[0] + dvetor[2]) com (2*dvetor[1]). Note que quando iindice = 1 temos (dvetor[1] + dvetor[3]) com (2*dvetor[2]). Note que quando iindice = 2 temos (dvetor[2] + dvetor[4]) com (2*dvetor[3]). Note que quando iindice = 3 temos (dvetor[3] + dvetor[5]) com (2*dvetor[2]). Note que quando iindice = 4 temos (dvetor[4] + dvetor[6]) com (2*dvetor[5]). Note que quando iindice = 5 temos (dvetor[5] + dvetor[7]) com (2*dvetor[6]). Note que quando iindice = 6 temos (dvetor[6] + dvetor[8]) com (2*dvetor[7]). Note que quando iindice = 7 temos (dvetor[7] + dvetor[9]) com (2*dvetor[8]). Precisamos, numa única fórmula, acessar simultaneamente 3 endereços distintos. Os endereços são iindice, (iindice+1) e (iindice+2).

Este é um exercício que envolve contagem.

(16)

para (iindice = 0 ; iindice <= 9 ; iindice = iindice + 1) leia (dvetor[iindice]); fim-para iconta =0 iindice = 0 enquanto (iindice <=7)

se ( (dvetor[iindice+2]+ dvetor[iindice]) == (2*dvetor[iindice+1]) ) iconta = iconta + 1

fim-se

iindice = iindice + 1 fim-enquanto

imprima (iconta)

Figura 21.19: descrição do algoritmo para o problema 4207 A figura 21.20 dá a descrição C para o problema 4207.

#include <conio.h> #include <stdio.h> #include <stdlib.h> int main ( ) {

int iindice , iconta ; float dvetor [10];

printf("\n dar o valor %d \n", iindice); scanf("%f",&dvetor[iindice]); }

iconta =0; iindice = 0; while (iindice <=7) {

if ( (dvetor[iindice+2]+ dvetor[iindice]) == (2*dvetor[iindice+1]) ) {

iconta = iconta + 1; }

iindice = iindice + 1; }

printf("\n pa´s de tamanho 3 neste vetor %d \n", iconta) ; system("pause");

return 0; }