Simon Viegas

1. Remova esse trecho do código. 2. Lá no ate mude de op para opcao e declare continuar com o tipo caractere. @Luiz Campos, além dos ponto acima. Poste o enunciado completo da questão. O que vai ser feito código depende daqui que foi solicitado para ser feito. Segue um esboço de ajustes/sugestões para poder servir de base: algoritmo "Gerenciador" const TAM = 10 tipo t_paciente = registro idade :inteiro nome :caractere sexo :caractere cpf :caractere telefone :caractere endereco :caractere status :caractere anotacao :caractere relatorio :caractere fimRegistro var pacientes :vetor[1..TAM] de t_paciente codUltimo, codPesquisa :inteiro opcao :caractere continuar :caractere inicio codUltimo <- 0 //no VisualG não precisa, mas deixa para pegar o costume repita LimpaTela() escrevaL("Pacientes cadatrados: ", codUltimo) escreval("Cadastro de Pacientes") escreval("1 - Pacientes ") escreval("2 - Situação ") escreval("3 - Procedimentos ") escreval("4 - Relatórios ") escreval("5 - Fechar sistema ") escreva ("Opção: ") leia(opcao) LimpaTela() se opcao = "1" entao codUltimo <- codUltimo+1 escrevaL("## CADASTRO DE NOVOS PACIENTES ##") escrevaL("Preencha os campos requisitados") escreva ("Nome: ") ALEATORIO ON leia (pacientes.nome[codUltimo]) escreva ("CPF: ") leia (pacientes.cpf[codUltimo]) escreva ("Idade: ") leia (pacientes.idade[codUltimo]) escreva ("Sexo: ") leia (pacientes.sexo[codUltimo]) escreva("Telefone: ") leia (pacientes.telefone[codUltimo]) escreva("Endereço: ") leia (pacientes.endereco[codUltimo]) escreva("Anotação: ") leia (pacientes.anotacao[codUltimo]) escreva("Relatorio: ") leia (pacientes.relatorio[codUltimo]) ALEATORIO OFF escrevaL("") escreva(" Tecle Enter para Voltar ao Menu") leia(continuar) LimpaTela() fimSe se opcao = "2" entao escrevaL("## SITUAÇÃO DE PACIENTES ##") escrevaL("Preencha os campos requisitados") escrevaL("") escreva ("Código do paciente: ") leia(codPesquisa) se ((codPesquisa >= 1) E (codPesquisa <= codUltimo)) entao escrevaL("Situacao: ", pacientes[codPesquisa].relatorio) senao escrevaL("Código inválido") fimSe escrevaL("") escreva(" Tecle Enter para Voltar ao Menu") leia(continuar) fimSe se opcao = "3" entao //Em construção fimSe se opcao = "4" entao //Em construção fimSe se opcao = "5" entao escreval(" Saindo Do Programa . . . !") escreva(" Tecle Enter para Voltar ao Menu") leia(continuar) fimSe ate opcao = "5" fimAlgoritmo Resumo de sugestões: - ajustar os itens 1 e 2, supracitados; - posta o enunciado completo; - ajustar o teu código baseando no código acima.

@julia v, acho que poderia fazer algo assim.. Para as palavras, poderia criar uma matriz de caracteres. A primeira coordenada seria o "índice da palavra" e para segunda coordenada você insere cada letra da palavra. Exemplo: palavras[1,1] = 'B' palavras[1,2] = 'A' palavras[1,3] = 'H' palavras[1,4] = 'I' palavras[1,5] = 'A' Aí implementaria uma lógica para encontrar a posição que vai inserir na matriz principal. Tipo, o i do para indo da primeira posição desejada até o tamanho da palavra. Veja, assim como foi jogando caracteres aleatório para cada posição da matriz, você pode ir jogando cada letra da palavra na linha ou na coluna. Adendo: para facilitar, primeiro você cria a matriz aleatória, depois insere a palavras. Mas depois precisaria inverter, ou seja, primeiro as palavra, depois gera as letras.

