VisualG Maior número entre um conjunto de inteiros

Eli Almeida · 15 de março de 2023

Se alguém puder ajudar, estou estudando portugol aos poucos, por isso, não

me aprofundei bem nesses assuntos ainda. Mas preciso entregar essas atividades até amanhã

2)Escreva um algoritmo que encontre o quinto número maior que 1000, cuja divisão
por 11 tenha resto 5

Não sei como começar essa 2° questão.

3) Ler 10 números inteiros, ao final mostrar o número maior.

Fiz essa questão desse jeito, mas não sei se está certo :

Var
   // Seção de Declarações das variáveis
   num1,num2,num3,num4,num5,num6,num7,num8,num9,num10:inteiro

Inicio
   // Seção de Comandos, procedimento, funções, operadores, etc...
   escreval (" Informe dez números inteiros")
   leia(num1,num2,num3,num4,num5,num6,num7,num8,num9,num10)
   se (num1>num2) e (num1 >3) e (num1>num4) e (num1>num5) e (num1>num6) e (num1>num7) e (num1>num8) e (num1>num9) e (num1>10) então
      escreval (" O primeiro número é o maior")
   senao
      se (num2>num1) e (num2 >3) e (num2>num4) e (num2>num5) e (num2>num6) e (num2>num7) e (num2>num8) e (num2>num9) e (num2>10) então
         escreval (" O segundo número é o maior")
      senao
         se (num3>num1) e (num3 >2) e (num3>num4) e (num3>num5) e (num3>num6) e (num3>num7) e (num3>num8) e (num3>num9) e (num3>10) então
            escreval (" O terceiro número é o maior")
         senao
            se (num4>num1) e (num4 >2) e (num4>num3) e (num4>num5) e (num4>num6) e (num4>num7) e (num4>num8) e (num4>num9) e (num4>10) então
               escreval (" O quarto número é o maior")
            senao
               se (num5>num1) e (num5 >2) e (num5>num3) e (num5>num4) e (num5>num6) e (num5>num7) e (num5>num8) e (num5>num9) e (num5>10) então
                  escreval (" O quinto número é o maior")
               senao
                  se  (num6>num1) e (num6 >2) e (num6>num3) e (num6>num4) e (num6>num5) e (num6>num7) e (num6>num8) e (num6>num9) e (num6>10) então
                     escreval (" O sexto número é o maior")
                  senao
                     se  (num7>num1) e (num7 >2) e (num7>num3) e (num7>num4) e (num7>num5) e (num7>num6) e (num7>num8) e (num7>num9) e (num7>10) então
                        escreval (" O sétimo número é o maior")
                     senao
                        se  (num8>num1) e (num8 >2) e (num8>num3) e (num8>num4) e (num8>num5) e (num8>num6) e (num8>num7) e (num8>num9) e (num8>10) então
                           escreval (" O oitavo número é o maior")
                        senao
                           se (num9>num1) e (num9 >2) e (num9>num3) e (num9>num4) e (num9>num5) e (num9>num6) e (num9>num7) e (num9>num8) e (num5>10) então
                              escreval (" O nono número é o maior")
                           senao
                              se (num10>num1) e (num10 >2) e (num10>num3) e (num10>num4) e (num10>num5) e (num10>num6) e (num10>num7) e (num10>num9) então
                                 escreval (" O décimo primeiro número é o maior")
                              senao
                              fimse
                           fimse
                        fimse
                     fimse
                  fimse
               fimse
            fimse
         fimse
      fimse
   fimse

4) Faça um programa que leia um vetor de dez posições. Em seguida, retire os valores
nulos e negativos e imprima os números que restaram.

Fiz essa 4° questão desse jeito, não sei se está certa :

Var
// Seção de Declarações das variáveis 
v: vetor [1..10] de inteiro
c:inteiro

Inicio
// Seção de Comandos, procedimento, funções, operadores, etc... 
para c <- 1 ate 10 faca
 se (c <> 0) e (c > 0) então
  escreval (c)
  senao
  fimse
 fimpara

Fimalgoritmo

5) Construa um algoritmo que leia uma quantidade indeterminada de números inteiros
e identifique qual foi o maior número digitado. O final da série de números digitada
deve ser indicado pela entrada de -1.

Não faço a mínima ideia de como começar essa 5° questão

devair1010 · 15 de março de 2023

@Eli Almeidaa essa 3ª aí , está compilando , mas não dá o resultado desejado , e mesmo para iniciantes esse código não está nada bom , e então , por que você não experimenta fazer do modo tradicional , que seria usar um Loop "laço de repetição" , que diminuiria muito a quantidade de linhas do seu código , pois do jeito que está , tem muita coisa desnecessária , vai dar muito trabalho , para fazer as comparações e ficar imaginando um monte de possibilidade que podem acontecer no algoritmo , além de que o código final teria 3 kb de tamanho e em um pc que tem muita memória , esses 3 Kb é nada , mas se você quiser colocar esse código em um micro controlador pic 16F84A que tem apenas 1 Kb de memória esse programa não serviria , pois não caberia na memória dele , mas se você usar os comando apropriados como loop's e vetores e outros , esse mesmo algoritmo , sem os comentários , teria apenas 1 Kb de tamanho e caberia nesse micro controlador PIC16F84A :

