Ajuda corrigir algoritmo visualg

Gabriel Tander · 20 de março de 2016

Sou iniciante no curso de ADS e montei o seguinte algoritmo hoje,após muitas pesquisas, no visualg.

Eu queria saber como fazer para o ultimo número não ter a virgula de separação.

Grato.

Pedrohtico · 23 de março de 2016

Eu achei um jeito de resolver seu problema, mas não ficou muito simples. Assim, vou tentar explicar passo a passo o funcionamento do algoritmo. Saiba que usei funções pré-definidas do visualg como "numpcarac", "copia" e "compr" e se você não as conhecer, pesquise na internet, pois ficaria ainda mais extenso eu explicá-las aqui. Não se assuste com o tamanho da resposta, pois tentei detalhar o máximo e, além disso, não é tão complicado quanto parece. Segue o algoritmo completo:

Spoiler


Algoritmo "intervalo"

Var
   num: vetor[1..10] de inteiro
   i, j, k: inteiro
   frase, aux: caracter
Inicio
   para i de 1 ate 10 faca
      escreva("Escreva um número: ")
      leia(num[i])
   fimpara
   
   k <- 0
   j <- 0
   frase <- "Os números "
   para i de 1 ate 10 faca
      se (num[i] >= 10) e (num[i] <= 150) entao
         aux <- numpcarac(num[i])
         frase <- frase + aux + ", "
         se (compr(aux) = 2) entao
            j <- j + 1
         senao
            se (compr(aux) = 3) entao
               k <- k + 1
            fimse
         fimse
      fimse
   fimpara
   
   se (j = 0) e (k = 0) entao
      escreva("Nenhum valor entre 10 e 150 foi adicionado.")
   senao
      aux <- copia(frase:1:9+4*j+5*k)
      escreva(aux, " está(ão) entre 10 e 150.")
   fimse
Fimalgoritmo

Primeiramente, eu criei uma variável de nome "frase" e tipo "caracter", para que ela comporte a frase que vai aparecer no final do programa, que é justamente a que você quer. Também criei uma variável de nome "aux" e tipo "caracter", que vai ter duas funções no algoritmo, mas a primeira vai ser receber o valor convertido do valor de uma determinada posição x do vetor "num" do tipo inteiro em caracter. Dessa forma, vai ser possível que você adicione esses valores à variável "frase", o que será essencial para retirar essa última vírgula no final. Assim, dentro da condição "se", quando o valor na posição i do vetor estiver entre 10 e 150, aux receberá o valor convertido em caracter (ex: se num[1] = 15, então aux = "15") e a variável frase será literalmente uma frase formada pela união dos caracteres já existentes antes na variável, mais o valor atual de aux e uma vírgula com um espaço na frente. Observe que isso tudo é basicamente o que você havia feito no seu programa, porém ao invés de escrever na tela todas as vezes que a função "para" completar um ciclo, eu guardo os valores dentro de uma variável do tipo "caracter". Observe que frase já havia recebido "Os números " antes de começar a receber os valores. Isso tudo ocorre apenas em:

   frase <- "Os números " 
   para i de 1 ate 10 faca
      se (num[i] >= 10) e (num[i] <= 150) entao
         aux <- numpcarac(num[i])
         frase <- frase + aux + ", "

Agora pense dessa forma: Se os únicos números que você inserisse que fossem entre 10 e 150 fossem 3 números e todos os 3 de apenas 2 algarismos. Tomemos como exemplo os valores 20, 30 e 40. Quando terminasse o ciclo da função "para", a variável frase teria esse valor dentro dela: "Os números 20, 30, 40, ". Assim, irei utilizar da função "copia" para que a variável aux receba todos os caracteres da variável frase, exceto os dois últimos, que consistem em ", ", que é justamente a vírgula que você deseja tirar e mais o caracter espaço. Observe que em "Os números " existem 11 caracteres, sendo 9 letras e 2 espaços. Dessa forma, contando a partir do primeiro caracter numérico (no caso, o 2) até o último algarismo numérico, que é o logo antes da vírgula indesejada, você teria "20, 30, 40", que consiste em 10 algarismos, sendo 6 numéricos, 2 vírgulas e 2 espaços.