@rodrigo junior 1001, imaginei de duas formas: Esboço utilizando um vetor para cada item: algoritmo "Gerenciador de Estoque" //1. O algoritmo deve contemplar o armazenamento de estoque para 5 produtos: //água, refrigerante, vinho, suco e cerveja, podendo estes serem os nomes das //variáveis a serem declaradas para serem mais intuitivas. //2. Uma venda só pode ser realizada se houver saldo positivo em estoque. Caso //contrário, não haveria como entregar o produto ao cliente na venda. //3. Em caso de uma venda ser bem-sucedida, exibir uma mensagem positiva do //processo. Caso contrário, exibir uma mensagem informando que a venda não pode ser efetuada. //4. A escolha do produto deve ser feita a partir de um menu de opções a ser //exibido ao usuário que escolhe a opção desejada para em seguida, informar a //quantidade desejada. //5. Todos os produtos iniciam o algoritmo com um estoque de 10 produtos, e //ao longo das vendas vão sendo reduzidos estes valores, sem a necessidade de //reposição durante a execução, imaginando que seria a única quantidade //possível disponível no momento em que o algoritmo é executado. var nomes :vetor[1..5] de caractere valores :vetor[1..5] de real estoques :vetor[1..5] de inteiro codVenda :inteiro qtdItens :inteiro valorVenda :real inicio nomes[1] <- "Água" valores[1] <- 3.0 estoques[1] <- 10 nomes[2] <- "Vinho" valores[2] <- 27.62 estoques[2] <- 10 repita escrevaL("Menu de opções ") escrevaL("1. Água ") escrevaL("2. Vinho ") escrevaL("3. Refrigerante") escrevaL("4. Suco ") escrevaL("5. Cerveja ") escrevaL escreva ("Digite a opcao de produto: ") leia(codVenda) escreva ("Digite a quantidade desejada: ") leia(qtdItens) valorVenda <- valores[codVenda]*qtdItens escrevaL("") escrevaL("Valor da venda: R$", valorVenda:1:2) escrevaL("") escrevaL("") ate (codVenda = 0) fimAlgoritmo Esboço utilizando vetores de registros: algoritmo "Gerenciador de Estoque" //1. O algoritmo deve contemplar o armazenamento de estoque para 5 produtos: //água, refrigerante, vinho, suco e cerveja, podendo estes serem os nomes das //variáveis a serem declaradas para serem mais intuitivas. //2. Uma venda só pode ser realizada se houver saldo positivo em estoque. Caso //contrário, não haveria como entregar o produto ao cliente na venda. //3. Em caso de uma venda ser bem-sucedida, exibir uma mensagem positiva do //processo. Caso contrário, exibir uma mensagem informando que a venda não pode ser efetuada. //4. A escolha do produto deve ser feita a partir de um menu de opções a ser //exibido ao usuário que escolhe a opção desejada para em seguida, informar a //quantidade desejada. //5. Todos os produtos iniciam o algoritmo com um estoque de 10 produtos, e //ao longo das vendas vão sendo reduzidos estes valores, sem a necessidade de //reposição durante a execução, imaginando que seria a única quantidade //possível disponível no momento em que o algoritmo é executado. tipo t_Produto = registro nome :caractere valor :real estoque :inteiro fimRegistro t_Venda = registro cod :inteiro qtd :inteiro valor :real fimRegistro var produtos :vetor[1..5] de t_Produto venda :t_Venda inicio produtos[1].nome <- "Água" produtos[1].valor <- 3.0 produtos[1].estoque <- 10 produtos[2].nome <- "Vinho" produtos[2].valor <- 27.62 produtos[2].estoque <- 10 repita escrevaL("Menu de opções ") escrevaL("1. Água ") escrevaL("2. Vinho ") escrevaL("3. Refrigerante") escrevaL("4. Suco ") escrevaL("5. Cerveja ") escrevaL escreva ("Digite a opcao de produto: ") leia(venda.cod) escreva ("Digite a quantidade desejada: ") leia(venda.qtd) venda.valor <- produtos[venda.cod].valor*venda.qtd escrevaL("") escrevaL("Valor da venda: RS", venda.valor:1:2) escrevaL("") escrevaL("") ate (venda.cod = 0) fimAlgoritmo Eu acharia melhor utilizando registro. Isso é apenas em relação a "como armazenar e recuperar dados". Todos 2 vai funcionar, daí implementar o resto do código com a lógica do problema. Dica importante: sempre mantenha o código rodável. Cada vez que for alterando alguma coisa, coloca para rodar e testa rapidinho. Não tente fazer muita coisa de vez e depois testar, vá fazendo aos poucos.

@julia v, consegue abstrair e perceber que a parte mais fundamental seria "gerar uma matriz de caracteres"? Veja, se não consegue gerar caracteres numa matriz, o que adiantaria já ter palavra nela? Primeiramente faça uma matriz de caracteres aleatórios. Algo assim: Dê uma olha em funções para manipulação de cadeias de caracteres (strings). E como gerar números aleatórios. (Que seria utilizado na função... ) Vá pesquisando e entendendo...

Tá, mas acontece o quê? Para ser direto, faltou fechar o fimEscolha dentro do caso 2. Dica básica. se atente sempre a deixar as estruturas prontas. Se começou um escolha, tem que ter o seu fimEscolha. Se começou um se, tem que ter o seu fimSe etc. Ainda mais no VisualG que "não tem compilador", ou seja, só mostra o erro quando o código roda (em vez de já mostrar quando tenta compilar). Sobre os pedidos, use um vetor para controlar. Os comandos seriam algo como: contPedido <- contPedido+1 leia(pedidos[contPedido].codItem) leia(pedidos[contPedido].qtd) Segue esboço de código: algoritmo "Sistema de Restaurante" const TAM = 3 tipo t_item = registro nome :caractere //valor :real valor: inteiro //por enquanto, para facilitiar gerar valores fimRegistro t_pedido = registro codItem :inteiro qtd :inteiro fimRegistro var menu :real cardapio :vetor[1..10] de t_item pedidos :vetor[1..3] de t_pedido i :inteiro inicio repita escrevaL("----------------------------------------") escrevaL("-------- RESTAURANTE -------") escrevaL("----------------------------------------") escrevaL("Opção 1 - Inclusão de itens no cardapio ") escrevaL("Opção 2 - Registro de pedido ") escrevaL("Opção 3 - Resumo do pedido ") escrevaL("Opção 4 - Sair ") escrevaL("----------------------------------------") escrevaL("Qual a sua escolha no restaurante? ") leia(menu) escolha menu caso 1 escrevaL("Informe os itens no cardapio por dia: ") para i de 1 ate TAM faca escreva ("Descrição : ") ALEATORIO ON LISTA "ESTADOS" leia(cardapio[i].nome) ALEATORIO OFF escreva ("Valor : R$ ") ALEATORIO 1, 80 leia(cardapio[i].valor) ALEATORIO OFF fimPara escrevaL("----------------------------------------") para i de 1 ate TAM faca escrevaL(i, " ", cardapio[i].nome:20, " R$", cardapio[i].valor:1:2) fimPara caso 2 para i de 1 ate TAM faca escrevaL("Item: ", cardapio[i].nome:30, " R$", cardapio[i].valor:1:2) fimPara caso 3 escrevaL("EM CONSTRUÇÃO") fimEscolha ate menu=4 fimAlgoritmo Por enquanto se preocupe apenas em conseguir cadastrar pedidos... que o vetor seja preenchido corretamente. Só depois para calcular (que basicamente será pegar os dados desse vetor de registro e fazer as contas).

