VisualG Algoritmos com vetores (vogais e consoantes)

saulogoiana · 26 de dezembro de 2017

Olá pessoal, meu professor me passou esta tarefa e não estou conseguindo resolver, se alguém me ajudar agradeço.

Escreva um algoritmo em pseudocódigo que armazene as letras vogais em
um vetor chamado vogal, as consoantes em um vetor chamado consoante. Em
seguida crie duas funções do tipo lógico (as quais vão percorrer os vetores e
comparar com a letra digitada, retornando V ou F) para saber se a letra é vogal
ou consoante. Ao final deverá ser impresso: vogal, consoante ou não é uma
letra (dependendo da letra digitada pelo usuário).

Eu fiz um pouco mas não estou sabendo como armazenar as vogais e as consoantes nos seu devido vetor. Estou travado no algoritmo

Algoritmo "VOGAL_CONSOANTE"
Var
vogal:vetor [1..5] de caracter
consoante:vetor [1..21] de caracter
i:inteiro
funcao letra(x:inteiro):logico
 var
 l:caractere
 inicio
 escolha l
  se
 fimescolha
 se
 fimse
fimfuncao
Inicio

Fimalgoritmo

Simon Viegas · 27 de dezembro de 2017

Olá @saulogoiana. Seja bem vindo ao Fórum do Clube do Hardware.

1) PREENCHIMENTO DOS VETORES

14 horas atrás, saulogoiana disse:

Escreva um algoritmo em pseudocódigo que armazene as letras vogais em
um vetor chamado vogal, as consoantes em um vetor chamado consoante.

Primeiramente foque apenas nesse requisito. O objetivo é ter 2 vetores com as características supracitadas.

Após, exiba esse vetor na tela. Essa é a base do programa.

Para te ajudar, tem pelo menos duas formas:

- "Por preenchimento na tora": para cada posição atribui seu respectivo valor. Ex.:

vogal[1]:="a"
vogal[2]:="e"
vogal[3]:="i"
etc

O mesmo para as consoantes.

- "Por preenchimento automatizado": utilizar das características do ASCII. Nela verás que as letras estão em sequência, o que pode ser aproveitado para preencher o vetor com auxílio de laços de repetições. Veja, dentro da faixa de letras (de "a" a "z"), basta inserir no vetor consoante tudo aquilo que não é vogal.

Comandos base:

Asc   (s : caracter): Retorna um inteiro com o código ASCII do primeiro caracter da expressão.
Carac (c : inteiro) : Retorna o caracter cujo código ASCII corresponde à expressão.

obs.: sugiro fazer inicialmente pelo primeiro método. Mais pra frente tenta fazer dessa ou de outra forma.

2) RESTANTE DO CÓDIGO

14 horas atrás, saulogoiana disse:

Em seguida crie duas funções do tipo lógico (as quais vão percorrer os vetores e
comparar com a letra digitada, retornando V ou F) para saber se a letra é vogal
ou consoante. Ao final deverá ser impresso: vogal, consoante ou não é uma
letra (dependendo da letra digitada pelo usuário).

Esqueça que isso existe por enquanto... foque apenas no item 1. Como se o programa fosse só aquela parte. Sem ela está funcionando, nada adianta o restante.

***

Posta o código aqui para analisarmos e/ou onde está com dúvidas.

Lembrando: seu objetivo é apenas criar um vetor de vogais, outro de consoantes e imprimir eles na tela.

No aguardo.

saulogoiana · 27 de dezembro de 2017

@Simon Viegas , Muito Obrigado pela atenção.

Eu consegui armazenar os caracteres nos devidos vetores.

Porém estão armazenados em maiúsculo, se tiver que corrigir isto eu dou um jeito.

Var

vogal:vetor [1..5] de caracter
consoante:vetor [1..21] de caracter
i,j,k:inteiro

Inicio
//Armazenamento nos devidos vetores.
j <- 0
k <- 65
para i de 1 ate 26 faca

