VisualG Dá ERRO por não ter um FIMSE no fim do código

MATEUS GOMES85 · 8 de outubro de 2019

Bom dia Galerinha do bem! Fiz este código no VisualG que ordena cada linha da minha matriz 5x5 em ordem crescente, mas só compila quando insiro um FIMSE antes do fechamento do penúltimo PARA do código...E a minha dúvida é exatamente por que, uma vez que não consegui visualizar nenhum SE sem um FIMSE correspondente. Aguardo a ajuda de vcs amigos de batalha!!

Var
// Seção de Declarações das variáveis 
   M: vetor[1..5,1..5] de Inteiro

   i, j, k, aux: Inteiro

Inicio
// Seção de Comandos, procedimento, funções, operadores, etc... 
   Para i <- 1 ate 5 faca
        Para j <- 1 ate 5 faca
             Escreva("Digite um numero para posição [",i,",",j,"]: ")
             Leia(M[i,j])
        FimPara
        EscrevaL()
   FimPara
   Para i <- 1 ate 5 faca
        Se i = 1 entao

                 j <- 1
                 k <- 1
                 Enquanto k < 5 faca
                          k <- k + 1
                          Se M[i,j] > M[i,k] entao
                             aux <- M[i,j]
                             M[i,j] <- M[i,k]
                             M[i,k] <- aux
                          FimSe
                          Se (k = 5) e (j < 4) entao
                             j <- j + 1
                             k <- k - 1
                          FimSe
                 FimEnquanto

        Senao
             Se i = 2 entao

                     j <- 1
                     k <- 1
                     Enquanto k < 5 faca
                              k <- k + 1
                              Se M[i,j] > M[i,k] entao
                                 aux <- M[i,j]
                                 M[i,j] <- M[i,k]
                                 M[i,k] <- aux
                              FimSe
                              Se (k = 5) e (j < 4) entao
                                 j <- j + 1
                                 k <- k - 1
                              FimSe
                     FimEnquanto

             Senao
                  Se i = 3 entao

                     j <- 1
                     k <- 1
                     Enquanto k < 5 faca
                              k <- k + 1
                              Se M[i,j] > M[i,k] entao
                                 aux <- M[i,j]
                                 M[i,j] <- M[i,k]
                                 M[i,k] <- aux
                              FimSe
                              Se (k = 5) e (j < 4) entao
                                 j <- j + 1
                                 k <- k - 1
                              FimSe
                     FimEnquanto
                  Senao
                     Se (i = 4) entao

                        j <- 1
                        k <- 1
                        Enquanto k < 5 faca
                              k <- k + 1
                              Se M[i,j] > M[i,k] entao
                                 aux <- M[i,j]
                                 M[i,j] <- M[i,k]
                                 M[i,k] <- aux
                              FimSe
                              Se (k = 5) e (j < 4) entao
                                 j <- j + 1
                                 k <- k - 1
                              FimSe
                        FimEnquanto
                     Senao
                          Se (i = 5) entao

                             j <- 1
                             k <- 1
                             Enquanto k < 5 faca
                                      k <- k + 1
                                      Se M[i,j] > M[i,k] entao
                                         aux <- M[i,j]
                                         M[i,j] <- M[i,k]
                                         M[i,k] <- aux
                                      FimSe
                                      Se (k = 5) e (j < 4) entao
                                         j <- j + 1
                                         k <- k - 1
                                      FimSe
                             FimEnquanto
                          FimSe
                     FimSe
             FimSe
        FimSe
   // Este FIMSE foi inserido por mim além dos demais por não compilar sem ele....                         
   FimSe
   FimPara
   EscrevaL("")
   EscrevaL("...........................")
   EscrevaL(" ORDEM CRESCENTE POR LINHA ")
   EscrevaL("...........................")
   EscrevaL("...........................")
   Para i <- 1 ate 5 faca
        EscrevaL()
        Para j <- 1 ate 5 faca
             Escreva(M[i,j]:4)
        FimPara
        EscrevaL()
   FimPara
   EscrevaL("...........................")