Poste o que já conseguiu fazer e em qual parte está com dúvidas.

Que tal refazer o exercício do zero? Daí você poderia se basear na estrutura do Portugol. Esboço inicial: algoritmo "Gerenciador de reservas de quartos" procedimento inicializarQuartos() var i :inteiro inicio para i de 1 ate 60 faca quartos[i] <- " " fimPara fimProcedimento var quartos :vetor[1..60] de caractere i :inteiro inicio inicializarQuartos() fimAlgoritmo { Faça um programa em Portugol Studio para controlar a ocupação de quartos de um hotel com 60 quartos. O programa deve ter as seguintes caractereísticas: Um menu deve ser fornecido para o usuário com as seguintes opções: r – para reservar um determinado quarto a – para reserva automática de quartos d – para liberar um quarto; t – para mostrar a taxa de ocupação do hotel x – Uma função que vocês vão definir q - para sair. Acima do menu deve ser mostrado uma lista de todos os quartos e se eles estão ocupados: se ocupado, mostrar um “X” na frente do número do quarto; caso contrário mostrar um espaço em branco “ “. Se o usuário tentar reservar um quarto que já está reservado, uma mensagem de erro deve ser exibida, indicando que o quarto já está ocupado. Sempre que ocorrer uma reserva ou liberação de quarto, a lista de quartos deve ser atualizada. Inicialmente todos os quartos devem estar desocupados. Mostrar quantos quartos estão ocupados juntamente com a porcentagem de ocupação. Mostrar também a taxa de ocupação por andar. Cada andar tem 20 quartos. Reserva automática: esse tipo de reserva faz com que o programa escolha automaticamente um quarto para reserva. O programa deve dar preferência para os quartos que estão nos andares que estão com maior ocupação. Crie um procedimento para lidar com as mensagens de erro. Após uma mensagem de erro peça para o usuário pressionar a tecla ENTER para continuar. Isso pode ser feito pelo comando leia(x), onde x é uma variável do tipo caractere. } Inserindo um menu: inicio inicializarQuartos() enquanto (opcao <> "q") faca escrevaL("r – para reservar um determinado quarto ") escrevaL("a – para reserva automática de quartos ") escrevaL("d – para liberar um quarto; ") escrevaL("t – para mostrar a taxa de ocupação do hotel") escrevaL("x – ima função que vocês vão definir ") escrevaL("q - para sair. ") escreva ("-> ") leia(opcao) fimEnquanto fimAlgoritmo Ou: procedimento exibirItensMenu() inicio escrevaL("r – para reservar um determinado quarto ") escrevaL("a – para reserva automática de quartos ") escrevaL("d – para liberar um quarto; ") escrevaL("t – para mostrar a taxa de ocupação do hotel") escrevaL("x – ima função que vocês vão definir ") escrevaL("q - para sair. ") fimProcedimento var quartos :vetor[1..60] de caractere opcao: caractere inicio inicializarQuartos() enquanto (opcao <> "q") faca exibirItensMenu() ") escreva ("-> ") leia(opcao) fimEnquanto fimAlgoritmo Por aí vai...

@julia v, poste o que já conseguiu fazer e onde está com dúvidas.

Interessante. Não sabia que esse "escape" funciona no Pascal. @Klbrrs, assim como no nosso português, é interessante dar um espaço após as ",". De um modo geral, segue um exemplo de código corrigido. program Exibir_Diversos_Calculos_Entre_Dois_Numeros; {$CODEPAGE UTF8} //para permitir acentos nas string em alguns compiladores [Não necessário no PascalZim, mas pode deixar] { Este programa lê dois números inteiros, calcula e imprime: - a soma dos dois números; - a subtração do primeiro pelo segundo; - a subtração do segundo pelo primeiro; - a multiplicação dos dois números; - o cociente inteiro da divisão do primeiro pelo segundo; - o cociente inteiro da divisão do segundo pelo primeiro; - o resto da divisão do primeiro pelo segundo; - o resto da divisão do segundo pelo primeiro. } {Progamador: Klbrrs} {Data: 17/05/2022} var a, b, c, d, e, f, g, h, i, j :integer; begin write ('Digite dois números: '); readln(a,b); c := a+b; d := a-b; e := b-a; f := a*b; g := a div b; h := b div a; i := a mod b; j := b mod a; writeln('A soma dos dois números é: ', c); writeln('A subtração do primeiro pelo segundo é: ', d); writeln('A subtração do segundo pelo primeiro é: ', e); writeln('A multiplicação dos dois números é: ', f); writeln('O cociente inteiro da divisão do primeiro pelo segundo é: ', g); writeln('O cociente inteiro da divisão do segundo pelo primeiro é: ', h); writeln('O resto da divisão do primeiro pelo segundo é: ', i); writeln('O resto da divisão do segundo pelo primeiro é: ', j); readln() end. Só para complementar: Por que erro na linha 27, e não na 26? E por que "'A' não esperado!"? É simples. Por que o delimitador de referência no Pascal é o ";", daí, é como se a linha 26 não tivesse terminado. O compilador entendo algo como: Após o c, tem um "aspas simples", correto? O que está fazendo iniciar uma novo bloco de texto... O ")" e o ";" estão sendo entendido como parte lá do novo bloco de texto, em vez de comandos no Pascal. Aí, após a próximo aspas simples, fecha o bloco e o Pascal entende que o A ali seria uma vaiável... só que, dentro do writeln(), precisaria de uma vírgula antes para separa o texto da tal variável. O que também ocorre é que o PascalZim está meio bugado. ("Não está preparado para tratar a situação", daí não está deixando as cores corretas quando a linha está quebrada. Tinha que aparecer em amarelo e verde como na imagem acima.) Para ficar mais claro a questão do delimitador. Eu posso fazer isso aqui de boa: c := a+b; d := a-b; e := b-a; f := a*b; g := a div b; h := b div a; i := a mod b; j := b mod a; Na primeira linha 4 instruções! (O que delimita é o ";".) Adendo: no VisualG (filho do Pascal), isso não funciona. É preciso separar as instruções por linha mesmo. (Lá não tem ";" ou algo para delimitar.)