Algoritmo "o maiorrr"
Var
  maior , num , i , aux : inteiro
  ordinal               : vetor[1..10] de caractere
Inicio
  ordinal[ 1] := "Primeiro"
  ordinal[ 2] := "Segundo "
  ordinal[ 3] := "Terceiro"
  ordinal[ 4] := "Quarto"
  ordinal[ 5] := "Quinto"   // cada nUmero tem seu respectivo Ordinal
  ordinal[ 6] := "Sexto "
  ordinal[ 7] := "Sétimo"
  ordinal[ 8] := "Oitavo"
  ordinal[ 9] := "Nono"
  ordinal[10] := "Décimo"
  
  aux := 1
  
  escreval (" Informe dez números inteiros")
  para i de 1 ate 10 faca  // Loop com dez repetiCOes
    leia( num )            // le o numero digitado
    se num > maior então   // verifica se o nUmero digitado Eh maior
                           // que a var "maior"  que foi criada
                           // e inicializada com valor zero , e se sim
      maior := num         // a var "maior" recebe o valor desse nUm
                           // que Eh maior
      aux := i             // var auxiliar armazena a posiCAo na sequencia
                           // de nUmeros digitados para usar o cardinaL
    fimse                  // fim da comparaCAo
  fimpara                  // fim do Loop "para / fimpara"
  escreval()
  escreval("O ",ordinal[ aux ]," número ",maior," , é o Maior . . . !" )
  escreval()
Fimalgoritmo

e essa 5 , pode ser com repita e também com enquanto

devair1010 · 15 de março de 2023

4 horas atrás, Eli Almeidaa disse:

4) Faça um programa que leia um vetor de dez posições. Em seguida, retire os valores
nulos e negativos e imprima os números que restaram.

Fiz essa 4° questão desse jeito, não sei se está certa :

@Eli Almeidaa não está certa pois você está comparando o valor da variável c que não nada a ver com os números no vetor , que são outra coisa , e quando o enunciado diz para ler um vetor , significa que precisar usar o comando leia , pegando os dados do teclado , e colocar no vetor , e essa comparação aqui , não precisa de duas comparações

se (c <> 0) e (c > 0) então // se c > 0 Eh lOgico que Eh diferente de zero
  escreval (c)
senao                       // o que faz esse "senao" aqui ? , nada .
fimse
// que seria assim :  
se c > 0 então              // se for maior que zero então não Eh neg e nem nulo
  escreval (c)              // e sim positivo
fimse

e no enunciado tem três partes ,

1ª parte - pegar os números digitados e colocar no vetor

2ª parte - remover os números inválidos , os nulos e os negativos , do vetor

3ª parte - rescrever os números , válidos , se houver , que restarem no vetor

Eli Almeida · 15 de março de 2023

@devair1010 , como ficaria essa questão 4?

Midori · 15 de março de 2023

A questão do título também é com loop. Como o enunciado não especifica mais nada entendo que deve terminar quando chegar nas condições: Quinto número maior que 1000 e com resto 5 para a divisão por 11 (o número 1006 p.ex).

Para pegar o resto da divisão tem o operador Mod e o teste pode ser assim: Se((Num > 1000) E (Num Mod 11 = 5)).

Você pode colocar um contador nessa condição para depois verificar se chegou a 5.

devair1010 · 15 de março de 2023

@Eli Almeidaa no seu código você não está pegando os números e já vai comparando , mas não é esse número da variável c , não , e imagino um código parecido com esse seu , e que tem alguns comandos a mais , e é apenas um exemplo de como fazer , mas você pode escolher outras formas de fazer , que melhor lhe convenha e te seja mais favorável ,

Algoritmo "remover nulos e negativos"
// 4) Faça um programa que leia um vetor de dez posições. Em seguida,
// retire os valores nulos e negativos e imprima os números que restaram.
Var
  v     : vetor [1..10] de inteiro
  c , j : inteiro
Inicio
  para c <- 1 ate 10 faca // esse Loop vai apenas ler os dez nUmeros
    leia( v[ c ] )        // e coolcar no vetor
  fimpara
  j <- 1                  // j será pos onde guardar os vAlidos
  para c <- 1 ate 10 faca // esse vai pesquisar no vetor
    se v[c] > 0 então     // encontrou nUmero vAlido
      v[j] := v[c]        // recoloca ele no vetor na nova posiCAo
      j := j + 1          // incrementa posiCAo para outro nUmero
    fimse
  fimpara
  para c de 1 ate (j-1) faca
    escreval( c,"º ", v[c] )
  fimpara
Fimalgoritmo

e poste uma versão sua , que atenda o que pede o enunciado , para vermos como ficou .

Eli Almeida · 15 de março de 2023

@Midori , como coloca esse contador?