Agora utilizaremos da parte de função, em matemática, mas nada complicado. Assim, podemos achar uma função "f(j) = 4j - 2", sendo que j é o número de algarismos entre 10 e 150 e f(j) o número de caracteres do primeiro algarismo numérico até o último antes da vírgula. No exemplo, podemos observar que temos 3 valores entre 10 e 150, sendo eles 20, 30 e 40. Assim, j = 3. Utilizando o j na função, achamos que f(j) = 4*3 - 2, então f(j) = 10. E esse f(j) é justamente o que achamos anteriormente na prática. Entretanto, essa função se aplica apenas se todos os valores entre 10 e 150 forem de 2 algarismos, o que nem sempre ocorre.

Mas se fizermos separadamente uma segunda função para qual todos os algarismos entre 10 e 150 forem de 3 algarismos, utilizando da mesma lógica anterior, achamos a função g(k) = 5k - 2, onde k é a quantidade de números com 3 algarismos. Essa segunda função é quase idêntica à primeira, mudando apenas um número por conta do acréscimo de algarismo.

Assim, você tem 2 funções que funcionam separadamente, mas o problema agora é juntá-las de forma que se obtenha apenas uma. E isso é bem simples. Tomemos por exemplo se em determinada vez no programa, existir 2 números de 2 algarismos e 3 números de 3 algarismos entre 10 e 150, como por exemplo os números 20, 30, 110, 120 e 130. Após passar pelo comando "para", a variável frase estaria da seguinte forma: frase = "Os números 20, 110, 30, 120, 130, " (veja que eles não estão necessariamente em ordem crescente ou decrescente). Novamente contando a partir do primeiro algarismo numérico até o último antes da vírgula, obtemos 21 caracteres. Entretanto, utilizando as funções que criamos separadamente, não é possível achar uma quantidade exata de caracteres antes da vírgula. Mas observe que se reagruparmos os valores, dessa forma em ordem crescente (ou decrescente, a lógica é a mesma), temos que frase = "Os números 20, 30, 110, 120, 130, " Se observarmos, fica claro que contando do primeiro algarismo numérico (no caso o algarismo 2 do número 20) até o último algarismo numérico do último número com a mesma quantidade de algarismos do primeiro (no caso o algarismo 0 do número 30), teríamos o valor encontrado utilizando a primeira função (f(j) = 4j - 2). Entretanto, ainda utilizaremos a vírgula e o espaço posterior, então simplesmente não retiramos esses 2 caracteres, sendo assim f(j) = 4j desta vez. Dessa forma, no exemplo, já teríamos contado todos os caracteres de "20, 30, ", que corresponde, justamente, a 8 caracteres. Ainda, observando agora os números com 3 algarismos, contamos do primeiro algarismo do primeiro número (no caso o 1 do 110) até o último algarismo do último número de 3 algarismos (no caso o 0 do 130). Observamos que corresponde a 13 algarismos, o que corresponde ao valor da segunda função (g(k) = 5k - 2) quando k = 3. Porém, dessa vez, nós desejamos retirar os últimos 2 caracteres, que são a vírgula e o espaço final. Assim, somando as 2 funções obtidas com essa lógica, temos uma nova função h(x) = 4j + 5k - 2. Também adicionamos os 11 caracteres iniciais de "Os números ", obtendo assim h(x) = 4j + 5j - 9. Essa função h(x) corresponde ao número de todos os caracteres até o último antes da última vírgula, que é justamente o que desejávamos.