Como citado, ponteiro não está disponível no VisualG. Mas de um modo geral, uma boa alternativa seria recriar um código aos poucos utilizando vetores, mesmo. Daí precisaria envolver toda a lógica relacionada. A lógica para ponteiros é uma, para vetores é outras... mas nada muuuito distante. Exemplo de base inicial: algoritmo "Minha Agenda" procedimento inserirElemLista() inicio cod <- cod+1 escreva ("Nome: ") leia(nomes[cod]) fimProcedimento var nomes: vetor[1..10] de caractere cod: inteiro opcao: caractere inicio repita escrevaL(">>>>>> AGENDA <<<<<<") escrevaL("(1) CRIAR NOVO CONTATO") escrevaL("(2) PROCURAR UM CONTATO") escrevaL("(3) DELETAR UM CONTATO") escrevaL("(4) LISTA DOS CONTATOS") escrevaL("(5) SAIR") leia(opcao) escolha opcao caso "1" inserirElemLista() fimEscolha ate (opcao = 5) fimAlgoritmo

Exemplo de possível solução: algoritmo "Valor e posição minimax de uma matriz" //Na teoria dos sistemas, define-se como elemento minimax de uma matriz //o menor elemento de uma linha onde se encontra o maior elemento da matriz. //Faça uma função que recebe, por parâmetro, uma matriz A(10,10) e //retorna o seu elemento minimax, juntamente com a sua posição. funcao Minimax (var posI, posJ: inteiro): inteiro var maiorValorMatriz: inteiro valorMinimax: inteiro i, j: inteiro inicio maiorValorMatriz <- matriz[1,1] para i de 1 ate 10 faca para j de 1 ate 10 faca se (matriz[i,j] > maiorValorMatriz) entao maiorValorMatriz <- matriz[i,j] posI <- i fimSe fimPara fimPara valorMinimax <- 999 para j de 1 ate 10 faca se (matriz[posI,j] < valorMinimax) entao valorMinimax <- matriz[posI,j] posJ <- j fimSe fimPara retorne valorMinimax fimFuncao procedimento preencherMatriz() var i, j: inteiro inicio para i de 1 ate 10 faca para j de 1 ate 10 faca //leia(matriz[i,j]) matriz[i,j] <- RandI(100) //gera valores de 0 a 99 //escreva (matriz[i,j]:3) exibir valor na tela fimPara fimPara escrevaL() fimProcedimento procedimento ExibirMatriz() var i, j: inteiro inicio para i de 1 ate 10 faca para j de 1 ate 10 faca escreva (matriz[i,j]:5) fimPara escrevaL() fimPara fimProcedimento var matriz: vetor [1..10,1..10] de inteiro valorMinimax: inteiro posX, posY: inteiro inicio escrevaL("Preenchendo a matriz...") preencherMatriz() valorMinimax <- Minimax(posX, posY) escrevaL() escrevaL("MATRIZ INFORMADA") ExibirMatriz() escrevaL() escrevaL("Minimax: ", valorMinimax:1, ". Posição: (", posX:1, ",", posY:1, ")") fimAlgoritmo Adendo 1: não necessariamente essa resposta está correta; Adendo 2: de um modo geral, não copie o código ou trecho dele, redigite e ajuste de acordo com seu próprio entendimento. Segue um outro código separando a parte de localizar o maior número da matriz: algoritmo "Valor e posição minimax de uma matriz" //Na teoria dos sistemas, define-se como elemento minimax de uma matriz //o menor elemento de uma linha onde se encontra o maior elemento da matriz. //Faça uma função que recebe, por parâmetro, uma matriz A(10,10) e //retorna o seu elemento minimax, juntamente com a sua posição. funcao MaiorValor (var posI, posX: inteiro): inteiro var i, j: inteiro maiorValorMatriz: inteiro inicio maiorValorMatriz <- matriz[1,1] para i de 1 ate 10 faca para j de 1 ate 10 faca se (matriz[i,j] > maiorValorMatriz) entao maiorValorMatriz <- matriz[i,j] posI <- i posX <- j fimSe fimPara fimPara retorne maiorValorMatriz fimFuncao funcao Minimax (var posI, posJ: inteiro): inteiro var maiorValorMatriz: inteiro valorMinimax: inteiro posMaiori, posMaiorJ, i, j: inteiro inicio maiorValorMatriz <- maiorValor(posMaiorI, posMaiorJ) posI <- posMaiorI valorMinimax <- 999 para j de 1 ate 10 faca se (matriz[posI,j] < valorMinimax) entao valorMinimax <- matriz[posI,j] posJ <- j fimSe fimPara retorne valorMinimax fimFuncao procedimento preencherMatriz() var i, j: inteiro inicio para i de 1 ate 10 faca para j de 1 ate 10 faca //leia(matriz[i,j]) matriz[i,j] <- RandI(100) //gera valores de 0 a 99 //escreva (matriz[i,j]:3) exibir valor na tela fimPara fimPara escrevaL() fimProcedimento procedimento ExibirMatriz() var i, j: inteiro inicio para i de 1 ate 10 faca para j de 1 ate 10 faca escreva (matriz[i,j]:5) fimPara escrevaL() fimPara fimProcedimento var matriz: vetor [1..10,1..10] de inteiro valorMinimax: inteiro posX, posY: inteiro inicio escrevaL("Preenchendo a matriz...") preencherMatriz() valorMinimax <- Minimax(posX, posY) escrevaL() escrevaL("MATRIZ INFORMADA") ExibirMatriz() escrevaL() escrevaL("Minimax: ", valorMinimax:1, ". Posição: (", posX:1, ",", posY:1, ")") fimAlgoritmo O resultado é exatamente o mesmo... apenas criei uma função apenas para localizar o maior.. Adendo 3: pode parecer confuso um pouco a questão das variáveis locais... se observar tem "várias variáveis com o mesmo nome" (e tem coisas que pode melhorar, rs)... mas veja (se é que não sabe ainda): as variáveis locais só existem dentro da própria função onde ela foi criada... o resto do programa não enxerga. Daí, por exemplo, teria teria a posI (seria posição ou coordenada i) de um contexto não tem nada a ver com uma outra posI de outro contexto. O uso de parâmetros na função servem justamente para fazer uma função (ou procedimento) se comunicar com o outro (ou com o programa principal)... o uso do var no parâmetro das funções servem para definir como "passagem por referência", ou seja, a variável local seria um link para a própria variável que foi utilizada na chamada da função (que em outras palavras seria dizer que "o que foi alterado na variável dentro da função, vai ser refletida na variável que foi utilizada ao chamar a função"). Por aí vai...