Eli Almeida · 16 de março de 2023

@devair1010 , achei esse modo que você fez um pouco difícil. Estou tentando

fazer dessa forma, mas não está funcionando. O que você acha que precisa colocar ?

// Descrição : Faça um programa que leia um vetor de dez posições. Em seguida, retire os valores
nulos e negativos e imprima os números que restaram.

v     : vetor [1..10] de inteiro
 c:inteiro
Inicio
// Seção de Comandos, procedimento, funções, operadores, etc... 
para c <- 1 ate 10 faca
leia( v[ c ] )
se v[c] > 0 então
escreval (v[c])
fimse
Fimalgoritmo

devair1010 · 16 de março de 2023

@Eli Almeidaa observe o que pede o enunciado , e esse código não está seguindo o enunciado , pois ele diz , primeiro pega os números e coloca no vetor , e só depois remover os inválidos , e depois escrever os número que restaram no vetor , e isso é para o estudante treinar a usar vetores , pois desse modo como pede o enunciado você vai precisar usar o vetor constantemente , e desse modo como você está fazendo , pode funcionar sim , mas você nem precisaria usar vetor , e não aprenderia nada de vetores , é preciso seguir o diz o enunciado , ele é quem manda , e se você não vai segui lo , então estará fazendo por sua conta . e nem precisaria de um enunciado .

e o resultado na tela fica todo desajeitado , misturando o que foi digitado pelo que o programa escreve logo em seguida ,

seu código tem erros falta comandos nrcesários , que você não colocou

Algoritmo "numeros positivos"
var
  v : vetor [1..10] de inteiro
  i : inteiro
Inicio
  para i <- 1 ate 10 faca
    leia( v[ i ] )
    se v[i] > 0 então
      escreval (v[i])
    fimse
  fimpara   // faltou esse 
Fimalgoritmo

Eli Almeida · 16 de março de 2023

@devair1010 , por que você coloca

j := j + 1

e

para c de 1 ate (j-1) faça

no código acima ?

devair1010 · 16 de março de 2023

@Eli Almeidaa a variável j está servindo como contador de números válidos e também para apontar em qual posição do vetor irá colocar o próximo número válido , por isso a cada número válido encontrado a variável j é incrementada em uma unidade ,

j <- j + 1
     
  ou pode ser assim tambEm que a mesmo coisa

j := j + 1

ou seja soma se mais um ao valor de j que começou em 1 apontando para a primeira posição do vetor v , e no Loop "para / fimpara" você pode escrever dessas três formas

// esse sImbolo ( <- ) Eh igual a esse ( := ) e no loop esse ( de )

para c de 1 ate (j-1) faça // o j-1 serve como limite  do loop

para c <- 1 ate (j-1) faça // sendo que j guarda a qtd de vAlidos
                           // e Eh incrementado em seguida
para c := 1 ate (j-1) faça // assim na saIda tem uma unidade a mais
                           // por isso o j-1 para a contaGem ficar certa

e o compilador vai entender o que significa e funcionar certo .

Midori · 16 de março de 2023

17 horas atrás, Eli Almeidaa disse:

@Midori , como coloca esse contador?

Um contador nada mais é que qualquer variável que pode ser incrementada ou decrementada. Normalmente é usado em loops.

Incremento é quando aumenta o valor, p.ex: i <- i + 1. E o decremento: i <- i - 1.

A condição Se que falei será verdadeira para o que o enunciado pede. Então dentro dela vai esse contador que pode ser verificado depois se chegou a cinco (o quinto número).

Eli Almeida · 17 de março de 2023

@Midori, estou tentando fazer dessa forma, mas não está funcionando. Saberia o motivo?

//Descrição: 2) Escreva um algoritmo que encontre o quinto número maior que 1000, cuja divisão por 11 tenha resto 5

num,i:inteiro

Inicio
   // Seção de Comandos, procedimento, funções, operadores, etc...
 i<-1000
para i de 1000 ate < 5 faca
Se(i > 1000) E ( i Mod 11 = 5) então
senao
fimse

 fimpara
 i<- i+1
  escreval(i)

devair1010 · 17 de março de 2023

@Eli Almeidaa . Qual erro está dando ? , e você está escrevendo os comandos de forma errada , assim não vai funcionar mesmo não ,

Para

para i de 1000 ate < 5 faca ,

Esse não faz parte da sintaxe do VisualG , não .

para i de 1000 ate 1500 faca

Esse sim , tem a sintaxe certa

e quando faz uma comparação precisa colocar o que é para o compilador fazer , e ali você colocou o "se" "senao" "fimse", mas não colocou nada dentro , e aí o compilador não vai fazer nada mesmo .

Midori · 17 de março de 2023

@Eli Almeidaa Antes de começar a escrever o código é preciso entender quais passos seguir para chegar na solução.

Seu programa deve ler o número indefinidamente até, pela quinta vez, ser maior que 1000 e com resto 5 para a divisão por 11. O comando Para não é o mais adequado já que ele repete uma sequencia até chegar a um determinado valor. O outro laço para esse caso pode ser o Repita, p.ex,

