Até agora trabalhamos com um estrutura simples de variáveis. Nesta parte vamos conhecer a estrutura composta de dados, que se divide em dois tipos: Homogêneas (vetores e matrizes) e heterogêneas (registros).

Começaremos pelas homogêneas, em especial as homogêneas unidimensionais – Estrutura de dados conhecida como vetor.

Um vetor é uma espécie de caixa com divisórias onde se armazena os dados.

Até agora, se quiséssemos guardar quatro notas de dois alunos em um algoritmo. Teríamos que criar uma variável para cada nota. Exemplo:

Algoritmo “Variáveis simples”
Var
n1,n2,n3,n4:real
i:inteiro
Inicio
para i de 1 ate 2 faca
escreval (“Digite a nota do aluno”,i,” :”)
leia (n1)
leia (n2)
leia (n3)
leia (n4)
escreval (“Média do aluno”,((n1+n2+n3+n4)/4))
fimpara
Fimalgoritmo

Ou usaríamos muito mais linhas se não utilizássemos a estrutura de repetição.

Para resolver este problema podemos declarar uma variável que pode ler estes valores de uma maneira diferente.

Vetor

Um vetor permitem o agrupamento de várias informações (valores) dentro de uma mesma variável.

Sintaxe no VisualG:

n: vetor [1..4] de real

Onde n é o nome da variável.
Após escrever a palavra vetor, utilize colchetes e dois pontos em sequência entre o número que representara o início o fim do vetor, ou seja, quantos espaços você deseja criar para armazenar os valores.

Obs: a maioria das linguagens de programação iniciam os vetores em 0 (zero).

Exemplo com 1 vetor:

Algoritmo “Variável composta”
Var
n: vetor [1..4] de real
soma:real
i,j:inteiro
//i conta os 2 alunos
//j conta as 4 notas de cada aluno.
Inicio
para i de 1 ate 2 faca
soma<-0
escreval (“Digite as notas do aluno”,i,” :”)
para j de 1 ate 4 faca
leia (n[j])
soma <- soma + (n[j])
fimpara
escreval (“Média do aluno:”,i,” :”,soma/4)
fimpara
Fimalgoritmo

Para visualizar melhor como o algoritmo está guardando as notas, inclua a linha de código abaixo (em negrito) dentro do segundo laço:

Fimpara
   escreval (“Notas do aluno:”,n[1],n[2],n[3],n[4])
escreval (“Média do aluno:”,i,” :”,soma/4)
soma<-0

Ela mostra na tela as notas digitadas. Perceba que cada valor é armazenado em cada posição do índice do vetor n.

Geralmente, utilizamos outro laço para mostrar a saída do algoritmo na tela, com isso, não precisamos apontar cada posição do índice. O próprio laço se encarrega de mostrar.
Desta forma, substitua a linha escreval (“Notas do aluno:”,n[1],n[2],n[3],n[4]), por estas:

escreva (“Notas do aluno: “)
para j de 1 ate 4 faca
escreva (n[j]:2)
fimpara

Onde 0 :2 da terceira linha representa dois espaços que farão a separação dos números na hora de exibi-los. Como a divisão das casas decimais dos exercícios anteriores. Lembra?

A principal vantagem dos vetores é a possibilidade de armazenamento dos dados, inclusive variáveis do tipo caracter.

No algoritmo abaixo o usuário entrará com os nomes do alunos.

Algoritmo “Variável composta – nome”
Var
n: vetor [1..4] de real
nome: vetor [1..2] de caracter
soma:real
i,j:inteiro
//i conta os 2 alunos
//j conta as 4 notas de cada aluno.
Inicio
para i de 1 ate 2 faca
soma<-0
escreval (“Digite os dados aluno “,i,” :”)
escreval (” “)
escreva (“Nome do aluno: “)
leia (nome[i])
escreval (“Digite as 4 notas do aluno “,nome[i])

para j de 1 ate 4 faca
leia (n[j])
soma <- soma + (n[j])
fimpara

escreval (“Notas do aluno “,nome[i],” :”)

para j de 1 ate 4 faca
escreva (n[j]:5)
fimpara

escreval (” “)

escreval (“Média do aluno “,nome[i],” :”,soma/4)
fimpara
Fimalgoritmo

 

Uma outra maneira de desenvolver este algortimo é separar as 4 notas em vetores ou criar dois blocos de entrada de dados, um para cada aluno. Desta forma:

Algoritmo “Variável composta – nome e entrada em dois blocos de vetores”
Var
n,n2: vetor [1..4] de real
nome: vetor [1..2] de caracter
soma,soma2:real
i,j,j1:inteiro
//i conta os 2 alunos
//j e j1 contam as 4 notas de cada aluno.
Inicio
para i de 1 ate 2 faca
soma<-0
escreva (“Digite o nome do”,i,”o aluno(a):”)
leia (nome[i])
fimpara
escreval (” ——— “)
para j de 1 ate 4 faca
escreval (“Digite a “,j,”a nota do aluno(a) “,nome[1],”:”)
leia (n[j])
soma <- soma + (n[j])
fimpara
escreval (“Notas do aluno(a) “,nome[1],” :”)
para j de 1 ate 4 faca
escreva (n[j]:5)
fimpara
escreval (” “)
escreval (“Média do aluno (a) “,nome[1],” :”,soma/4)

escreval (” ———- “)

para j1 de 1 ate 4 faca
escreval (“Digite a “,j1,”a nota do aluno(a) “,nome[2],”:”)
leia (n2[j1])
soma2 <- soma2 + (n2[j1])
fimpara
escreval (“Notas do aluno(a) “,nome[2],” :”)
para j1 de 1 ate 4 faca
escreva (n2[j1]:5)
fimpara

escreval (” “)
escreval (“Média do aluno(a)”,nome[2],” :”,soma2/4)

escreval (” ———– “)
escreval (“Média total:”,((soma/4)+(soma2/4))/2)

Fimalgoritmo

Existem outras maneiras de desenvolvimento deste algortimo.  Tudo depende do objetivo do algoritmo.

Desafio:
Faça um algoritmo, utilizando vetores, que leia o nome e 2 notas de 4 alunos. Por fim, mostre a média de cada aluno e a média a turma.