@Rafael_RJ, alguns pontos: Sobre a semântica no código A função chama-se "minimax()", mas eventualmente está retornando "maior_valor"? Percebe que tem alguma coisa está errada? Aí você precisa devolver valor_minimax. Sobre a verificação do menor na linha: para coluna de 1 ate 10 faca // valor contador fixo e faço um <para> para analisar todas as colunas se (valor_minimax < xmatriz[contador,coluna]) entao valor_minimax <- xmatriz[contador,coluna] fimse fimpara O sinal está trocado... ali no se, em vez de "<", seria ">". Sobre a linha encontrada... a nomenclatura "contador" está meio estranha... sugeriria algo como linhaMaior ou algo o tipo... Adendo: a variável onde será definida o valor da linha poderia ser atualizada junto com o valor do maior.. algo como: se (xmatriz[linha,coluna] > maior_valor) entao maior_valor <- xmatriz[linha,coluna] linha_maior <- linha fimse

@happy_day, por favor, não me chame de sr. Verificar com quem solicitou resolver o problema... Minha sugestão seria fazer das duas formas... como uma já foi feita, faz da outra também.

A provocação seria essa mesmo... é preciso focar no problema, não na solução. Senão sabemos do que precisa, como vamos encontrar uma alternativa? Segue enunciado: Pelo que eu vi, a forma que você entendeu seria algo como. "Informar a soma dos elementos da matriz entre si, só que cada elemento adicionado de 10". Ou algo assim, né? Se for, entendo que está correto!! Entretanto eu imagino que não seria isso. Eu entendi algo como: "tendo uma matriz 5x5, você pegaria cada uma das posição e adicionaria 10". ex.: 1 2 3 4 5 6 7 8 9 10 etc Exibiria: 11 22 23 24 25 16 17 18 19 20 etc Observe que a solução de ambos os casos são extremamente simples... a questão todo seria a interpretação, ou seja, após você entender o problema de uma forma, conseguiu resolver de boa (para aquilo que entendeu)... mas de uma forma de outra é preciso entender... Adendo: se for tentar fazer lá a soma de cada elemento na própria matriz, vai surgir um outro sub-problema: como imprimir matriz..., mas veja que o problema já estaria definido... só tentar fazer por tentativa e erro ou pesquisar. (Se é que não já sabe imprimir). Adendo 2: para ajudar no alinhamento, tem o conceito de formatação no VisualG. Lá dentro do escrevaL(), é possível definir o "tamanho" do número. Ex: valor[i,j]:3 Nesse caso, o número que estiver lá dentro do vetor, vai ser exibido com pelo menos 3 espaços. No caso, inserindo espaços à esquerda.

@neto562155, poste o que conseguiu fazer para servir de base para outros usuário, ou caso não tenha terminado, em qual parte está com dúvidas.

Segue o enunciado: Desenvolva um algoritmo em pseudocódigo com uma matriz 5x5 que some cada valor de uma posição da matriz com 10. Mostre o resultado na tela Primeiramente: de um modo resumido, o que o enunciando está pedindo? Após você repensar no enunciado, o que o seu código está fazendo? O seu algoritmo seria uma resposta para o enunciado?

@Rafael_RJ, são duas etapas distintas... Primeiro acha o maior valor da matriz (ignore por enquanto a questão da possibilidade de ter maiores iguais. Pegue o primeiro maior). Depois de ter o maior valor, você vai pegar o menor valor na linha onde está esse maior. Ou seja: quando estiver pegando o maior, também pegue a sua linha. Daí, para pegar o menor, use essa linha como referência. Lembrando: são etapas distintas... Não faz sentido tentar fazer as duas coisas ao mesmo tempo, já que para saber o maior, precisar varrer toda a matriz antes...(Se não tem o maior ainda, como vai querer achar o menor?)