Fimalgoritmo

Simon Viegas · 8 de outubro de 2019

Olá @MATEUS GOMES85.

Alguns pontos:

1#

O VisualG não compila o código por completo... em vez disse ele meio que vai interpretando linha a linha em tempo de execução, ou seja: se tiver faltando algo ou tenha algum erro, é comum só dá erro se a execução "se esbarrar" com esse trecho errado...

2#

Uma forma útil de implementar códigos, é já deixando as estruturas prontas a medida que vai implementando, ou seja: toda vez que criar um se, já insira abaixo o seu fimSe correspondente. Algo como:

      se i = 1 entao
        
      fimSe

Aí preenche o conteúdo depois. Vale ressaltar que um possível senao faz parte da mesma estrutura... ou seja: não tem outro fimSe (ou um fimSenao, rs)

3#

Outra dica bacana é pressionar Ctrl+G para reindentar o código... pelo alinhamento já ajuda a ver que pode está faltando algo. Experimento dar um Ctrl+G no seu código, depois tire um fimSe e dê outro Ctrl+G. Verás que vai mudar o alinhamento... com o tempo, acostuma com o alinhamento "correto" (ou seja: que faltando um fimSe, o alinhamento estará estranho).

4#

Abaixo segue uma versão reorganizada num padrão que eu uso (variáveis em minúsculo; camelCase para palavras juntas; espaçamento depois das "," etc):

algoritmo "FCdH'
var
   m :vetor[1..5, 1..5] de inteiro
   i, j, k, aux :inteiro

inicio
   para i <- 1 ate 5 faca
      para j <- 1 ate 5 faca
         escreva ("Digite um numero para posição [", i, ",", j, "]: ")
         aleatorio 1, 999
         leia(m[i,j])
         aleatorio off
      fimPara
      escrevaL("")
   fimPara
   para i <- 1 ate 5 faca
      se i = 1 entao
         j <- 1
         k <- 1
         enquanto k < 5 faca
            k <- k + 1
            se m[i,j] > m[i,k] entao
               aux <- m[i,j]
               m[i,j] <- m[i,k]
               m[i,k] <- aux
            fimSe
            se (k = 5) e (j < 4) entao
               j <- j + 1
               k <- k - 1
            fimSe
         fimEnquanto
      senao
         se i = 2 entao
            j <- 1
            k <- 1
            enquanto k < 5 faca
               k <- k + 1
               se m[i,j] > m[i,k] entao
                  aux <- m[i,j]
                  m[i,j] <- m[i,k]
                  m[i,k] <- aux
               fimSe
               se (k = 5) e (j < 4) entao
                  j <- j + 1
                  k <- k - 1
               fimSe
            fimEnquanto
         senao
            se i = 3 entao
               j <- 1
               k <- 1
               enquanto k < 5 faca
                  k <- k + 1
                  se m[i,j] > m[i,k] entao
                     aux <- m[i,j]
                     m[i,j] <- m[i,k]
                     m[i,k] <- aux
                  fimSe
                  se (k = 5) e (j < 4) entao
                     j <- j + 1
                     k <- k - 1
                  fimSe
               fimEnquanto
            senao
               se (i = 4) entao
                  j <- 1
                  k <- 1
                  enquanto k < 5 faca
                     k <- k + 1
                     se m[i,j] > m[i,k] entao
                        aux <- m[i,j]
                        m[i,j] <- m[i,k]
                        m[i,k] <- aux
                     fimSe
                     se (k = 5) e (j < 4) entao
                        j <- j + 1
                        k <- k - 1
                     fimSe
                  fimEnquanto
               senao
                  se (i = 5) entao
                     j <- 1
                     k <- 1
                     enquanto k < 5 faca
                        k <- k + 1
                        se m[i,j] > m[i,k] entao
                           aux <- m[i,j]
                           m[i,j] <- m[i,k]
                           m[i,k] <- aux
                        fimSe
                        se (k = 5) e (j < 4) entao
                           j <- j + 1
                           k <- k - 1
                        fimSe
                     fimEnquanto
                  fimSe
               fimSe
            fimSe
         fimSe
      fimSe //não é a mais. Ele é referente ao primeiro se lá em cima!
            //ou seja: possivelmente ficou faltando algum antes
   fimPara
   escrevaL("")
   escrevaL("...........................")
   escrevaL(" ORDEM CRESCENTE POR LINHA ")
   escrevaL("...........................")
   escrevaL("...........................")
   para i <- 1 ate 5 faca
      escrevaL()
      para j <- 1 ate 5 faca
         escreva(m[i,j]:4)
      fimPara
      escrevaL("")
   fimPara
   escrevaL("...........................")