asc(k)

 se (k = 65) então
  vogal[1] <- carac(k)
 senao

  se (k = 69) então
  vogal[2] <- carac(k)
  senao

   se (k = 73) então
   vogal[3] <- carac(k)
   senao

    se (k = 79) então
    vogal[4] <- carac(k)
    senao

     se (k = 85) então
     vogal[5] <- carac(k)
     senao
     
     j <- j + 1
     consoante[j] <- carac(k)
     
     fimse
    fimse
   fimse
  fimse
 fimse

k <- k + 1
fimpara

Fimalgoritmo

Simon Viegas · 27 de dezembro de 2017

Olá.

1 hora atrás, saulogoiana disse:

Eu consegui armazenar os caracteres nos devidos vetores.

Ficou bacana. Faltou exibir na tela os vetores... mas nem precisa, olhando pelo painel da "Área das variáveis de memória.." (lado direito do Visualg ) já dá para verificar.

1 hora atrás, saulogoiana disse:

Porém estão armazenados em maiúsculo, se tiver que corrigir isto eu dou um jeito.

Caso queira minúsculo, basta usar a faixa onde começa eles.. acho que a partir do 95. Mas não faz diferença, pois para comparar a sugestão que compare sempre com as maiúsculas. Pode usar a função Maiusc(). (obs.: acho que no Visualg nem precisa, ele já compara com maiúscula por padrão, ou seja, "A" e "a" são tecnicamente diferentes, mas mas o desenvolvedor já implementou para comparar já transformando o minúsculo em maiúsculo)

obs.: a instrução:

1 hora atrás, saulogoiana disse:

asc(k)

não está sendo utilizada... simplesmente apague do código.

Pronto... a base já tem. Agora vai para próxima etapa:

17 horas atrás, saulogoiana disse:

Em seguida crie duas funções do tipo lógico (as quais vão percorrer os vetores e
comparar com a letra digitada, retornando V ou F) para saber se a letra é vogal
ou consoante.

Pelo que eu entendi, cada uma das funções irá receber um caractere e retornar um logico. Tente fazer apenas um de cada vez. Por exemplo, chamar de EhVogal(), nela você precisa de alguma forma verifica se a letra que foi passada por parâmetro é igual a alguma das letras que estão no vetor vogal, se sim, retorna Verdadeiro, senão, retorna falso. Exatamente o mesmo será feito para as consoantes.

Caso tenha dúvidas sobre funcao em Visualg, dê uma pesquisa e olhe alguns exemplos... sugiro dar uma olhada nas postagens anteriores do Fórum.

Abaixo segue um exemplo aleatório:

algoritmo "Retorna o sinal do número (positivo, negativo ou neutro)"

funcao sinalDoNumero(numero:inteiro):caracter
   inicio
   se (numero>0) então
      retorne "Estritamente Positivo"
   senao
      se (numero<0) então
         retorne "Negativo"
      senao
         retorne "Neutro"
      fimSe
   fimSe
   fimFuncao
   
var
  x:inteiro

Inicio
x:=14
escreval(X," é ",sinalDoNumero(x))
x:=-7
escreval(X," é ",sinalDoNumero(x))
x:=0
escreval(X," é ",sinalDoNumero(x))
fimAlgoritmo

Então, no seu código, precisará retornar "Verdadeiro" ou "Falso", a depender se é vogal ou não. Esse valor que será retornado será utilizado na parte final.

2 horas atrás, Simon Viegas disse:

Ao final deverá ser impresso: vogal, consoante ou não é uma
letra (dependendo da letra digitada pelo usuário).

Pelo que entendi, aqui, quando a parte de cada função já estiver funcionando, você vai verificar se "é vogal" (se EhVogal() retronou verdadeiro), senão se "é consoante" (se EhConsoante() retornou verdadeiro), senão "não é uma letra". Independente de qualquer coisa, primeiro tente fazer as funções... depois parte para essa etapa.

No aguardo.

saulogoiana · 27 de dezembro de 2017

@Simon Viegas

Pesquisei sobre função.

Fiz outros exercícios usando funções(soma, subtração, multiplicação...), mas não estou conseguindo fazer a função que retorne o valor logico analisando os elementos dos vetores.