Repita
    Leia(Num)
Ate Num >= 5

Assim vai ficar em loop até a entrada receber um valor maior ou igual a 5. No seu é quase isso já que você deve pegar a entrada e a partir dela testar se chega nas condições pedida no enunciado. Para isso tem aquele Se que comentei. E o Repita não é para o valor da entrada, mas para um contador que mostre que chegou na condição cinco vezes.

Eli Almeida · 17 de março de 2023

@Midori e @devair1010, será que estaria certo dessa forma agora?

Var
   // Seção de Declarações das variáveis
   num:inteiro

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

escreval (" Informe um número")
   leia (num)
   repita num ate Num > = 5
      Se(num > 1000) E (Num Mod 11 = 5)então
         escreval (" O número é " , num)
      senao
         escreval (" Não é esse")
      fimse
fimalgoritmo

Midori · 17 de março de 2023

@Eli Almeidaa Testou o seu código? Ele apresenta erro de execução e também não está como sugeri. O Repita é mais simples do que tentou fazer. A leitura tem que ficar dentro do loop ou será feita apenas uma vez.

Algoritmo "Numero"
Var
    Num:    Inteiro
    Conta:  Inteiro
Inicio
    Repita
        Leia(Num)
        Se(Num > 1000) E (Num Mod 11 = 5) então
            Conta <- Conta + 1
        FimSe
    Ate Conta >= 5
    Escreval("O numero e ", Num)
Fimalgoritmo

Eli Almeida · 17 de março de 2023

@Midori, acho que entendi agora. 1006 seria o primeiro número maior que 1000 que quando dividido por 11 restam 5 e 1050 seria o quinto número que quando dividido por 11 restam 5, que é o que a questão pede. Notei uma coisa: quando digita primeiramente 1050 por que não encerra o programa, já que 1050 seria o que ele pede?

Outra coisa: nesse caso, não precisa colocar o "escreval" , desse jeito, aí, que você fez já está de acordo?

Outra dúvida: por que você coloca

Conta <- Conta + 1

?

JorgeGus · 18 de março de 2023

No exercício 2 tenho a impressão que é só começar a contar a partir de 1000, sem a necessidade de ler nenhum número, pelo menos o enunciado não diz nada sobre sobre soliciar um número inicial.

Midori · 18 de março de 2023

@Eli Almeidaa O que o @JorgeGus comentou faz sentido. Dá para resolver sem loop, mas uma das formas com contador é iniciado com 1001 para fazer loop até o primeiro. E depois um cálculo para mostrar o quinto que é 1050 como comentou,

Algoritmo "Numero"
Var
    Num: Inteiro
Inicio
    Num <- 1001
    Repita
        Num <- Num + 1
    Ate (Num Mod 11 = 5)
    Escreval("O Numero e ", Num + 11 * 4)
FimAlgoritmo

Eli Almeida · 18 de março de 2023

10 horas atrás, Midori disse:
@Eli Almeidaa O que o @JorgeGus comentou faz sentido. Dá para resolver sem loop, mas uma das formas com contador é iniciado com 1001 para fazer loop até o primeiro. E depois um cálculo para mostrar o quinto que é 1050 como comentou,
Algoritmo "Numero"
Var
    Num: Inteiro
Inicio
    Num <- 1001
    Repita
        Num <- Num + 1
    Ate (Num Mod 11 = 5)
    Escreval("O Numero e ", Num + 11 * 4)
FimAlgoritmo

@Midori,Vou deixar dessa forma aí mesmo.Obrigada

Eli Almeida · 19 de março de 2023

Em 15/03/2023 às 01:39, devair1010 disse:
@Eli Almeidaa essa 3ª aí , está compilando , mas não dá o resultado desejado , e mesmo para iniciantes esse código não está nada bom , e então , por que você não experimenta fazer do modo tradicional , que seria usar um Loop "laço de repetição" , que diminuiria muito a quantidade de linhas do seu código , pois do jeito que está , tem muita coisa desnecessária , vai dar muito trabalho , para fazer as comparações e ficar imaginando um monte de possibilidade que podem acontecer no algoritmo , além de que o código final teria 3 kb de tamanho e em um pc que tem muita memória , esses 3 Kb é nada , mas se você quiser colocar esse código em um micro controlador pic 16F84A que tem apenas 1 Kb de memória esse programa não serviria , pois não caberia na memória dele , mas se você usar os comando apropriados como loop's e vetores e outros , esse mesmo algoritmo , sem os comentários , teria apenas 1 Kb de tamanho e caberia nesse micro controlador PIC16F84A :
Algoritmo "o maiorrr"
Var
  maior , num , i , aux : inteiro
  ordinal               : vetor[1..10] de caractere