@heinzi19, não imagino que seja algo trivial, pois, OU você já saberia fazer e acharia fácil, que não é o caso... OU não sabe fazer e vai ter uma dificuldade imensa para conseguir, ou seja, depois que entende fica fácil, mas entender por conta própria não me parece razoável, rs. Desta forma, segue uma explicação do que poderia ser: Tente entender o algoritmo independentemente do código já fornecido no enunciado. Veja: - ler os 15 valores jogando no vetor v; (Bem simples.) - ordenar o vetor v em ordem crescente, assim os 10 primeiros elementos serão os 10 primeiros menores; (Envolve a lógica de "perceber", ou seja, alguém te contar, que se deixar os elementos num vetor e ordená-lo depois, você vai ter os dados em ordem... Outro ponto são os diversos métodos de ordenação, que eventualmente precisa estudar em separado... o mais famoso é o Bubble Sort.) - inserir no a os 10 primeiros menores, ou seja, as 10 primeiras posições de v; - exibir o vetor a; Esses tipos de estruturas são padrões.. se repetem o teeeempo todo, mas dificilmente alguém o redescobre sozinho, ou seja, praticamente todo mundo um dia copiou de alguém e, no processo, entendeu/aprendeu os conceitos (isso é o esperado pelos professores)... Então, poderia ficar algo assim: program exercicio1; {$CODEPAGE UTF8} //para permitir acentos nas string em alguns compiladores [Não necessário no PascalZim, mas pode deixar] var i, j, aux: integer; v: array[1..15] of integer; a: array[1..10] of integer; //a porque lá no final ele utiliza essa nomenclatura begin for i:= 1 to 15 do readln(v[i]); //aqui estaria usando uma estrutura de ordenação bem famosa, que não sei o //nome, mas é bem parecido com o Bubble Sort (Obs.: essa abaixo NÃO é o Bubble Sort) for i:= 1 to 14 do for j:= i+1 to 15 do if v[i] > v[j] then begin //essa estrutura abaixo é típica para permuta de elementos num vetor... aux := v[i]; //copia o valor da posição "A" (para não perder o que tá lá. Vai ser substituído em seguida) v[i] := v[j]; //joga o valor da posição "B" em "A" v[j] := aux; //joga o valor de "A" em "B" (que está no "auxiliar", já que "A" já não tem o valor original) end; for i:= 1 to 10 do begin a[i] := v[i]; //aqui vai jogando o valor que está no vetor v, no vetor a write(a[i],' '); end; end. PONTOS IMPORTANTES: - Não sei se é a resposta correta; - Não copie o código com Ctrl+C/Ctrl+V... se for o caso, redigite tudo; - Para treinar um pouco, separe a "cópia das das posições de v em a" da exibição dos valores, ou seja, primeiro faça a cópia de v para a e separadamente exiba o vetor a. Qual dúvida ou comentário é só postar.

@robzpe, uma dica inicial é ir fazendo o programa aos pouco. Tente entender a essência do problema... que no caso seria basicamente "calcular médias aritméticas de duas notas" e "verificar a situação do aluno de acordo com essa média." Esboço inicial: algoritmo "Média de notas de turmas" //Escreva um pseudocódigo (algoritmo) que receba o nome da turma e o número de //disciplinas e o número de alunos por turma. O pseudocódigo deve calcular a //média de cada aluno em cada disciplina. Para calcular a média de cada aluno //é necessário ler as notas de 1ª avaliação e 2ª avaliação deste aluno [média //= (1AV + 2AV) / 2]. O pseudocódigo também deve verificar a situação do aluno: //• Reprovado por média se média for menor que 3; //• Aguardando final se média for maior ou igual a 3 e menor que 7 e //• Aprovado por média se média for maior ou igual a 7 Após ler todas as notas //de todos os alunos de uma determinada disciplina, dever ser impresso o resumo //da disciplina [ver relatório abaixo]. E após ler todas as disciplinas de uma //determinada turma dever ser impresso o resumo da turma. var notaAV1, notaAV2: real media: real inicio escreva ("Nota AV1: ") leia(notaAV1) escreva ("Nota AV2: ") leia(notaAV2) media <- (notaAV1+notaAV2) / 2 escreval("Média : ", media:1:2) fimAlgoritmo Verifica a situação: media <- (notaAV1+notaAV2) / 2 escreval("Média : ", media:1:2) se (media < 3) entao escrevaL("Reprovado") fimSe se (media >= 3) E (media < 7) entao escrevaL("Aguardando final") fimSe se (media >= 7) entao escrevaL("Aprovado") fimSe Como precisa ler para várias alunos, deixar num laço de repetição: var notaAV1, notaAV2: real media: real opcao: caractere inicio opcao <- "S" enquanto (opcao = "S") faca escreva ("Nota AV1: ") . . . escrevaL("") escrevaL("Ler outro? [S] ou [N]") leia(opcao) fimEnquanto fimAlgoritmo Por aí vai... Quais assuntos já foram dados até o momento? Já trabalhou com Vetores? Registros? Procedimentos e Funções? Qualquer coisa, poste o que já conseguiu fazer e em que parte está com dúvidas.

Rodar, acho que rodaria de boa... seria mais pelas questão dos princípios mesmo, relacionados aos paradigmas da linguagem*. Outro exemplo seria esse: O comando fimAlgoritmo não seria para "foçar finalizar o programa". Este é um comando relacionado o inicio para delimitar a parte do programa principal. Não poderia ser utilizar como no exemplo acima. É um erro. O programa roda porque o VisualG é "bugado" e não compila, ele interpreta em execução... daí nem o VisualG percebe que tá errado. Seria como fazer no Pascal algo assim: if (op = 4) then begin end. end; Entende? Lá no Pascal acho que existe o exit e o halt. Que seriam especificamente para isso (forçar a finalização...)... ou seja, no VisualG não existe um comando equivalente, como sair ou parar. Mas mesmo no Pascal não se usaria halt, um mais correto seria deixar o fluxo continuar até chegar no end. lá do final.

