resolução de algoritmo em livro de programação

[Salenka 0]

Olá, estou estudando lógica de programação por conta própria, e comecei com o livro Lógica de Programação: a construção de algoritmos e estruturas de dados, de Forbellone e Eberspächer (Pearson Education do Brasil, 2000, 2ª edição).

 

Só que apesar de ser uma edição "revisada", ela tem erros pra chuchu, que às vezes causam confusão (e depois de perceber vários erros, nas próximas vezes que você não entende alguma coisa, você começa a se perguntar se você não está entendendo mesmo, ou se existe algum erro de edição no logaritmo apresentado).

 

É o caso do logaritmo abaixo, apresentado como resolução de um exercício. Alguém poderia dar uma olhada pra ver se está certo? No caso, não consigo entender porque o primeiro e o último comando para é de 1 até 4 (de onde saiu esse quatro?)

 

Obrigada!

 

[observação: o quadradinho que apareceu no código é, na verdade, aquela flechinha apontando pra esquerda, que não saiu aqui :ermm: ]

 

Exercícios de fixação 1 [pág. 74]

 

1.4) Desenvolva um algoritmo que leia um vetor de 20 posições inteiras e o coloque em ordem crescente, utilizando a seguinte estratégia de ordenação:

Selecione o elemento do vetor de 20 posições que apresenta o menor valor;

Troque este elemento pelo primeiro;

Repita estas operações, envolvendo agora apenas os 19 elementos restantes (selecionando o de menor valor com a segunda posição), depois os 18 elementos restantes (trocando o de menor valor com a terceira posição), depois os 17, 16 e assim por diante, até restar um único elemento, o maior deles.

 

Resposta

 

___________________________________________________________________

 

Início

 

// definição do tipo de vetor

 

Tipo VETINT = vetor [1..20] de inteiro;

 

// declaração de variáveis

 

VETINT: V; // vetor de entrada de dados

inteiro: I, J, K, // índices

AUX; // auxiliar para troca

 

// laço para ler os valores de entrada do vetor V

 

para I de 1 até 4 passo 1 faça

leia (V) ;

fimpara;

 

// ordenação do vetor

 

para I de 1 até 19 passo 1 faça

K  I;

AUX  V;

para J de I + 1 até 20 passo 1 faça

se (V[J] < AUX)

então

início

K  J;

AUX  V[K];

fim;

fimse;

fimpara;

V[K]  V;

V  AUX;

fimpara;

 

// laço para mostrar o vetor V ordenado

 

para I de 1 até 4 passo 1 faça

escreva (V);

fimpara;

fim.

 

_________________________________________________________________________

 

Forbellone, ALV; Eberspacher, HF. Lógica de programação: a construção de algoritmos e estruturas de dados. 2. Ed. São Paulo : Pearson Education do Brasil, 2000.

 

 

 

 

P.S.: Tentei usar o comando

 pra manter a tabulação, mas aí ficou aparecendo as marcações BBCode... Então tirei o comando [code] pra manter o negrito (aos meus olhos, pelos menos, entre o negrito e a tabulação, o primeiro é ajuda mais na clareza do código. Espero estar certa.  :blush:

[Célio A. 4]

bem, o algoritmo esta correto, é chamado de método bolha.

oque ocorre é que mesmo o vetor tendo capacidade para 20 dados o algoritmo esta registrando apenas 4 dados, ou seja, mesmo tendo 20 cabides no meu guarda roupa eu não preciso colocar uma camisa em cada cabide, vou colocar apenas no que eu for usar.

 

O objetivo é ordenar o vetor, talvez foi registrado apenas 4 informaçoes para facilitar o teste de mesa, imagina fazer o teste com 20 informaçoes, percorrendo um por um para ordenar!

 

recomendo o curso da softblue, é um site de cursos pagos mas o de lógica é gratis para testar a metodologia da empresa.

[Salenka 0]

Obrigada, Célio!

 

Agora que sei que o 4 não é um erro, posso tentar entender o algoritmo em si. Mas tá difícil de visualizar a coisa funcionando, heim? - uma viagem isso de existirem 3 índices que na verdade são a mesma série de números, mais os números que são os vetores em si, que uma hora são V outra hora são AUX, argh!

 

Vou dar uma olhada nesse curso da Softblue, quem sabe ajude.

:thumbsup:

[Célio A. 4]

Método bolha para ordenar vetor, código mais limpo :)

 

algoritmo bolha
var
bolha: vetor[1..10] de inteiro
i, k, aux: inteiro
inicio
//grava os dados no vetor
para i de 1 até 4 passo 1 faça
	escreva("digite o valor da posição",i)
	leia(bolha[i]
fim_para

//coloca os dados em ordem
para i de 1 até 9 passo 1 faça
	para k de i+1 até 10 passo 1 faça 
		se (bolha[i] > bolha[k]) então
			aux <- bolha[i]
			bolha[i] <- bolha[k]
			bolha[k] <- aux
		fim_se
	fim_para
fim_para
fim.

 

Teste de mesa

o método bolha foi criada para colocar os dados de um vetor em ordem, podem ser numeros ou mesmo nomes

 

primeiro laço grava os 4 valores Ex: eu digito 9, 3, 22, 5

bolha[1] = 9

bolha[2] = 3

bolha[3] = 22

bolha[4] = 5

 

primeiro laço 'para' vai ler o vetor no indice i e o segundo que é o indice k vai ler i+1

i = 1

k = i+1 = 1+1 = 2

 

entra na estrutura se:

bolha > bolha[k]

bolha[1] > bolha[2]

9 > 3

verdadeiro

 

se é verdadeiro então vai executar oque esta dentro da estrutura

oque este codigo faz é trocar os valores, ou seja, trocar as posiçoes

aux <- bolha //aux = 9

bolha <- bolha[k] //bolha = 3

bolha[k] <- aux // bolha[k] = 9

 

agora temos

bolha[1] = 3 //bolha

bolha[2] = 9 //bolha[k]

bolha[3] = 22

bolha[4] = 5

 

passa para o segundo laço do "para" interno, vai comparar se:

bolha[3] é menor do que bolha[1] // falso

bolha[4] é menor do que bolha[1] // falso

 

termina o laço do 'para' interno volta 'para' o para externo, passa para o indice 2 e vai para o 'para' interno

bolha[3] é menor do que bolha[2] // falso

bolha[4] é menor do que bolha[2] // verdadeiro executa a troca pelo codigo na estrutura "se"

bolha[1] = 3

bolha[2] = 5 //bolha

bolha[3] = 22 //bolha[k]

bolha[4] = 9

 

termina o laço do 'para' interno volta 'para' o para externo, passa para o indice 3 e vai para o 'para' interno

bolha[4] é menor do que bolha[3] // verdadeiro

bolha[1] = 3

bolha[2] = 5

bolha[3] = 9 //bolha

bolha[4] = 22 //bolha[k]

 

vetor ordenado com sucesso