Inicio
  ordinal[ 1] := "Primeiro"
  ordinal[ 2] := "Segundo "
  ordinal[ 3] := "Terceiro"
  ordinal[ 4] := "Quarto"
  ordinal[ 5] := "Quinto"   // cada nUmero tem seu respectivo Ordinal
  ordinal[ 6] := "Sexto "
  ordinal[ 7] := "Sétimo"
  ordinal[ 8] := "Oitavo"
  ordinal[ 9] := "Nono"
  ordinal[10] := "Décimo"
  
  aux := 1
  
  escreval (" Informe dez números inteiros")
  para i de 1 ate 10 faca  // Loop com dez repetiCOes
    leia( num )            // le o numero digitado
    se num > maior então   // verifica se o nUmero digitado Eh maior
                           // que a var "maior"  que foi criada
                           // e inicializada com valor zero , e se sim
      maior := num         // a var "maior" recebe o valor desse nUm
                           // que Eh maior
      aux := i             // var auxiliar armazena a posiCAo na sequencia
                           // de nUmeros digitados para usar o cardinaL
    fimse                  // fim da comparaCAo
  fimpara                  // fim do Loop "para / fimpara"
  escreval()
  escreval("O ",ordinal[ aux ]," número ",maior," , é o Maior . . . !" )
  escreval()
Fimalgoritmo
e essa 5 , pode ser com repita e também com enquanto

@devair1010, esse aux : = 1 que você coloca primeiro acima é opcional? porque se tirar ele o programa roda. E por que coloca aux recebe 1?

devair1010 · 19 de março de 2023

8 horas atrás, Eli Almeidaa disse:

esse aux : = 1 que você coloca primeiro acima é opcional?

@Eli Almeidaa não , não é opciomal , não , creio que ninguém coloca comandos desnecessários em um programa , pois além de não ajudar em nada e perder tempo escrever tal comando , ainda atrapalha pois vai aumentar o espaço na memória , e então tudo que está escrito no código é necessário e se remover ou modificar alguma coisa vai fazer falta , pois o código até pode compilar e funcionar , mas vai ter resultado errado ,

8 horas atrás, Eli Almeidaa disse:

E por que coloca aux recebe 1?

se você estiver se referindo a esse comando aqui

aux := 1

esse é o modo de adicionar valor a uma variável no visualG , e recebe 1 porque a primeira posição no vetor de OrdinaL é a posição 1 , onde tem o nome do ordinal do número 1 , e se você remover esse comando , a var aux não vai receber o valor 1 e conterá então o valor 0 e os ordinais ficariam errados .

mas se você se refere ao texto "aux recebe 1" , isso pode ser um comentário no algoritmo que são colocado depois desse dois sinais //

Simon Viegas · 19 de março de 2023

Em 18/03/2023 às 11:09, Midori disse:
@Eli Almeidaa, o que o @JorgeGus comentou faz sentido. Dá para resolver sem loop, mas uma das formas com contador é iniciado com 1001 para fazer loop até o primeiro. E depois um cálculo para mostrar o quinto que é 1050 como comentou
Algoritmo "Numero"
Var
    Num: Inteiro
Inicio
    Num <- 1001
    Repita
        Num <- Num + 1
    Ate (Num Mod 11 = 5)
    Escreval("O Numero e ", Num + 11 * 4)
FimAlgoritmo

O primeiro número é o 1001 (já que é "maior que 1000"), mas algoritmo aí está começando com número 1002 (uma inconformidade). Basta inicializar o num com 1000 mesmo.

Só para ficar claro: e se 1001 dividido por 11 desse resto 5? Para exemplificar, troque o 11 por 12 e teste inicializando com 1001 e com 1000 e vejam o que acontece.

Simon Viegas · 19 de março de 2023

Só tentando aprofundar um pouco...

Perdão se vou ser ser prolixo, e para quem não me conhece, é o meu jeito mesmo... Tô tentando melhorar.. mas eu não consigo ser mais sintético e aproveitar para treinar a escrita. Vamos lá:

11 horas atrás, Eli Almeidaa disse:

@devair1010, esse aux : = 1 que você coloca primeiro acima é opcional? Porque se tirar ele o programa roda

Nesse caso, são duas coisas distintas: ser opcional e rodar.

Rodar está intrinsecamente relacionado à sintaxe, ou seja, as regras de como um código pode ser escrito no VisualG.

Já ser opcional, estaria relacionado à lógica, se os conjuntos de passos implementados estão satisfazendo ao enunciado.

São coisas ligadas, mas é preciso entender que são distintas. O programa roda pois não seria requisito da sintaxe. Essa linha é uma instrução solta... É apenas um comando como qualquer outro.

Já ser opcional ou não, vou comentar mais abaixo.

11 horas atrás, Eli Almeidaa disse:

E por que coloca aux recebe 1?

Pode ser necessário ou não. Tem a ver também com o que comento lá mais abaixo.

2 horas atrás, devair1010 disse:

creio que ninguém coloca comandos desnecessários em um programa

Entendo o contrário. A ideia seria buscar seguir um bons padrões de projetos... seria evitar que ocorra situações como essa. Meio que vai depender do contexto...

Tipo:

2 horas atrás, devair1010 disse:

então tudo que está escrito no código é necessário