@kgin, muito bacana o teu código... imagino que já adianta muito coisa pro projeto (vai depender do enunciado, rs). Uma sugestão seria declarar as constantes diretamente (em vez de deixar como variáveis e setar os valores no corpo): algoritmo "loteamentos" const QUANTIDADE_LOTES = 14 LOTE_DISPONIVEL = 0 LOTE_RESERVADO = 1 LOTE_VENDIDO = 2 var lotes_disponiveis: vetor [1..QUANTIDADE_LOTES] de inteiro lotes_nomes: vetor [1..QUANTIDADE_LOTES] de caractere contador: inteiro Inclusive já usar o parâmetro na própria criação dos vetores. Só um adendo: Esse trecho está dentro do procedimento reservarLote, certo? Daí "não pode" invocar novamente o próprio método (nem poderia invocar um outro externo com objetivo de navegação entre partes..., pois o procedimento "atual" continua aberto... vai ficar "empilhando processos"). Um mais correto seria estruturar um laço de repetição. @Cristian Herchonvicz, por favor, poste o texto completo do enunciado. A estrutura do programa vai depender dos "requisitos" naquilo que foi solicitado... não adiantar fazer um programa todo lindo e rodando certo se não foi o que foi pedido. ABAIXO UM REFATORADA NO CÓDIGO ORIGINAL Refatorada 1: - inserção das constantes (como sugerido pelo @kgin); - ajustes de algumas nomenclaturas de variáveis; - uso de variáveis LOCAIS dentro dos procedimentos; - alinhamento da exibição dos lotes. algoritmo "Consisa Lote | Compra e Venda de Loteamentos" const QUANTIDADE_LOTES = 14 LOTE_DISPONIVEL = 0 LOTE_RESERVADO = 1 LOTE_VENDIDO = 2 var lotesStatus: vetor[1..QUANTIDADE_LOTES] de inteiro nomesCompradores: vetor[1..QUANTIDADE_LOTES] de caractere nomeComprador: caractere op: inteiro procedimento listarLote() var coluna: inteiro linha: inteiro Inicio para linha de 1 ate 14 passo 2 faca para coluna de 0 ate 1 faca escreva(linha+coluna) fimPara escreval() fimPara fimProcedimento procedimento reservarLote() inicio fimProcedimento procedimento comprarLote() inicio fimProcedimento inicio escreval("Bem vindos ao Consisa Lote:") escreval() escreval("Digite seu nome:") leia(nomeComprador) escreval() escreval("Por favor selecione um item abaixo:") escreval(" 1 Listar lotes") escreval(" 2 Reservar lote") escreval(" 3 Comprar lote") escreval(" 4 Sair") escreva ("Opção: ") leia(op) se op = 1 entao listarLote() fimSe se op = 2 entao reservarLote() fimSe se op = 3 entao compraLote() fimSe fimAlgoritmo Refatorada 1: - utilizar caracteres para representar os "status" dos lotes; - simplificação do fluxo para testes. (Não precisar ficar digitando) algoritmo "Consisa Lote | Compra e Venda de Loteamentos" const QUANTIDADE_LOTES = 14 LOTE_DISPONIVEL = "_" LOTE_RESERVADO = "R" LOTE_VENDIDO = "V" var lotesStatus: vetor[1..QUANTIDADE_LOTES] de caractere nomesCompradores: vetor[1..QUANTIDADE_LOTES] de caractere nomeComprador: caractere op: inteiro procedimento inicializarStatusLote() var i: inteiro inicio para i de 1 ate QUANTIDADE_LOTES faca lotesStatus[i] <- LOTE_DISPONIVEL fimPara fimProcedimento procedimento listarLote() var i: inteiro Inicio escreval("LISTA DE LOTES") para i de 1 ate QUANTIDADE_LOTES faca escreva(i:3, " [", lotesStatus[i], "]") se (i mod 2 = 0) entao escreval() fimSe fimPara fimProcedimento procedimento reservarLote() inicio lotesStatus[3] <- LOTE_RESERVADO fimProcedimento procedimento comprarLote() inicio fimProcedimento inicio inicializarStatusLote() escreval("Bem vindos ao Consisa Lote:") escreval() escreva ("Digite seu nome: ") //leia(nomeComprador) {Por enquanto, para não precisar ficar digitando} nomeComprador <- "Maria Joaquina" escreval(nomeComprador) escreval() escreval("Por favor selecione um item abaixo:") escreval(" 1 Listar lotes") escreval(" 2 Reservar lote") escreval(" 3 Comprar lote") escreval(" 4 Sair") escreva ("Opção: ") //leia(op) escreval() listarLote() reservarLote() listarLote() fimAlgoritmo Observem que assim só faço rodar... obviamente as implementações estão incompletas... até mesmo porque precisa do enunciado completo para ter uma base melhor... @Cristian Herchonvicz, você não precisa necessariamente seguir os nossos código, ok? A ideia é que você vá entendendo pelos exemplos e replicando as ideias no teu próprio código... Posta aí o enunciado que a depender pode ir refazendo aos poucos... a parte da modelagem inicial é a parte mais importante... todo o código vai ser estruturado de acordo com a estrutura dos dados. Só um adendo. Sobre: Ao chamar um procedimento pode ter a ideia de um "vá para" (GoTo)... mas no VisualG (e na maioria das linguagens do mundo real), na verdade é "invocado um NOVO método", ou seja, imaginem que um procedimento seja um programa do Windows... cada vez que chama-o, abriria um novo processo... daí, ao invocar um procedimento dentro do procedimento, aconteceria algo como: programa_principal reservaLote()1 reservaLote()2 reservaLote()3 ... Nisso, cada "processo" desse tem as suas próprias estruturas de variáveis, Ou seja, o 1 invoca 2... daí o 1 fica parado esperando terminar o 2. Se o 2 chamar o 3, vai ficar parado tb e esperar o 3... assim por diante. Quando o 3 terminar, volta para 2, que ao terminar volta para 1, que ao terminar volta para o programa principal... um mais correto seria o programa principal invocar um método, que volta para o principal. Que invoca um método e volta... por aí vai... Mas sobre isso dps a gente pode conversar com mais calma, se quiserem...