fimalgoritmo

Obs.: para ajudar nos testes, pode utilizar da funcionalidade aleatorio. Já está contida no código acima.

Dúvidas e/ou comentário é só postar.

Adendo: não analisei a lógica do código... não sei se o algoritmo está funcionando ou não.

No aguardo.

MATEUS GOMES85 · 9 de outubro de 2019

@Simon Viegas, valeu pelos detalhes apontados amigo! Corrigi os erros de indentação e a lógica do programa tava errada também. Consistia em ordenar cada linha de forma crescente. Aí vai o pedaço do código que mudei pra q funcionasse. E em relação ao Se sem fechamento correspondente tem me acontecido todas as vezes que tento copiar/colar o código e acabo esquecendo fechar um deles (rs). Obrigado pela ajuda Simon! Até a próxima!

Para i <- 1 ate 10 faca
   Se i = 1 entao
      j <- 1
      k <- 1
      Enquanto k < 10 faca
         k <- k + 1
         Se M[i,j] > M[i,k] entao
            aux <- M[i,j]
            M[i,j] <- M[i,k]
            M[i,k] <- aux
         FimSe
         Se (k = 10) e (j < 9) entao
            j <- j + 1
            k <- j
         FimSe
      FimEnquanto
   Senao
      .
      .
      .
   FimSe

OBS:. O código continua exatamente igual até i = 10, pois a questão pede uma matriz 10x10

Simon Viegas · 9 de outubro de 2019

Eu não entendi muito bem o que é para ser feito... Por favor, poste o enunciado do problema, uma matriz inicial e como a matriz deveria ficar.

MATEUS GOMES85 · 10 de outubro de 2019

QUESTÃO: Escreva um algoritmo que ordene cada linha de uma matriz M[X,Y]

A questão pede para ordenar cada linha da matriz isoladamente do restante da matriz. 

Então optei em ordenar de forma crescente:


Algoritmo "MATRIZ ordenar por linha"
// Disciplina  :  [Linguagem e Lógica de Programação]
// Autor(a)    : Mateus Henrique
// Data atual  : 07/10/2019
Var
   // Seção de Declarações das variáveis
   M: vetor[1..3,1..3] de Inteiro

   i, j, k, aux: Inteiro