Simon Viegas · 28 de dezembro de 2017

Está em dúvidas em qual parte?

17 horas atrás, saulogoiana disse:

Fiz outros exercícios usando funções(soma, subtração, multiplicação...), mas não estou conseguindo fazer a função que retorne o valor logico analisando os elementos dos vetores.

É na parte de retornar o valor ou de encontrar uma resposta para retornar o valor correto? Poste o código e onde está com dúvidas.

Em relação à verificação, você precisa encontrar uma forma de identificar que a letra informada está contida no vetor ou não. Uma forma seria utilizando uma flag. Por exemplo, cria-se a variável EXISTE, do tipo inteiro. Inicializa ela com "0", ou seja, a "bandeira" indicando que "a letra que está sendo verificada não 'existe' no vetor". Daí, numa estrutura de repetição, você compara cada posição do vetor com a letra, se a posição for igual a letra, então muda a flag para "1", ou seja, a variável EXISTE mudará de valor... indicando que "a letra que está sendo verificada 'existe' no vetor". Ao final do processo, verifica o valor que está no EXISTE. Se existe for igual a "0", retorna falso ("não é vogal", pois a letra que foi informada não corresponde a nenhuma da vogais que tem no vetor, já que o EXISTE não mudou para 1). Senão, retorna verdadeiro. Entendeu? a flag inicializa com uma "status", se durante o processo de verificação for identificado que é outro status, a flag terá sido alterada.

Abaixo um exemplo de função utilizando retorno lógico:

algoritmo "Retorna se um número é positivo ou não"

funcao ehPositivo(numero:inteiro):logico
   inicio
   se (numero>=0) ENTÃO
      retorne VERDADEIRO
   senao
      se (numero<0) ENTÃO
         retorne FALSO
      fimSe
   fimSe
   fimFuncao

var
  x:inteiro

Inicio
escreval("Digite um número inteiro")
leia(x)
se ehPositivo(x)=VERDADEIRO ENTÃO
   escreval(X," é positivo")
senao
   escreval(X," é negativo")
fimSe
fimAlgoritmo

Na sua função, precisa verificar se a letra existe no vetor ou não. Na parte do código, vai usar essa resposta.

saulogoiana · 28 de dezembro de 2017

@Simon Viegas

Tentei muito fazer a função mas acho que ainda não está correta.

Var

vogal:vetor [1..5] de caracter
consoante:vetor [1..21] de caracter
i,j,k:inteiro
l:caracter

funcao fvogal (x:inteiro): logico
var
t:inteiro
inicio

 para t de 1 ate 26 faca
 vogal[t]
 consoante[t]

   se (x = vogal[t]) então
     retorne verdadeiro
   senao
    se (x = consoante[t]) então
      retorne falso
    fimse
   fimse

 fimpara

fimfuncao

Inicio
//Armazenamento nos devidos vetores.
j <- 0
k <- 97
para i de 1 ate 26 faca

asc(k)

 se (k = 97) então
  vogal[1] <- carac(k)
 senao

  se (k = 101) então
  vogal[2] <- carac(k)
  senao

   se (k = 105) então
   vogal[3] <- carac(k)
   senao

    se (k = 111) então
    vogal[4] <- carac(k)
    senao

     se (k = 117) então
     vogal[5] <- carac(k)
     senao

     j <- j + 1
     consoante[j] <- carac(k)

     fimse
    fimse
   fimse
  fimse
 fimse

k <- k + 1
fimpara

escreva("Digite uma letra:")
leia(l)
escreval("")