Depois dessa longa explicação, finalmente voltamos ao algoritmo. Entretanto, agora fica extremamente mais fácil de entendê-lo. Observe que no ciclo do comando "para", toda vez que o número escrito pelo usuário estiver entre 10 e 150, haverá 2 condições lógicas, sendo a primeira para ver se o comprimento do número é de 2 algarismos e a segunda para ver se o comprimento do número é de 3 algarismos. Se a primeira estiver correta, adicionamos 1 à variável j, que corresponde justamente à quantidade de números de 2 algarismos. Isso ocorre de forma análoga para a variável k na segunda condição. Veja que antes de começar o comando "para", ambas as variáveis receberam o valor 0, para evitar problemas futuros. Observamos isso em:

j <- 0
k <- 0
se (compr(aux) = 2) entao
   j <- j + 1
senao
   se (compr(aux) = 3) entao
      k <- k + 1
   fimse
fimse

Agora, após a função "para" acabar, existem 3 variáveis importantes: A variável j e k, que correspondem, respectivamente, à quantidade de números com 2 e 3 algarismos, e a variável frase, que possui a frase inteira que necessitamos para a saída do programa, porém ainda com a vírgula e o espaço final indesejado. Entretanto, como já criamos a função necessária, fica realmente fácil tirar esses 2 caracteres. Agora é o momento que a variável aux realiza sua segunda função, sendo esta a função de receber todos os carateres desejados da variável frase. Para isso, utilizamos a função "copia", que vai literalmente copiar os caracteres desejados. Assim:

aux <- copia(frase:1:9+4*j+5*k)
escreva(aux, " está(ão) entre 10 e 150.")

Quando fazemos "frase:1:9+4*j+5*k", o algarismo 1, em laranja, significa que copiaremos a partir do primeiro caracter e a função em roxo significa o número de caracteres que iremos copiar. Assim, copiamos toda a parte desejável para a variável aux. Após isso, basta fazer um comando escreva, que escreverá tudo dentro da variável aux mais a parte " está(ão) entre 10 e 150.", terminando o algoritmo. Apenas para finalizar, observe a parte abaixo do algoritmo:

se (j = 0) e (k = 0) entao
   escreva("Nenhum valor entre 10 e 150 foi adicionado.")
senao
   aux <- copia(frase:1:9+4*j+5*k)
   escreva(aux, " está(ão) entre 10 e 150.")
fimse

Coloquei uma condição para ver se j e k são iguais a 0, pois se forem, quer dizer que não foi inserido nenhum valor entre 10 e 150.

Desculpe pela extensão da resposta, apesar do algoritmo não ser tão complicado, não achei uma forma mais rápida de explicar. Espero que entenda a resolução.

devair1010 · 9 de maio de 2016

Oi Gabriel Tander
coloque o segundo loop para ir de 1 ate 9 e aí depois do loop depois do fimpara
coloque assim que funciona :
se ( num [ 10 ] >= 10 ) e ( num [1 0 ] <= 150 ) então
escreval( num [ 10 ] )
fimse

Pedrohtico · 11 de maio de 2016

Então devair1010, esse pensamento também funciona, porém é necessário uma mudança. Desse jeito que você mostrou, só funcionaria se o último número estivesse entre 10 e 150. Se ele não estivesse, ele não seria printado na tela e o espaço do penúltimo número continuaria lá.

Assim, você teria que fazer um programa gigante tentando sempre achar o último valor que está entre o intervalo escolhido, que no caso é 10 e 150. Não adiantaria apenas conferir se o último número está ou não no intervalo. Imagine que o oitavo, nono e décimo número não estão entre o intervalo 10 e 150. Então seria necessário tirar o espaço depois do sétimo número, assim como se só o primeiro estivesse no intervalo, você precisaria conferir se os 9 últimos estão no intervalo para poder retirar o espaço.

Para fazer essas condições, seria um programa muito grande com várias condições e isso porque são apenas 10 números inseridos, imagine com 100 ou até 1000, que precisariam de, no pior dos casos, 99 e 999 verificações de condição, respectivamente. Por isso o método apresentado acima é mais prático, pois funciona de qualquer maneira, enquanto esse seria um programa muito confuso e exagerado.