Inicio
   // Seção de Comandos, procedimento, funções, operadores, etc...
   Para i <- 1 ate 3 faca
      Para j <- 1 ate 3 faca
         Escreva("Digite um numero para posição [",i,",",j,"]: ")
         Leia(M[i,j])
      FimPara
      EscrevaL()
   FimPara
   Para i <- 1 ate 3 faca
      Se i = 1 entao
         j <- 1
         k <- 1
         Enquanto k < 3 faca
            k <- k + 1
            Se M[i,j] > M[i,k] entao
               aux <- M[i,j]
               M[i,j] <- M[i,k]
               M[i,k] <- aux
            FimSe
            Se (k = 3) e (j < 2) entao
               j <- j + 1
               k <- j
            FimSe
         FimEnquanto
      Senao
         Se i = 2 entao
            j <- 1
            k <- 1
            Enquanto k < 3 faca
               k <- k + 1
               Se M[i,j] > M[i,k] entao
                  aux <- M[i,j]
                  M[i,j] <- M[i,k]
                  M[i,k] <- aux
               FimSe
               Se (k = 3) e (j < 2) entao
                  j <- j + 1
                  k <- j
               FimSe
            FimEnquanto
         Senao
            Se i = 3 entao
               j <- 1
               k <- 1
               Enquanto k < 3 faca
                  k <- k + 1
                  Se M[i,j] > M[i,k] entao
                     aux <- M[i,j]
                     M[i,j] <- M[i,k]
                     M[i,k] <- aux
                  FimSe
                  Se (k = 3) e (j < 2) entao
                     j <- j + 1
                     k <- j
                  FimSe
               FimEnquanto
            FimSe
         FimSe
      FimSe
   FimPara
   EscrevaL("")
   EscrevaL("............................................................")
   EscrevaL("               ORDEM CRESCENTE POR LINHA A LINHA            ")
   EscrevaL("............................................................")
   EscrevaL("............................................................")
   Para i <- 1 ate 3 faca
      EscrevaL()
      Para j <- 1 ate 3 faca
         Escreva(M[i,j]:6)
      FimPara
      EscrevaL()
   FimPara
   EscrevaL("...........................................................")

Fimalgoritmo

@Simon Viegas Simon, desculpa por nao ter postado todo o código completo. Aí está o enunciado e a resolução com uma matriz 3x3. O enunciado pede uma matriz M[10,10].

adicionado 13 minutos depois

@Simon Viegas

Tava faltando as linhas que mostram a matriz antes de ser modificada!

Simon Viegas · 10 de outubro de 2019

Dois pontos:

- No trecho dá ordenação, você está repetindo o algoritmo de ordenação 3 (ou 10) vezes. É exatamente o mesmo código, não precisa repetir. Vai ficar apenas um para e um enquanto. A parte da ordenação é análoga a parte de impressão da matriz... você não precisa de uma estrutura de ordenação para cada linha... . Perceba que está utilizando umas estrutura se/senao para verificar qual a linha... e após faz exatamente a mesma coisa para qualquer linha... logo, não precisar de estrutura de seleção.

- Após ajustar a ordenação, como opção, insira uma constante que conterá o tamanho da matriz. Daí, onde precisa dessa referência (na leitura, na ordenação e na exibição), utiliza esse. obs.: esse segundo ponto seria apenas um bônus, pois o tamanho da matriz é fixa.

MATEUS GOMES85 · 10 de outubro de 2019

@Simon Viegas

Muito esclarecedora a sua explicação !!

Algoritmo "MATRIZ ordenar por linha"
// Disciplina  :  [Linguagem e Lógica de Programação]
// Professor   : Gustavo Guanabara
// Descrição   : Ordenar matriz linha a linha
// Autor(a)    : Mateus Henrique
// Data atual  : 07/10/2019
Var
   // Seção de Declarações das variáveis
   M: vetor[1..3,1..3] de Inteiro

   i, j, k, aux, t: Inteiro