Não é que "é", mas talvez seria "deveria ser". Lá também mais abaixo tento demonstra que não seria necessário!

A ideia seria tentarmos implementar um melhor código possível (sempre para o contexto dele). Só para simplificar: o algoritmo pode está incompleto ou mesmo não tão bem otimizado, por exemplo. Nem por isso estaria "errado". Deixar ou não deixar essa atualização do aux não necessariamente seria um problema. Pode ser "tanto faz".

2 horas atrás, devair1010 disse:

esse é o modo de adicionar valor a uma variável no visualG, e recebe 1 porque a primeira posição no vetor de OrdinaL é a posição 1 , onde tem o nome do ordinal do número 1 , e se você remover esse comando , a var aux não vai receber o valor 1 e conterá então o valor 0 e os ordinais ficariam errados .

Como diria o comediante: "mais ou menos, mais ou menos"... . De um modo geral, meio que só iria dar problema em uma única situação: se todos os números digitados forem menor ou igual a 0. Caso contrário, o aux vai receber um valor válido, pois algum número iria fazer atualizar o aux.

ADENDO: poderia resumir a postagem toda a essa linha acima. Mas queria/quero apenas detalhar os pontos que penso.

IMPORTANTE: lembrando que o VisualG já atribui um valor inicial a todas a variáveis globais, portanto, todas as variáveis do tipo inteiro automaticamente já começam com 0. Entendam que isso é um funcionalidade, ou seja, entendo que não era para ser assim, apenas o "desenvolvedor do VisualG achou legal fazer isso". O Pascal, pai do VisualG, e acho que o Delphi também, têm a mesma característica de inicializar variáveis globais, mas nas principais linguagem do mercado isso meio que não ocorre!!! Seria preciso sempre* inicializar manualmente em algum momento, se não o código não compila ou ficam apresentando alertas (warning) informando que pode dar problemas. (Pois pode dar mesmo! A medida que um projeto cresce, fica mais difícil identificar a necessidade.. o simples fato de inicializar, ajuda a minimizar erros.)

Então, vejamos o código:

11 horas atrás, Eli Almeidaa disse:

  ...
  aux := 1
  escreval (" Informe dez números inteiros")
    
  para i de 1 ate 10 faca
    leia( num )
    se num > maior então
      maior := num
      aux := i
    fimse
  fimpara
        
  escreval()
  escreval("O ",ordinal[ aux ]," número ",maior," , é o Maior . . . !" )
  ...

Vejam como é belo (espero que eu não erre em algo, rs): observem lá que a variável aux pode receber uma atribuição de valor dentro de uma estrutura de seleção (se), certo? E que, por sua vez, também está dentro de uma estrutura de repetição (para), ou seja:

Citação

A única forma do aux ficar sem um valor (novo) seria se o laço não começasse (mas já sabemos que sempre vai), ou se a expressão da estrutura de seleção nunca seja verdadeira (que "nunca entre no se"), que analisado vemos que bastaria ser todos os números menores ou igual a 0 para não entrar.

Em relação à variável em si, não tem problema algum, mas o que poderia dar errado? Ali na última linha do código está utilizando essa tal variável aux, e, caso ocorra o que citei (só ter valores menores ou igual a 0), essa variável aux estaria com o seu valor inicial, que é o 0, lembram?... Logo, seria o mesmo que fazer:

ordinal[0]

Sacam? A necessidade de inicializar ou não, nesse caso, está apenas na possibilidade de está com um valor válido para o contexto, ou seja, não haveria erro de sintaxe, apenas erro de lógica.

Especificamente para um caso, essa posição não existiria, ocasionando um erro de execução (tentar achar uma posição de vetor que não existe). Eventualmente até poderia existir, por exemplo, passando o vetor para começar do 0. Indo de 0 a 9 (em vez de 1 a 10). Não ocorreria erro algum na execução... só que o resultado ficaria errado. Oh! se digitar só zero, ficaria parcialmente certo!, pois iria informar que o primeiro era o maior .

Vejam que estamos ignorando a possibilidade de números maior repetidos!!!!

VAMOS MAIS ALÉM:

Tecnicamente esse aux := 1 pode não ser necessário mesmo, mas é que existem outros probleminhas que precisariam ser resolvidos lá na lógica...

Enunciado:

Em 14/03/2023 às 22:54, Eli Almeidaa disse:

3) Ler 10 números inteiros, ao final mostrar o número maior.

Observem que não tem nada a ver com "informar a posição por extenso ou a posição em ordinal", sacam? Foi um subproblema que foi inserido além do que foi pedido.

A minha sugestão seria: primeiro se atentar ao enunciado, depois pensar nas possíveis melhorias ou tentativas de ir além dele.

Vejam um trecho do código:

Em 14/03/2023 às 22:54, Eli Almeidaa disse:

Inicio
   // Seção de Comandos, procedimento, funções, operadores, etc...
   escreval (" Informe dez números inteiros")
   leia(num1,num2,num3,num4,num5,num6,num7,num8,num9,num10)
   se (num1>num2) e (num1 >3) e (num1>num4) e (num1>num5) e (num1>num6) e (num1>num7) e (num1>num8) e (num1>num9) e (num1>10) então
      escreval (" O primeiro número é o maior")
   senao
      se (num2>num1) e (num2 >3) e (num2>num4) e (num2>num5) e (num2>num6) e (num2>num7) e (num2>num8) e (num2>num9) e (num2>10) então
         escreval (" O segundo número é o maior")
      senao

Um problema maior aí está nesse balaio de gato de se e não no texto de resultado. Pode funciona assim? Pode, mas no mínimo fica complexo de mais para algo que seria simples.

AQUI ABAIXO VOU DEMONSTRAR UMA METODOLOGIA DE COMO IMPLEMENTAR UMA CORREÇÃO/SOLUÇÃO

Sobre:

Em 14/03/2023 às 22:54, Eli Almeidaa disse:

   escreval (" Informe dez números inteiros")
   leia(num1,num2,num3,num4,num5,num6,num7,num8,num9,num10)

Pode ser assim? Pode, mas não seria comum. Poderia até informar para "separar os números por espaços".

Aqui em vez de ler todas os valores em uma linha, leria por um laço. Meu código começaria assim:

algoritmo "Maior número inteiro"
//3) Ler 10 números inteiros, ao final mostrar o número maior.
var
   num, i : inteiro
inicio
   escrevaL("Informe 10 números inteiro")
   para i de 1 ate 10 faca
      escreva ("Número ", i:2, ": ")
      leia(num)
   fimPara


fimAlgoritmo

Também escolheria o para, pois temos uma quantidade fixa de repetições. Veja o teste:

Para chegar nesse resultado, eu testei alguns vezes e fui ajustando... Para facilitar o processo, tem esse recurso bem bacana:

Depois só rodar o código. Lembrar de desativar depois!

Tá! Implementei uma estrutura para ler os dados, agora vou implementar mais alguma coisa. Vou lá implementar a verificação do maior.

algoritmo "Maior número inteiro"
//3) Ler 10 números inteiros, ao final mostrar o número maior.
var
   num, i : inteiro
   maior : inteiro
inicio
   escrevaL("Informe 10 números inteiro")
   
   para i de 1 ate 10 faca
      escreva ("Número ", i:2, ": ")
      leia(num)
      
       se (num > maior) então
            maior <- num
       fimSe
   fimPara
   
   escrevaL()
   escrevaL("O maior número informado foi o ", maior:1)
fimAlgoritmo

Acho que cheguei ao fim...

Hum! Vamos nos aprofundar... tentei analisar o problema. Venha cá: qual o valor de maior na primeira verificação? Eu não atribui nenhum valor para ele.

Testei com números negativos:

(deixei três pois testei na mão)

Ué? Por que deu 0? Então, já "aprendemos" que o VisualG inicializa as variáveis numéricas com zero, logo, maior vale zero... e, logo, nenhum dos números que informei foi maior que o maior..., logo, continuou com o valor inicial, que é zero!

Precisamos resolver esse problema (que uma das ideias de quem propôs o enunciado era justamente se aprofundar um pouco e aprender coisas de um modo geral, inclusive aprender a aprender).

Uma alternativa seria inicializar maior com um número baixo.

   maior <- (-999999)
     
   para i de 1 ate 10 faca
      escreva ("Número ", i:2, ": ")
      ALEATORIO -100, -1
      leia(num)
      ALEATORIO OFF

      se (num > maior) então
         maior <- num
      fimSe
   fimPara

(propositalmente inseri o ALEATORIO no código... em vez de "para que ser isso?", qual tal pesquisar e descobrir? Saca? Caso ainda tenha dúvidas, só perguntar)

Parece que funcionou. Matematicamente eu já sei que vai funcionar com qualquer valor inteiro maior ou igual a -999999. (Ou não?).

Se informar um número ainda menor? Esse problema vai continuar existindo... Por isso que vai do contexto. Não precisa ficar sempre perfeito... mas podemos tentar ir cada vez mais se aproximando de algo ideal. Que tal descobrir qual o menor número inteiro do VisualG e usar lá?

Outra solução seria inicializar o maior com o primeiro valor.

   para i de 1 ate 10 faca
      escreva ("Número ", i:2, ": ")
      ALEATORIO -100, 100
      leia(num)
      ALEATORIO OFF

      se (i > 1) então
         se (num > maior) então
            maior <- num
         fimSe
      senao
         maior <- num
      fimSe
   fimPara

Parece que funcionou também. Esse código poderia ser o que eu iria entregar. Agora perceba (feat Prof. Procópio): a forma de "inicializar com o primeiro" poderia ser feita de diversas outras formas também... isso seria um subproblema, ou seja, eu já "imagino que isso funciona", mas qual a melhor forma de implementar? Vai se aprofundando.. ou não... depende.....