se ((fvogal (l) = verdadeiro) então
  escreva("A letra é uma Vogal.")
senao
 se ((fvogal (l) = falso) então
  escreva("A letra é uma Consoante.")
 senao
  escreva("Não é uma letra.")
 fimse
fimse

Fimalgoritmo

Simon Viegas · 28 de dezembro de 2017

Olá @saulogoiana.

2 horas atrás, saulogoiana disse:

Tentei muito fazer a função mas acho que ainda não está correta.

O quê que não está correto? em qual parte está com dúvidas?

Você precisa entender o que você quer fazer e o quê não está conseguindo implementar... daí tenta corrigir. Caso não consiga, poste aqui qual parte está com dúvida.

Em relação ao código, veja, são duas funções distintas. Uma para verificar se é vogal; outra para verificar se é consoante.

Em 26/12/2017 às 17:37, saulogoiana disse:

Em seguida crie duas funções do tipo lógico (as quais vão percorrer os vetores e
comparar com a letra digitada, retornando V ou F) para saber se a letra é vogal
ou consoante.

Pelo menos foi assim que entendi. Por enquanto só se preocupe com as Vogais.. esqueça das consoantes. A próxima etapa é criar uma função que apenas para retorne VERDADEIRO caso o caractere seja vogal, OU retorne FALSO caso o caractere não seja vogal. Só depois faz o da consoantes (que é exatamente igual ao da Vogal, só muda o vetor). NÃO TENTE FAZER OS DOIS JUNTOS!!! Faz um... copia o código e edita para o outro.

Tente achar uma forma de como verificar se um caractere é vogal ou não! E só!. É necessário abstrair o contexto geral...

Abaixo, tentei dar uma reorganizada no seu código:

algoritmo "a"
Var
   vogal    :vetor [1..5] de caracter  //vetor de vogais
   consoante:vetor [1..21] de caracter //vetor de consoantes
   i,j,k:inteiro //variáveis auxiliares
   {l:caracter} //não é uma "letra", mas sim um "caractere" (APAGUE ESSA LINHA)
   c:caracter //caracetere lido do usuário

//FUNÇÃO QUE RECEBE UM CARACTERE E RETORNA VERDADEIRO SE FOR ou FALSO SE NÃO FOR
{funcao fvogal (x:inteiro): logico} //a função recebe uma tipo caracte, não um número (APAGUE ESSA LINHA)
funcao fvogal (c:caracter): logico
   var
      i:inteiro
   inicio


   //FALTA IMPLEMENTAR AQUI


   fimfuncao

Inicio
//PREENCHE OS VETORES DE VOGAIS E CONSOANTES
j <- 0  //inicializa o contador de consoantes
k <- 97 //código da letra "a" na tabela ASCII
para i de 1 ate 26 faca //para as 26 letra do alfateto
   {asc(k)} //esse comando não está servindo para nada (APAGUE ESSA LINHA)
   se (k = 97) ENTÃO //se letra "a"
      vogal[1] <- carac(k)
   senao
      se (k = 101) ENTÃO //se letra "e"
         vogal[2] <- carac(k)
      senao
         se (k = 105) ENTÃO //se letra "i"
            vogal[3] <- carac(k)
         senao
            se (k = 111) ENTÃO //se letra "o"
               vogal[4] <- carac(k)
            senao
               se (k = 117) ENTÃO //se letra "u"
                  vogal[5] <- carac(k)
               senao //senão é consoante
                  j <- j + 1 //atualiza contador de consoantes
                  consoante[j] <- carac(k)
               fimse
            fimse
         fimse
      fimse
   fimse
   k <- k+1 //atualiza o contador de letras
fimpara

//LEITURA DE CARACTERE DO USUÁRIO
{escreva("Digite uma letra:")} //não é uma letra..... (APAGUE ESSA LINHA)
escreva("Digite um caractere:")
leia(c)

//ANALISE E RESPOSTA PARA O USUÁRIO
escreval("É vogal?",fvogal(c))

Fimalgoritmo

A parte que você precisa fazer está comentada aqui:

8 horas atrás, Simon Viegas disse:

Em relação à verificação, você precisa encontrar uma forma de identificar que a ~~letra~~ caractere informado está contida no vetor ou não. Uma forma seria utilizando uma flag. Por exemplo, cria-se a variável EXISTE, do tipo inteiro. Inicializa ela com "0", ou seja, a "bandeira" indicando que "o caractere que está sendo verificada não 'existe' no vetor". Daí, numa estrutura de repetição, você compara cada posição do vetor com a letra, se a posição for igual a letra, então muda a flag para "1", ou seja, a variável EXISTE mudará de valor... indicando que "a letra que está sendo verificada 'existe' no vetor". Ao final do processo, verifica o valor que está no EXISTE. Se existe for igual a "0", retorna falso ("não é vogal", pois a letra que foi informada não corresponde a nenhuma da vogais que tem no vetor, já que o EXISTE não mudou para 1). Senão, retorna verdadeiro. Entendeu? a flag inicializa com uma "status", se durante o processo de verificação for identificado que é outro status, a flag terá sido alterada.

No aguardo.

saulogoiana · 29 de dezembro de 2017

Spoiler

Algoritmo "VOGAL_CONSOANTE"

Var

vogal :vetor [1..5] de caracter
consoante:vetor [1..21] de caracter
i,j,k:inteiro
c:caracter

funcao fvogal (letra:caracter): logico
var

existe,posicao: inteiro

inicio
existe <- 0

    para posicao de 1 ate 5 faca
      se (letra = posicao) então
      existe <- 1
      fimse
    fimpara

fimfuncao

Inicio
//PREENCHE OS VETORES DE VOGAIS E CONSOANTES
j <- 0
k <- 97
para i de 1 ate 26 faca
   se (k = 97) ENTÃO //se letra "a"
      vogal[1] <- carac(k)
   senao
      se (k = 101) ENTÃO //se letra "e"
         vogal[2] <- carac(k)
      senao
         se (k = 105) ENTÃO //se letra "i"
            vogal[3] <- carac(k)
         senao
            se (k = 111) ENTÃO //se letra "o"
               vogal[4] <- carac(k)
            senao
               se (k = 117) ENTÃO //se letra "u"
                  vogal[5] <- carac(k)
               senao //senão, é consoante
                  j <- j + 1 //atualiza contador de consoantes
                  consoante[j] <- carac(k)
               fimse
            fimse
         fimse
      fimse
   fimse
   k <- k+1 //atualiza o contador de letras
fimpara

escreva("Digite um caractere:")
leia(c)

escreva(fvogal(c))

@Simon Viegas

Acho que não estou conseguindo fazer a variável percorrer o vetor, não tenho ideia de como colocar isso numa função.

Porque eu imagino ter de criar um vetor genérico na função, para quando for usar a função eu use o verdadeiro vetor no lugar desse genérico.

Simon Viegas · 30 de dezembro de 2017

Olá.

7 horas atrás, saulogoiana disse:

Acho que não estou conseguindo fazer a variável percorrer o vetor, não tenho ideia de como colocar isso numa função.

Porque eu imagino ter de criar um vetor genérico na função, para quando for usar a função eu use o verdadeiro vetor no lugar desse genérico.

Por uma questão de semântica, quem vai "percorrer" o vetor é a estrutura do laço de repetição... a variável é usada no processo.

Ex.:

funcao fvogal (letra:caracter): logico
   var
      existe, posicao: inteiro
   inicio
   existe <- 0 //inicializa a flag como "a letra não existe no vetor"
   para posicao de 1 ate 5 faca //para cada posição do vetor
      se (letra = vogal[posicao]) ENTÃO //se a letra informada é iagual a posição atual
         existe <- 1 //muda para "a letra existe no vetor"
      fimse
   fimPara
   se (existe=0) ENTÃO //se ficou com "a letra não existe no vetor"
      retorne FALSO //retorno FALSO ("não é vogal")
   senao //caso contrário
      retorne VERDADEIRO //retorno VERDADEIRO, ("é vogal")
   fimSe
   fimfuncao

Para simplificar, como só existe duas possibilidade (0 e 1), poderia usar a flag como do tipo lógico.

funcao fvogal (letra:caracter): logico
   var
      existe : logico
      posicao: inteiro
   inicio
   existe <- FALSO //inicializa a flag como "a letra não existe no vetor"
   para posicao de 1 ate 5 faca //para cada posição do vetor
      se (letra = vogal[posicao]) ENTÃO //se a letra informada é iagual a posição atual
         existe <- VERDADEIRO //muda para "a letra existe no vetor"
      fimse
   fimPara
   se (existe=FALSO) ENTÃO //se ficou com "a letra não existe no vetor"
      retorne FALSO //retorno FALSO ("não é vogal")
   senao //caso contrário
      retorne VERDADEIRO //retorno VERDADEIRO, ("é vogal")
   fimSe
   fimfuncao

Como a verificação no se é igual ao retorno, dá para usar direto:

funcao fvogal (letra:caracter): logico
   var
      existe : logico
      posicao: inteiro
   inicio
   existe <- FALSO //inicializa a flag como "a letra não existe no vetor"
   para posicao de 1 ate 5 faca //para cada posição do vetor
      se (letra = vogal[posicao]) ENTÃO //se a letra informada é iagual a posição atual
         existe <- VERDADEIRO //muda para "a letra existe no vetor"
      fimse
   fimPara
   retorne existe
   fimfuncao

Alguma dúvida ate aqui? algum trecho? alguma outra dúvida, como "por que a letra eu recebo por parâmetro, mas o vetor eu uso direto"?

Para este último, tem pelo menos 2 pontos:

- não é possível passar vetor por parâmetro no Visualg (pelo menos eu desconheço), se fosse, seria interessante passar também.

- e poderia sem problemas usar a variável c diretamente. Só deixar a função sem o parâmetro e trocar onde tem letra por c.

Pronto. Daí, cria a função para verificar se é constante (idêntico a vogal, só muda o vetor). E faz a parte final:

Em 26/12/2017 às 17:37, saulogoiana disse:

deverá ser impresso: vogal, consoante ou não é uma letra (dependendo da letra digitada pelo usuário).

Basta seguir:

Em 27/12/2017 às 11:06, Simon Viegas disse:

...você vai verificar se "é vogal" (se EhVogal() retronou verdadeiro), senão se "é consoante" (se EhConsoante() retornou verdadeiro), senão "não é uma letra".

*no caso com a nomenclatura que você escolher para as funções.

No aguardo.

saulogoiana · 30 de dezembro de 2017

Spoiler

Algoritmo "VOGAL_CONSOANTE"

Var

vogal:vetor [1..5] de caracter
consoante:vetor [1..21] de caracter
i,j,k:inteiro
l:caracter

funcao fvogal (letra:caractere):logico

var
posicao:inteiro
existe:logico
inicio

existe <- falso
para posicao de 1 ate 5 faca
se (letra = vogal[posicao]) então
existe <- verdadeiro
fimse
fimpara

retorne existe
fimfuncao

funcao fconsoante (letra:caractere):logico
var
posicao:inteiro
existe:logico
inicio

existe <- falso
para posicao de 1 ate 21 faca
se (letra = consoante[posicao]) então
existe <- verdadeiro
fimse
fimpara

retorne existe
fimfuncao

Inicio
//Armazenamento nos devidos vetores.
j <- 0
k <- 97
para i de 1 ate 26 faca

se (k = 97) então
vogal[1] <- carac(k)
senao

se (k = 101) então
vogal[2] <- carac(k)
senao

se (k = 105) então
vogal[3] <- carac(k)
senao

se (k = 111) então
vogal[4] <- carac(k)
senao

se (k = 117) então
vogal[5] <- carac(k)
senao

j <- j + 1
consoante[j] <- carac(k)

fimse
fimse
fimse
fimse
fimse

k <- k + 1
fimpara

escreval("Digite uma letra:")
leia(l)

se (fvogal(l) = verdadeiro) então
escreva("É uma vogal.")
senao
se(fconsoante(l) = verdadeiro) então
escreva("É uma consoante.")
senao
escreva("Não é um caractere.")
fimse
fimse

Fimalgoritmo

@Simon Viegas

MUITO OBRIGADO!!

agora tudo fez sentido, consegui compreender como trabalhar com este tipo de função.

Feliz Natal e Ano novo p você parceiro!

Simon Viegas · 31 de dezembro de 2017

Olá;

Muito bom! Show de bola!

Obs.: É recomendado manter o código indentado. No Visugal, basta pressionar "Ctrl+G".

Outra sugestão é criar um vetor para preencher os vetores, a ideia é deixar o código mais organizado...

- o vetor de vogal pode ser preenchido diretamente;

- o vetor de consoantes é preenchido com tudo que não é vogal da sequência, ou seja, se não é "a", "e", "i", "o" ou "u";

- em vez de ir de 1 a 26, usa a faixa das letras diretamente no para;

Abaixo segue um exemplo código.

procedimento preencherVetores()
var  
   codANSII :inteiro
   i        :inteiro
inicio
   //vetor de vogais preenchido diretamente
   vogal[1] <- "a"
   vogal[2] <- "e"
   vogal[3] <- "i"
   vogal[4] <- "o"
   vogal[5] <- "u"
   //vetor de consoantes preenchido com os "não vogais"
   para codANSII de 97 ate 122 faca
      escolha codANSII
      caso 97, 101, 105, 111, 117 //código das vogais
         escreva("") //não faz nada
      outrocaso //o que não é vogal, será consoante
         i:=i+1
         consoante[i]:=carac(codANSII)
      fimEscolha
   fimPara
fimProcedimento

Como é uma única variável com vários possível valores é possível utilizar Escolha/Caso, fiz com ele para demonstrar. Mas caso queira aproveitar do procedimento, poderia tentar fazer com se também.

Observe que dentro dele declarei o i para usar no para, pois dessa forma a procedimento fica independente das variáveis globais, ou seja, só receberia o vetores por parâmetro... (como não dá para enviar por parâmetro, usa diretamente a variável global. Isso é uma limitação do Visualg).

Segue abaixo um código completo para poder servi de base:

Algoritmo "VOGAL_CONSOANTE"
Var
   vogal    :vetor [1..5] de caracter
   consoante:vetor [1..21] de caracter
   {i,j,k    :inteiro} //não utilizados PODE APAGAR
   letra    :caracter

procedimento preencherVetores()
var
   codANSII :inteiro
   posicao  :inteiro
inicio
   //vetor de vogais preenchido diretamente
   vogal[1] <- "a"
   vogal[2] <- "e"
   vogal[3] <- "i"
   vogal[4] <- "o"
   vogal[5] <- "u"
   //vetor de consoantes preenchido com os "não vogais"
   para codANSII de 97 ate 122 faca
      escolha codANSII
      caso 97, 101, 105, 111, 117
         //código das vogais
         escreva("") //não faz nada
      outrocaso
         //o que não é vogal, será consoante
         posicao:=posicao+1
         consoante[posicao]:=carac(codANSII)
      fimEscolha
   fimPara
fimProcedimento

funcao fvogal (letra:caractere):logico
var
   posicao:inteiro
   existe:logico
inicio
   existe <- falso
   para posicao de 1 ate 5 faca
      se (letra = vogal[posicao]) ENTÃO
         existe <- verdadeiro
         interrompa //se já foi encontrado, logo não precisa continuar verificando
      fimse
   fimpara
   retorne existe
fimfuncao

funcao fconsoante (letra:caractere):logico
var
   posicao:inteiro
   existe:logico
inicio
   existe <- falso
   para posicao de 1 ate 21 faca
      se (letra = consoante[posicao]) ENTÃO
         existe <- verdadeiro
         interrompa //se já foi encontrado, logo não precisa continuar verificando
      fimse
   fimpara
   retorne existe
fimfuncao

Inicio
   preencherVetores()
   escreval("Digite uma letra:")
   leia(letra)
   se (fvogal(letra) = verdadeiro) ENTÃO
      escreva("É uma vogal.")
   senao
      se(fconsoante(letra) = verdadeiro) ENTÃO
         escreva("É uma consoante.")
      senao
         escreva("Não é um caractere.")
      fimse
   fimse
Fimalgoritmo

Nesse código, já que nos outros procedimentos utilizou a nomenclatura posicao, fiz o mesmo no preencherVetores(). Quando mais "coerentes" as nomenclaturas, melhor...

Abraços