Inicio
   // Seção de Comandos, procedimento, funções, operadores, etc...
   t <- 1

   Para i <- 1 ate 3 faca
      Para j <- 1 ate 3 faca
         Escreva("Digite um numero para posição [",i,",",j,"]: ")
         Leia(M[i,j])
      FimPara
      EscrevaL()
   FimPara
   EscrevaL("..............................")
   EscrevaL("        MATRIZ INICIAL        ")
   EscrevaL("..............................")
   Para i <- 1 ate 3 faca
        EscrevaL()
        Para j <- 1 ate 3 faca
             Escreva(M[i,j]:6)
        FimPara
        EscrevaL()
   FimPara
   EscrevaL("..............................")
   EscrevaL("..............................")
   Para i <- 1 ate 3 faca
      Se i = t entao
         j <- 1
         k <- 1
         Enquanto k < 3 faca
            k <- k + 1
            Se M[i,j] > M[i,k] entao
               aux <- M[i,j]
               M[i,j] <- M[i,k]
               M[i,k] <- aux
            FimSe
            Se (k = 3) e (j < 2) entao
               j <- j + 1
               k <- j
            FimSe
         FimEnquanto
         t <- t + 1

      FimSe
   FimPara
   EscrevaL("")
   EscrevaL("..................................")
   EscrevaL("ORDEM CRESCENTE POR LINHA A LINHA ")
   EscrevaL("..................................")
   EscrevaL("..................................")
   Para i <- 1 ate 3 faca
      EscrevaL()
      Para j <- 1 ate 3 faca
         Escreva(M[i,j]:6)
      FimPara
      EscrevaL()
   FimPara
   EscrevaL("..................................")

Fimalgoritmo

a explicação!!. Vou colocar logo em prática ...

O código ficou muito menor!

Obrigado!!!

Simon Viegas · 10 de outubro de 2019

1#

Sobre:

50 minutos atrás, MATEUS GOMES85 disse:
Se i = t entao

Sempre i vai ser igual a t (é uma tautologia). Não precisa desse se.

2#

Para facilitar os testes, utilize do recurso aleatorio. Ex.:

   Para i <- 1 ate 3 faca
      Para j <- 1 ate 3 faca
         Escreva("Digite um numero para posição [",i,",",j,"]: ")
         aleatorio 1, 999
         Leia(M[i,j])
         aleatorio off
      FimPara
      EscrevaL()
   FimPara

3#

Agora poderia tentar:

1 hora atrás, Simon Viegas disse:

- Após ajustar a ordenação, como opção, insira uma constante que conterá o tamanho da matriz. Daí, onde precisa dessa referência (na leitura, na ordenação e na exibição), utiliza ele*.

Desta forma, ao mudar o valor dessa constante no código, irá mudar o tamanho da matriz e todas a suas dependências.

***

No aguardo.

MATEUS GOMES85 · 10 de outubro de 2019

Var
   // Seção de Declarações das variáveis
   M: vetor[1..3,1..3] de Inteiro

   i, j, k, aux, t: Inteiro

Inicio
   // Seção de Comandos, procedimento, funções, operadores, etc...

   t <- 3
   Para i <- 1 ate t faca
      Para j <- 1 ate t faca
         Escreva("Digite um numero para posição [",i,",",j,"]: ")
         aleatorio 1,999
         Leia(M[i,j])
         aleatorio off
      FimPara
      EscrevaL()
      
   FimPara
   EscrevaL("..............................")
   EscrevaL("        MATRIZ INICIAL        ")
   EscrevaL("..............................")
   Para i <- 1 ate t faca
        EscrevaL()
        Para j <- 1 ate t faca
             Escreva(M[i,j]:6)
        FimPara
        EscrevaL()

   FimPara
   EscrevaL("..............................")
   EscrevaL("..............................")
   Para i <- 1 ate t faca
         j <- 1
         k <- 1
         Enquanto k < t faca
            k <- k + 1
            Se M[i,j] > M[i,k] entao
               aux <- M[i,j]
               M[i,j] <- M[i,k]
               M[i,k] <- aux
            FimSe
            Se (k = t) e (j < (t - 1)) entao
               j <- j + 1
               k <- j
            FimSe
         FimEnquanto

   FimPara
   EscrevaL("")
   EscrevaL("..................................")
   EscrevaL("ORDEM CRESCENTE POR LINHA A LINHA ")
   EscrevaL("..................................")
   EscrevaL("..................................")
   Para i <- 1 ate t faca
      EscrevaL()
      Para j <- 1 ate t faca
         Escreva(M[i,j]:6)
      FimPara
      EscrevaL()
   FimPara
   EscrevaL("..................................")