Agora: de onde tirei que "poderia inicializar com um valor bem baixo" ou "que poderia inicializar com o primeiro". Man, quase certeza que vi isso em algum lugar... arrisco a dizer que mais de 90% da população mundial ocorreu o mesmo. Parece bobo para que já viu, mas é complexo para quem tá cru. O importante é entender qual o raciocínio envolvido. Acho que lembro de ter batido cabeça com meu coloca de faculdade, e ele me deu a resposta. Mas acho que ele me falou que eventualmente viu essas possíveis soluções em algum outro lugar (ou inferi isso). Não vejo problema algum. É normal. Muitas das soluções que damos podem ser baseadas em soluções já tivemos contato ou que adaptamos. O importante assimilar.

Solução até aqui:

algoritmo "Maior número inteiro"
//3) Ler 10 números inteiros, ao final mostrar o número maior.
var
   num, i : inteiro
   maior : inteiro
inicio
   escrevaL("Informe 10 números inteiro")
   escrevaL()

   para i de 1 ate 10 faca
      escreva ("Número ", i:2, ": ")
      ALEATORIO -100, 100
      leia(num)
      ALEATORIO OFF

      se (i > 1) então
         se (num > maior) então
            maior <- num
         fimSe
      senao
         maior <- num
      fimSe
   fimPara

   escrevaL()
   escrevaL("O maior número informado foi o ", maior:1)
fimAlgoritmo

Vamos dizer que já temos uma solução final. Agora, como treinamento, vou tentar inserir a melhoria para exibir por extenso. Mas observem que isso está um pouco ALÉM do enunciado.

Declarei uma variável e coloquei para receber o valor de i.

      se (i > 1) então
         se (num > maior) então
            maior <- num
            posMaior <- i
         fimSe
      senao
         maior <- num
      fimSe

Só fiz isso... para testar, vejam que dá para ver ali no lado no VisualG. Oh! lá marcando a 4 posição.

Versão "final":

algoritmo "Maior número inteiro"
//3) Ler 10 números inteiros, ao final mostrar o número maior.
var
   num, i : inteiro
   maior, posMaior : inteiro
   ordinal : vetor [1..10] de caractere
inicio
   ordinal[ 1] <- "primeira"
   ordinal[ 2] <- "segunda"
   ordinal[ 3] <- "terceira"
   ordinal[ 4] <- "quarta"
   ordinal[ 5] <- "quinta"
   ordinal[ 6] <- "sexta"
   ordinal[ 7] <- "sétima"
   ordinal[ 8] <- "oitava"
   ordinal[ 9] <- "nona"
   ordinal[10] <- "décima"

   escrevaL("Informe 10 números inteiros")
   escrevaL()

   para i de 1 ate 10 faca
      escreva ("Número ", i:2, ": ")
      //ALEATORIO -100, 100
      leia(num)
      //ALEATORIO OFF

      se (i > 1) então
         se (num > maior) então
            maior <- num
            posMaior <- i
         fimSe
      senao
         maior <- num
         posMaior <- 1
      fimSe
   fimPara

   escrevaL()
   escrevaL("O maior número informado foi o ", maior:1)
   escrevaL("Está na ", ordinal[posMaior], " posição")
fimAlgoritmo

Adendo 1:

Observem que, no VisualG, tecnicamente, para esse código acima, não precisou inicializar a variável posMaior (o mesmo que seria o aux). OU ele vai ficar com o 1, caso o primeiro seja o maior ou se todos os números forem iguais ao primeiro. OU vai ficar com outro valor de posição correspondente ao maior. Sempre vai ser atribuindo um novo valor para ele.

Adendo 2:

O posMaior só estaria sendo atualizado dentro de um se (o senao também faz parte), correto? Em algumas linguagens de programação, o compilador poderia identificar esse contexto e informar algo como: "ALERTA: a variável posMaior pode não inicializada". Aí buscaríamos reforçar a lógica para ver a necessidade. Teria compilador que não deixar rodar até que "corrija".

Adendo 3:

Quando o programa cria uma variável, ele meio que apenas "reserva uma espaço de memória e prepara para que aquele espaço armazene dados do tipo dessa variável" no computador. Daí, o que estiver lá nesse pedaço de memória, é o que fica na variável. Isso é um conceito de estrutura de dados. As memórias sempre estão com dados lá. Dizer que "está livre" ou "ocupado" está na abstração, ou seja, o espaço livre seria "aquele que pode ser substituído e utilizável".

Por isso que é "um padrão inicializar a variável", ou seja, dar um valor inicial logo quando cria ou em algum momento oportuno, como no exemplo do @devair1010. Aqui no VisualG isso não é necessário, pois o VisualG já inicializa para as variáveis globais... acho isso errado pois tira a oportunidade de já entender isso desde o início... sei lá.

Por fim, só demonstrar que o VisualG inicializa sozinho:

No C (corrijam-me se estiver engano), as variáveis NÃO são inicializadas. Ficam com o "lixo" que está lá na memória. Meio que pode ocorrer de ficar com o mesmo valor de uma execução anterior do mesmo programa, por exemplo. Pode dá rúim!!!