@Lauro Viana, uma sugestão seria: "tente deixar sempre a base da estrutura pronta". Exemplo: Var aprovado, reprovado, final: inteiro media, maior, menor: real cont_nota, cont_dis : inteiro cont_mat, cont_por, cont_geo, cont_fil, cont_his, cont_qui : inteiro opc_dis, opc_rep, opc_nota : inteiro rep, rep_disc: inteiro mediaD, mediaT:real Naluno, Ndis:inteiro somamedia:inteiro log_alun, log_dis, log_nota : logico nota, nota1, nota2, N1, N2: real inicio cont_nota := 0 log_nota := verdadeiro log_alun := verdadeiro log_dis := verdadeiro Naluno := 0 Ndis := 0 aprovado:=0 reprovado:=0 final:=0 menor:= 0 enquanto log_nota faca cont_nota := cont_nota + 1 escreva ("Informe o nome do aluno: ") leia (nota) repita cont_dis := cont_dis + 1 //essa linha seria digitada APÓS já ter o até ate (XPTO) //Ao criar repita, já defina o seu até fimEnquanto (XPTO) //Ao criar o enquanto, já defina o seu fimEnquanto fimAlgoritmo Adendo: XPTO seria apenas uma representação genérica. No lugar, no teu código, teria a sentença adequada. Adendo 2: a ideia é que sempre o teu código esteja compilável (não confundir com pronto). Tudo que vai inserindo, já vai (sintaticamente) está pronto. Daí só vai crescendo... e evitando esquecer, por exemplo, "fechar" algo. Lembrando que o VisuaG NÃO COMPILA código... ou seja, só vai ver os erros em tempo de execução.

Só complementando: como são "8 posições", seria de 0 a 7 (em detrimento de 0 a 8). Pequeno detalhe na digitação .Ex.: var numeros: vetor [0..7] de inteiro Sobre: Entendo que esse exercício seria bem básico. Meio que você precisaria atribuir um mesmo valor para todas as posições do vetor. Tentou fazer algo? Então, o ideal é sempre tentar fazer de alguma forma... tentar fazer algo... sugeriria tentar fazer com o que já aprendeu com as aulas, e caso tenha muita dificuldade, achar exemplos prontos com temas semelhantes (uso de vetores) e entender o que foi feito lá nos exemplos e replicar (reescrever, nunca copiar) o código... ajustando de acordo com o seu próprio exercício. Segue um exemplo pronto em VisualG 3.6.0.5: algoritmo "Preenchimento de vetor" var numeros : vetor [0..7] de inteiro i: inteiro inicio para i de 0 ate 7 faca numeros[i] <- 999 fimPara //eu não sei se além de preencher é também para exibir... mas vai lá: para i de 0 ate 7 faca escreva (numeros[i]) fimPara escreval("") escreva (" ") para i de 0 ate 7 faca escreva (i, " " ) fimPara fimAlgoritmo Outra forma de preencher: inicio numeros[0] <- 999 numeros[1] <- 999 numeros[2] <- 999 numeros[3] <- 999 numeros[4] <- 999 numeros[5] <- 999 numeros[6] <- 999 numeros[7] <- 999 Veja que essa forma é muito mais trabalhosa... "gasta muito mais linhas". No exemplo anterior, a combinação de vetores e laço de repetição (para) se sai bem mais prático. Se for se basear com um dos códigos acimas, NÃO COPIE... redigite tudo. Vá fazendo modificações e testando. Segue outro exemplo: Qual a diferença? É que no VisualG os números são impressos com "um espaço à esquerda". Ao utilizar esses ":x" após o número, remove esse espaço. O valor de x (no caso 1 no exemplo acima), define que o VisualG deve reservar 1 espaço para exibir o número. Como assim? Se não conhece esse o comando, e quiser se aprofundar, faça testes. Insira outros valores após os ":" e tente entender como funciona. Por aí vai.

@Genilson20 e @Leandro ads, conseguiram fazer?

@Pedroso90, um ponto inicial: para ler do teclado não use read(), este costuma dar problemas em alguns casos... Simplesmente sempre* use readln(). Esse "ln" aí no meio NÃO serve para pular uma linha na tela como no writeln() x write(). Só confia... Sugiro fazer algo do tipo: Sobre o programa... sugiro o seguinte: primeiro deixe a base funcionando... não vai adiantar tentar "não ter times repetidos" se eventualmente o programa sequer está cadastrando times... sacou? RESUMO: Refazer o programa indo do básico para o avançado. Exemplo: Programa que ler alguns times e exibe a lista (listar os times cadastrados). Uma boa opção seria utilizar um menu (Ex.: 1. Cadastrar. 2. Listar) Dica 1: não precisa ler todos os dados... leia apenas o nome! Depois de funcionar, testa lendo um segundo atributo... Dica 2: testa utilizar "1" em tudo para um time. "2" em outro etc... o importante é rodar. Depois testa com "dados mais reais". No aguardo.