Fimalgoritmo

@Simon Viegas

Os pontos #1 e #2 eu entendi...Mas (o ponto #3) como fazer referencia em uma constante sobre a ordem da matriz sem a necessidade de repetir em todo código quando alterar o tamanho da matriz estou dúvida de como fazê-lo.

Adicionei no código acima uma constante no primeiro Para do código afim de nao ter que alterar o tamanho da matriz no restante do código ...Seria isso mesmo ? Fico no aguardo.

Simon Viegas · 10 de outubro de 2019

@MATEUS GOMES85, seria assim como você fez mesmo, apenas mudando de variável para constante... (que é basicamente a mesma coisa, apenas que não dá para mudar o valor no depois). Outra vantagem da constante para o contexto é que pode usá-la para definir o tamanho do vetor.

Desta forma, apenas alterando o valor da constante, todo o restante ficará ajustado.

Segue:

Algoritmo "MATRIZ ordenar por linha"
Const
   TAMANHO = 10
Var
   M: vetor[1..TAMANHO, 1..TAMANHO] de Inteiro
   i, j, k, aux :Inteiro
   
Inicio
   Para i <- 1 ate TAMANHO faca
      Para j <- 1 ate TAMANHO faca
         Escreva("Digite um numero para posição [", i:2, ",", j:2, "]: ")
         aleatorio 1,999
         Leia(M[i,j])
         aleatorio off
      FimPara
      EscrevaL()
   FimPara
   EscrevaL("..............................")
   EscrevaL("        MATRIZ INICIAL        ")
   EscrevaL("..............................")
   Para i <- 1 ate TAMANHO faca
        EscrevaL()
        Para j <- 1 ate TAMANHO faca
             Escreva(M[i,j]:6)
        FimPara
        EscrevaL()

   FimPara
   EscrevaL("..............................")
   EscrevaL("..............................")
   Para i <- 1 ate TAMANHO faca
         j <- 1
         k <- 1
         Enquanto k < TAMANHO faca
            k <- k + 1
            Se M[i,j] > M[i,k] entao
               aux <- M[i,j]
               M[i,j] <- M[i,k]
               M[i,k] <- aux
            FimSe
            Se (k = TAMANHO) e (j < (TAMANHO - 1)) entao
               j <- j + 1
               k <- j
            FimSe
         FimEnquanto
   FimPara
   EscrevaL("")
   EscrevaL("..................................")
   EscrevaL("ORDEM CRESCENTE POR LINHA A LINHA ")
   EscrevaL("..................................")
   EscrevaL("..................................")
   Para i <- 1 ate TAMANHO faca
      EscrevaL()
      Para j <- 1 ate TAMANHO faca
         Escreva(M[i,j]:6)
      FimPara
      EscrevaL()
   FimPara
   EscrevaL("..................................")
Fimalgoritmo

adicionado 12 minutos depois

Segue alternativa para o algoritmo de ordenação baseada num método bem popular de ordenação.

   Para i <- 1 ate TAMANHO faca
      Para j <- 1 ate TAMANHO-1 faca
         para k <- j+1 ate TAMANHO faca
            Se M[i,j] > M[i,k] entao
               aux <- M[i,j]
               M[i,j] <- M[i,k]
               M[i,k] <- aux
            FimSe
         FimPara
      FimPara
   FimPara

Ou seja: é basicamente o método tradicional de ordenação de vetores... como é um vetor de vetores (matriz), será feita uma ordenação para cada vetor desse vetor (que no caso representa uma linha).

MATEUS GOMES85 · 11 de outubro de 2019

@Simon Viegas Valeu muito a explicação Simon! Tava tentando acertar como se declarava uma constante e nao encontrei nenhuma referência nos meus mateirais..

Muito obrigado pelos esclarecimentos. Foi muito proveitoso pra mim esses diálogos.