Artigo

Atualizar artigo

Título:

Slug:

Conteúdo:

<h1>Introdução ao VisualG</h1>

<h2>O que é o VisualG?</h2>

<p>VisualG é uma ferramenta usada para desenvolver algoritmos em português, usando a linguagem de pseudocódigo. É amplamente utilizada em ambientes educacionais para introduzir lógica de programação.</p>

<h2>1. Primeiros Passos no VisualG</h2>

<p>Para começar a programar no VisualG, você deve abrir o ambiente e criar um novo algoritmo. Vamos usar a estrutura básica do VisualG:</p>

<pre><code data-highlighted="yes" class="hljs language-csharp">algoritmo <span class="hljs-string">"NomeDoAlgoritmo"</span>
<span class="hljs-keyword">var</span>
<span class="hljs-comment">// Declaração de variáveis</span>
inicio
<span class="hljs-comment">// Início do código</span>
fimalgoritmo</code></pre>

<p>Exemplo:</p>

<h3>Explicação</h3>

<ul>
	<li><strong>algoritmo "NomeDoAlgoritmo"</strong>: Define o início do código.</li>
	<li><strong>inicio</strong> e <strong>fimalgoritmo</strong>: Marcam o início e o fim do programa.</li>
</ul>

<h2>5. Exercícios Práticos</h2>

<h3>5.1 Calculadora Simples</h3>

<p>Escreva um algoritmo que leia dois números e um operador (+, -, *, /) e exiba o resultado da operação.</p>

<h3>5.2 Média de Notas</h3>

<p>Crie um algoritmo que leia 4 notas, calcule a média e informe se o aluno foi aprovado (média >= 7).</p>

<h3>5.3 Número Par ou Ímpar</h3>

<p>Crie um algoritmo que leia um número e verifique se ele é par ou ímpar.</p>

<h2>Conclusão</h2>

<p>Essa introdução apresentou os conceitos básicos do VisualG, incluindo variáveis, estruturas de decisão e loops. Com esses fundamentos, você pode criar seus próprios algoritmos e praticar lógica de programação.</p>

<h3>5.1 Calculadora Simples</h3>

<p>Este algoritmo lê dois números e um operador (+, -, *, /) e exibe o resultado da operação escolhida.</p>

<p>algoritmo "CalculadoraSimples"<br>
var<br>
    num1, num2, resultado: real<br>
    operador: caractere<br>
inicio<br>
    escreva("Digite o primeiro número: ")<br>
    leia(num1)<br>
    escreva("Digite o operador (+, -, *, /): ")<br>
    leia(operador)<br>
    escreva("Digite o segundo número: ")<br>
    leia(num2)<br>
    <br>
    se (operador = "+") entao<br>
        resultado <- num1 + num2<br>
    senao<br>
        se (operador = "-") entao<br>
            resultado <- num1 - num2<br>
        senao<br>
            se (operador = "*") entao<br>
                resultado <- num1 * num2<br>
            senao<br>
                se (operador = "/") e (num2 <> 0) entao<br>
                    resultado <- num1 / num2<br>
                senao<br>
                    escreval("Erro: Divisão por zero ou operador inválido!")<br>
                    interrompa<br>
                fimse<br>
            fimse<br>
        fimse<br>
    fimse<br>
    <br>
    escreval("Resultado: ", resultado)<br>
fimalgoritmo</p>

<h3>5.2 Média de Notas</h3>

<p>Este algoritmo calcula a média de quatro notas e informa se o aluno foi aprovado (média >= 7).</p>

<p>algoritmo "MediaDeNotas"<br>
var<br>
    nota1, nota2, nota3, nota4, media: real<br>
inicio<br>
    escreva("Digite a primeira nota: ")<br>
    leia(nota1)<br>
    escreva("Digite a segunda nota: ")<br>
    leia(nota2)<br>
    escreva("Digite a terceira nota: ")<br>
    leia(nota3)<br>
    escreva("Digite a quarta nota: ")<br>
    leia(nota4)<br>
    <br>
    media <- (nota1 + nota2 + nota3 + nota4) / 4<br>
    <br>
    escreval("Média: ", media)<br>
    <br>
    se (media >= 7) entao<br>
        escreval("Aluno aprovado.")<br>
    senao<br>
        escreval("Aluno reprovado.")<br>
    fimse<br>
fimalgoritmo</p>

<h3>5.3 Número Par ou Ímpar</h3>

<p>Este algoritmo verifica se um número é par ou ímpar.</p>

<p>algoritmo "ParOuImpar"<br>
var<br>
    numero: inteiro<br>
inicio<br>
    escreva("Digite um número: ")<br>
    leia(numero)<br>
    <br>
    se (numero % 2 = 0) entao<br>
        escreval("O número ", numero, " é par.")<br>
    senao<br>
        escreval("O número ", numero, " é ímpar.")<br>
    fimse<br>
fimalgoritmo<br>
Essas são as resoluções para os exercícios práticos em VisualG! Eles cobrem operações básicas de cálculo, condições e loops para ajudar a reforçar a prática de lógica de programação.</p>

<p>o VisualG, a diferença entre <code>escreva</code> e <code>escreval</code> é:</p>

<ul>
	<li>
	<p><strong><code>escreva</code></strong>: Exibe o texto ou valor na tela <strong>sem quebrar a linha</strong> após a saída. Ou seja, a próxima instrução de <code>escreva</code> ou <code>escreval</code> continuará na mesma linha.</p>
	</li>
	<li>
	<p><strong><code>escreval</code></strong>: Exibe o texto ou valor na tela <strong>com quebra de linha</strong> após a saída. Isso significa que a próxima instrução de <code>escreva</code> ou <code>escreval</code> será exibida na linha seguinte.</p>
	</li>
</ul>

<h3>Exemplo</h3>

<p>algoritmo "ExemploEscrevaEscreval"<br>
inicio<br>
    escreva("Olá")<br>
    escreva(" Mundo!")<br>
    escreval(" Bem-vindo ao VisualG.")<br>
    escreval("Fim do exemplo.")<br>
fimalgoritmo<br>
Saída</p>

<p>Olá Mundo! Bem-vindo ao VisualG.<br>
Fim do exemplo.</p>

<ul>
	<li>Os comandos <code>escreva("Olá")</code> e <code>escreva(" Mundo!")</code> exibem na mesma linha.</li>
	<li><code>escreval(" Bem-vindo ao VisualG.")</code> exibe na mesma linha anterior, mas <strong>com uma quebra de linha ao final</strong>.</li>
	<li><code>escreval("Fim do exemplo.")</code> aparece na linha seguinte.</li>
</ul>

<p>Essas diferenças são úteis para controlar a formatação da saída no console.</p>

<h2>1. <strong>Introdução ao VisualG e à Programação Estruturada</strong></h2>

<ul>
	<li>Breve histórico e importância do VisualG no ensino de lógica.</li>
	<li>Conceitos fundamentais de programação estruturada.</li>
	<li>Vantagens do pseudocódigo para iniciantes.</li>
</ul>

<h2>2. <strong>Tipos de Dados e Variáveis</strong></h2>

<ul>
<li>Tipos de dados: <strong>inteiro</strong>, <strong>real</strong>, <strong>caractere</strong>, e <strong>lógico</strong>.</li>
<li>Como declarar e inicializar variáveis no VisualG.</li>
<li>Exercícios.</li>
</ul>

<h2>3. <strong>Operadores</strong></h2>

<ul>
	<li><strong>Operadores aritméticos</strong>: <code>+</code>, <code>-</code>, <code>*</code>, <code>/</code>, <code>div</code>, <code>mod</code>.</li>
	<li><strong>Operadores relacionais</strong>: <code>=</code>, <code><></code>, <code><</code>, <code>></code>, <code><=</code>, <code>>=</code>.</li>
	<li><strong>Operadores lógicos</strong>: <code>e</code>, <code>ou</code>, <code>não</code>.</li>
	<li>Exemplos de uso e exercícios para praticar.</li>
</ul>

<h2>4. <strong>Estruturas de Decisão</strong></h2>

<ul>
	<li><strong>Condicional SE...ENTAO...SENAO</strong>.</li>
	<li><strong>Escolha...caso</strong>: ideal para múltiplas condições com base em um único valor.</li>
	<li>Exemplos e exercícios para praticar as diferentes formas de decisão.</li>
</ul>

<h2>5. <strong>Estruturas de Repetição (Loops)</strong></h2>

<ul>
	<li><strong>Enquanto...faca</strong>: repetição condicionada.</li>
	<li><strong>Para...ate...faca</strong>: repetição com contador.</li>
	<li><strong>Repita...ate</strong>: repetição pós-condicionada.</li>
	<li>Exercícios práticos, como gerar tabelas de multiplicação ou calcular fatorial.</li>
</ul>

<h2>6. <strong>Funções e Procedimentos</strong></h2>

<ul>
	<li>Diferença entre funções e procedimentos.</li>
	<li>Como criar e chamar funções no VisualG.</li>
	<li>Exemplos práticos, como calcular a área de uma figura geométrica usando funções.</li>
</ul>

<h2>7. <strong>Manipulação de Dados</strong></h2>

<ul>
	<li><strong>Entrada e saída</strong>: uso de <code>leia</code>, <code>escreva</code>, e <code>escreval</code> com controle de formatação.</li>
	<li><strong>Formatação de dados de saída</strong>: como alinhar textos e controlar espaços.</li>
	<li>Exemplos para prática de manipulação e formatação de dados.</li>
</ul>

<h2>8. <strong>Vetores e Matrizes</strong></h2>

<ul>
	<li>Declaração e manipulação de <strong>vetores</strong> (arrays unidimensionais).</li>
	<li>Declaração e manipulação de <strong>matrizes</strong> (arrays bidimensionais).</li>
	<li>Exemplos de uso, como ordenar elementos em um vetor ou somar linhas de uma matriz.</li>
</ul>

<h2>9. <strong>Algoritmos de Ordenação e Busca</strong></h2>

<ul>
	<li><strong>Busca sequencial</strong>: localizar um valor em um vetor.</li>
	<li><strong>Ordenação</strong>: introdução ao método de ordenação bolha (Bubble Sort).</li>
	<li>Exercícios para criar e testar algoritmos de busca e ordenação.</li>
</ul>

<h2>10. <strong>Tratamento de Erros e Validação de Dados</strong></h2>

<ul>
	<li>Como lidar com entradas inválidas.</li>
	<li>Técnicas para garantir que o programa funcione corretamente mesmo com dados inesperados.</li>
	<li>Exercícios práticos para aplicar validação.</li>
</ul>

<h2>11. <strong>Desafios e Exercícios Práticos</strong></h2>

<ul>
	<li>Exercícios adicionais para praticar todos os tópicos anteriores.</li>
	<li>Desafios de lógica para aprimorar o raciocínio, como cálculo de médias, contagem de letras, e conversão de valores.</li>
</ul>

<h2>12. <strong>Projetos Finais</strong></h2>

<ul>
	<li>Propostas de projetos mais completos para praticar a integração dos conhecimentos adquiridos, como:
	<ul>
		<li><strong>Sistema de Cadastro de Alunos</strong>: com vetores para armazenar dados.</li>
		<li><strong>Calculadora Completa</strong>: incluindo operações avançadas.</li>
		<li><strong>Jogo de Adivinhação</strong>: que usa estrutura de repetição e validação.</li>
	</ul>
	</li>
</ul>

<h2>13. <strong>Dicas de Prática e Recursos Extras</strong></h2>

<ul>
	<li>Dicas para melhorar o raciocínio lógico.</li>
	<li>Recursos extras: links para tutoriais, exercícios online, e livros recomendados para complementar o aprendizado.</li>
</ul>

<p><hr></p>
<p>Essa apostila expandida cobriria os conceitos essenciais e avançados do VisualG, oferecendo uma base sólida para iniciantes e desafiando os alunos com exercícios mais complexos conforme avançam.</p>

<h1>Apostila de VisualG</h1>

<h2>1. <strong>Introdução ao VisualG e à Programação Estruturada</strong></h2>

<p>VisualG é uma ferramenta que permite escrever algoritmos em português, ajudando a entender a lógica de programação antes de aprender uma linguagem de código. A programação estruturada segue um passo a passo de instruções e é uma base essencial para resolver problemas computacionais.</p>
<p><hr></p>

<h3>2. <strong>Tipos de Dados e Variáveis</strong></h3>

<h4>2.1. Tipos de Dados</h4>
<p>No VisualG, os tipos de dados principais são:</p>
<ul>
<li><code>Inteiro</code>: números inteiros (ex: 5, -12).</li>
<li><code>Real</code>: números com ponto decimal (ex: 3.14, -0.5).</li>
<li><code>Caractere</code>: texto ou sequência de caracteres (ex: "Olá", "A").</li>
<li><code>Logico</code>: valores booleanos (Verdadeiro ou Falso).</li>
</ul>

<h4>2.2. Variáveis</h4>

<p>As variáveis são usadas para armazenar informações. No VisualG, usamos o comando <code>var</code> para declarar variáveis e definir o tipo de dado.</p>

<h4>Exemplo de Declaração de Variáveis</h4>
<pre><code>algoritmo "ExemploTipos"

var
    idade: inteiro
    altura: real
    nome: caractere
    aprovado: logico
inicio
    idade <- 20
    altura <- 1.75
    nome <- "Fabrício de Medeiros"
    aprovado <- verdadeiro
fimalgoritmo</code></pre>

<h4>Exercício</h4>
<p>Declare variáveis de cada tipo e atribua valores para praticar.</p>

<h5>Solução</h5>
<pre><code>algoritmo "TiposDeDados"

var
    idade: inteiro
    altura: real
    nome: caractere
    aprovado: logico
inicio
    idade <- 25
    altura <- 1.68
    nome <- "Fabrício de Medeiros"
    aprovado <- verdadeiro
    escreval("Idade: ", idade)
    escreval("Altura: ", altura)
    escreval("Nome: ", nome)
    escreval("Aprovado: ", aprovado)
fimalgoritmo</code></pre>
<p><hr></p>

<h3>3. Operadores</h3>

<ul>
<li><strong>Aritméticos</strong>: <code>+</code>, <code>-</code>, <code>*</code>, <code>/</code>, <code>div</code>, <code>mod</code></li>
<li><strong>Relacionais</strong>: <code>=</code>, <code><></code>, <code><</code>, <code>></code>, <code><=</code>, <code>>=</code></li>
<li><strong>Lógicos</strong>: <code>e</code>, <code>ou</code>, <code>não</code></li>
</ul>

<h4>Exemplo</h4>
<pre><code>algoritmo "Operadores"

var
    a, b: inteiro
    resultado: logico
inicio
    a <- 10
    b <- 5
    resultado <- (a > b) e (b <> 0)
    escreval("Resultado lógico: ", resultado)
fimalgoritmo</code></pre>

<h4>Exercício</h4>
<p>Crie expressões usando operadores diferentes e teste os resultados.</p>

<h5>Solução</h5>
<pre><code>algoritmo "Operadores"

var
    a, b: inteiro
    resultadoLogico: logico
    resultadoAritmetico: inteiro
inicio
    a <- 10
    b <- 3
    resultadoAritmetico <- (a + b) * 2
    resultadoLogico <- (a > b) e (b <> 0)
    escreval("Resultado Aritmético: ", resultadoAritmetico)
    escreval("Resultado Lógico: ", resultadoLogico)
fimalgoritmo</code></pre>
<p><hr></p>

<h3>4. Estruturas de Decisão</h3>
<p>As estruturas de decisão permitem executar diferentes partes do código, dependendo de uma condição.</p>

<ul>
<li><code>se...entao...senao</code>: permite a execução de instruções com base em uma condição.</li>
<li><strong>Escolha...caso</strong>: ideal para múltiplas condições baseadas em um único valor.</li>
</ul>

<h4>Sintaxe Condicional <code>SE...ENTAO...SENAO</code></h4>

<pre><code>se (condição) entao
    // Código a ser executado se a condição for verdadeira
senao
    // Código a ser executado se a condição for falsa
fimse</code></pre>

<h4>Exemplo</h4>
<pre><code>algoritmo "Maioridade"

var
    idade: inteiro
inicio
    escreva("Digite sua idade: ")
    leia(idade)
    se (idade >= 18) entao
        escreval("Você é maior de idade.")
    senao
        escreval("Você é menor de idade.")
    fimse
fimalgoritmo</code></pre>

<h4>Exemplo</h4>
<pre><code>algoritmo "EstruturaSe"

var
    nota: real
inicio
    escreva("Digite a nota: ")
    leia(nota)
    se (nota >= 7) entao
        escreval("Aprovado")
    senao
        escreval("Reprovado")
    fimse
fimalgoritmo</code></pre>

<h4>Exercício</h4>
<p>Verifique a faixa etária de uma pessoa usando <code>se...entao...senao</code>.</p>

<h4>Solução</h4>
<pre><code>algoritmo "FaixaEtaria"

var
    idade: inteiro
inicio
    escreva("Digite sua idade: ")
    leia(idade)
    se (idade < 12) entao
        escreval("Criança")
    senao
        se (idade < 18) entao
            escreval("Adolescente")
        senao
            escreval("Adulto")
        fimse
    fimse
fimalgoritmo</code></pre>
<p><hr></p>

<h3>5. Estruturas de Repetição (Loops)</h3>
<p>Estruturas de repetição são usadas para executar um bloco de código várias vezes.</p>

<ul>
<li><code>enquanto...faca</code>: repete enquanto uma condição é verdadeira.</li>
<li><code>para...ate...faca</code>: ideal para um número conhecido de repetições.</li>
<li><code>repita...ate</code>: executa pelo menos uma vez antes de verificar a condição.</li>
</ul>

<h4><code>enquanto...faca</code></h4>
<p>A estrutura <code>enquanto...faca</code> é usada para repetir um bloco de código enquanto uma condição é verdadeira. Ela verifica a condição no início do loop; se a condição for falsa desde o início, o bloco de código não será executado.</p>

<h4>Sintaxe</h4>
<pre><code>enquanto (condição) faca
    // Código a ser executado
fimenquanto</code></pre>
<p>O código dentro do bloco <code>enquanto</code> será repetido até que a condição se torne falsa.</p>

<h4>Exemplo</h4>
<p>Programa que exibe uma contagem de 1 a 10 usando a estrutura <code>enquanto...faca</code>.</p>
<pre><code>algoritmo "Contagem"

var
    contador: inteiro
inicio
    contador <- 1
    enquanto (contador <= 10) faca
        escreval("Contador: ", contador)
        contador <- contador + 1
    fimenquanto
fimalgoritmo</code></pre>

<h4>Explicação</h4>
<ol>
<li>Inicializamos a variável <code>contador</code> com o valor <code>1</code>.</li>
<li>A condição <code>(contador <= 10)</code> é verificada no início do loop. Enquanto essa condição for verdadeira, o código dentro do bloco <code>enquanto</code> será executado.</li>
<li>A cada iteração, o valor de <code>contador</code> é incrementado em <code>1</code>.</li>
<li>Quando o <code>contador</code> atinge <code>11</code>, a condição <code>(contador <= 10)</code> se torna falsa, e o loop é finalizado.</li>
<li>Esse exemplo exibe os números de <code>1</code> a <code>10</code> na tela.</li>
</ol>

<h4>Sintaxe <code>para...ate...faca</code></h4>
<p>A estrutura <code>para...ate...faca</code> é ideal quando sabemos o número exato de repetições que queremos realizar. Ela permite definir uma variável de controle, um valor inicial e um valor final. A variável de controle é incrementada automaticamente a cada iteração.</p>

<h4>Sintaxe</h4>
<pre><code>para variável de inicio ate fim faca
    // Código a ser executado
fimpara</code></pre>
<p>O código dentro do bloco <code>para</code> será executado um número fixo de vezes, de acordo com o valor inicial e final definidos.</p>

<h4>Exemplo</h4>
<p>Programa que exibe a tabuada de um número usando a estrutura <code>para...ate...faca</code>.</p>
<pre><code>algoritmo "Tabuada"

var
    numero, i: inteiro
inicio
    escreva("Digite um número: ")
    leia(numero)
    para i de 1 ate 10 faca
        escreval(numero, " x ", i, " = ", numero * i)
    fimpara
fimalgoritmo</code></pre>
<h4>Explicação</h4>
<ol>
<li>O programa solicita que o usuário insira um número, que será usado para gerar a tabuada.</li>
<li>A estrutura <code>para...ate...faca</code> cria uma variável de controle <code>i</code>, que começa em <code>1</code> e vai até <code>10</code>.</li>
<li>A cada iteração, o programa exibe o resultado da multiplicação de <code>numero</code> por <code>i</code>.</li>
<li>Quando <code>i</code> atinge <code>10</code>, o loop é finalizado, e a tabuada completa é exibida na tela.</li>
</ol>

<h4>Exemplo</h4>
<p>Programa que exibe uma contagem de 1 a 10 usando a estrutura <code>para...ate...faca</code>.</p>
<pre><code>algoritmo "Contador"

var
    i: inteiro
inicio
    para i de 1 ate 5 faca
        escreval("Número: ", i)
    fimpara
fimalgoritmo</code></pre>

<h4>Exercício</h4>
<p>Crie um loop que exiba a tabuada de um número.</p>

<h4>Solução</h4>
<pre><code>algoritmo "Tabuada"

var
    i, numero: inteiro
inicio
    escreva("Digite um número para a tabuada: ")
    leia(numero)
    para i de 1 ate 10 faca
        escreval(numero, " x ", i, " = ", numero * i)
    fimpara
fimalgoritmo</code></pre>

<h4><code>para...ate...faca</code></h4>
<p>A estrutura <code>repita...ate</code> é utilizada para executar um bloco de código pelo menos uma vez, independentemente da condição. A condição de saída é verificada no final do bloco, o que garante que o código seja executado ao menos uma vez.</p>

<h4>Sintaxe</h4>
<pre><code>repita
    // Código a ser executado
ate (condição)</code></pre>
<p>O código dentro do bloco <code>repita</code> será executado repetidamente até que a condição dentro de <code>ate</code> seja verdadeira.</p>

<h4>Exemplo</h4>

<p>Programa que solicita ao usuário uma senha e repete a solicitação até que ele insira a senha correta.</p>
<pre><code>algoritmo "VerificarSenha"

var
    senha: inteiro
inicio
    repita
        escreva("Digite a senha (dica: 1234): ")
        leia(senha)
    ate (senha = 1234)
    
    escreval("Senha correta! Acesso permitido.")
fimalgoritmo</code></pre>

<h4>Explicação</h4>
<ol>
<li>O programa solicita que o usuário digite uma senha.</li>
<li>Se a senha inserida for incorreta, o programa repete o pedido até que o usuário insira <code>1234</code>.</li>
<li>Quando a senha correta é digitada, o programa exibe uma mensagem de acesso permitido.</li>
</ol>

<h4>Exercício</h4>
<p>Crie um programa que leia um número e some valores inteiros inseridos pelo usuário até que o valor da soma seja igual ou superior a 50. Exiba o valor final da soma após sair do loop.</p>

<pre><code>algoritmo "SomaAte50"

var
    numero, soma: inteiro
inicio
    soma <- 0  // Inicializa a soma em 0
    
    repita
        escreva("Digite um número para somar: ")
        leia(numero)
        soma <- soma + numero  // Atualiza a soma com o número inserido
    ate (soma >= 50)
    
    escreval("A soma final é: ", soma)
fimalgoritmo</code></pre>

<h3>Explicação</h3>
<ol>
<li>Inicializamos a variável <code>soma</code> com o valor <code>0</code>.</li>
<li>Usamos a estrutura <code>repita...ate</code> para garantir que o usuário insira pelo menos um número.</li>
<li>A cada iteração, o programa solicita um número ao usuário e o adiciona à variável <code>soma</code>.</li>
<li>O loop continua até que o valor de <code>soma</code> seja maior ou igual a 50.</li>
<li>Quando a condição <code>(soma >= 100)</code> é satisfeita, o programa exibe a soma final e termina.</li>
</ol>

<p>Esse programa garante que a soma dos valores inseridos seja sempre mostrada após atingir ou ultrapassar 50.</p>
<p><hr></p>

<h2>6. Funções e Procedimentos</h2>
<p>Funções retornam valores e procedimentos apenas executam ações.</p>

<h4>Exemplo de Função</h4>
<pre><code>funcao areaQuadrado(lado: real): real
inicio
    retorne lado * lado
fimfuncao</code></pre>

<h4>Explicação</h4>
<ul>
<li>A função <code>areaQuadrado</code> recebe um parâmetro <code>lado</code> do tipo <code>real</code>.</li>
<li>Dentro do corpo da função, calcula-se a área multiplicando <code>lado</code> por ele mesmo.</li>
<li>O comando <code>retorne</code> devolve o resultado da multiplicação, que representa a área do quadrado.</li>
</ul>

<h4>Casos de Uso</h4>
<p>Para utilizar a função, você pode chamá-la em um programa principal e exibir o resultado:</p>
<pre><code>variavel lado, area: real

inicio
    escreva("Digite o valor do lado do quadrado: ")
    leia(lado)
    area <- areaQuadrado(lado)
    escreva("A área do quadrado é: ", area)
fimalgoritmo</code></pre>

<h4>Exemplo</h4>
<pre><code>algoritmo "AreaQuadrado"

// Declaração da função que calcula a área do quadrado
funcao calculoAreaQuadrado(lado: real): real

inicio
    retorne lado * lado
fimfuncao

// Programa principal
var
   lado, area: real

inicio
    escreva("Digite o valor do lado do quadrado: ")
    leia(lado)

// Chama a função areaQuadrado para calcular a área
    area <- calculoAreaQuadrado(lado)

escreva("A área do quadrado é: ", area)
fimalgoritmo</code></pre>

<h4>Exercício</h4>
<p>Crie uma função para calcular a área de um círculo.</p>

<h4>Solução</h4>
<pre><code>funcao areaCirculo(raio: real): real

inicio
    retorne 3.14159 * raio * raio
fimfuncao

algoritmo "AreaCirculo"

var
    raio, area: real
inicio
    escreva("Digite o raio do círculo: ")
    leia(raio)
    area <- areaCirculo(raio)
    escreval("Área do círculo: ", area)
fimalgoritmo</code></pre>
<p><hr></p>

<h3>7. Manipulação de Dados (Entrada e Saída)</h3>
<ul>
<li><code>Leia</code>: lê dados do usuário.</li>
<li><code>Escreva</code> e <code>Escreval</code>: exibe dados, sendo <code>Escreval</code> com quebra de linha.</li>
</ul>

<h4>Exemplo</h4>
<pre><code>algoritmo "EntradaSaida"

var
    nome: caractere
inicio
    escreva("Digite seu nome: ")
    leia(nome)
    escreval("Olá, ", nome)
fimalgoritmo</code></pre>

<h4>Exercício</h4>
<p>Crie um programa que leia o nome do usuário e o exiba com uma saudação.</p>

<h4>Solução</h4>
<pre><code>algoritmo "SaudacaoUsuario"

var
    nome: caractere
inicio
    escreva("Digite seu nome: ")
    leia(nome)
    escreval("Olá, ", nome, "! Seja bem-vindo!")
fimalgoritmo</code></pre>

<h3>8. Vetores e Matrizes</h3>
<ul>
<li><strong>Vetores</strong>: armazenamento linear (ex: notas de um aluno).</li>
<li><strong>Matrizes</strong>: armazenamento em linhas e colunas (ex: tabela de dados).</li>
</ul>

<h4>Exemplo de Vetor</h4>
<pre><code>algoritmo "VetorSimples"

var
    notas: vetor[1..3] de real
    i: inteiro
inicio
    para i de 1 ate 3 faca
        escreva("Digite a nota ", i, ": ")
        leia(notas[i])
    fimpara
    escreval("Notas armazenadas.")
fimalgoritmo</code></pre>

<h4>Exemplo de Matriz</h4>
<pre><code>algoritmo "Matriz2x2"

var
    matriz: vetor[1..2, 1..2] de inteiro
    i, j: inteiro
inicio
    para i de 1 ate 2 faca
        para j de 1 ate 2 faca
            escreva("Digite o valor para matriz[", i, "][", j, "]: ")
            leia(matriz[i, j])
        fimpara
    fimpara
    
    escreval("Valores da matriz:")
    para i de 1 ate 2 faca
        para j de 1 ate 2 faca
            escreva(matriz[i, j], " ")
        fimpara
        escreval()
    fimpara
fimalgoritmo</code></pre>

<h4>Exercício 1</h4>
<p>Preencha um vetor com 4 elementos e exiba esses valores.</p>

<h4>Solução</h4>
<pre><code>algoritmo "Vetor4Elementos"

var
    notas: vetor[1..4] de real
    i: inteiro
inicio
    // Preenchendo o vetor
    para i de 1 ate 4 faca
        escreva("Digite o elemento ", i, ": ")
        leia(notas[i])
    fimpara

// Exibindo os valores do vetor
    escreval("Elementos do vetor:")
    para i de 1 ate 4 faca
        escreva(notas[i], " ")
    fimpara
    escreval()
fimalgoritmo</code></pre>

<h4>Exercício 2</h4>
<p>Preencha uma matriz 3x3 e exiba os valores.</p>

<h4>Solução</h4>
<pre><code>algoritmo "Matriz3x3"

var
    matriz: vetor[1..3, 1..3] de inteiro
    i, j: inteiro
inicio
    // Preenchendo a matriz
    para i de 1 ate 3 faca
        para j de 1 ate 3 faca
            escreva("Digite o valor para matriz[", i, "][", j, "]: ")
            leia(matriz[i, j])
        fimpara
    fimpara
    
    // Exibindo os valores da matriz
    escreval("Valores da matriz:")
    para i de 1 ate 3 faca
        para j de 1 ate 3 faca
            escreva(matriz[i, j], " ")
        fimpara
        escreval()
    fimpara
fimalgoritmo</code></pre>
<p><hr></p>

<h3>9. Algoritmos de Ordenação e Busca</h3>
<ul>
<li><strong>Busca sequencial</strong>: procura um valor em uma lista.</li>
<li><strong>Ordenação Bolha</strong> (Bubble Sort): organiza valores em ordem crescente.</li>
</ul>

<h4>Exemplo de Busca:</h4>
<pre><code>algoritmo "BuscaSequencial"

var
    numeros: vetor[1..5] de inteiro
    i, procurado: inteiro
    encontrado: logico
inicio
    // Supondo que o vetor já esteja preenchido
    procurado <- 7
    encontrado <- falso
    para i de 1 ate 5 faca
        se (numeros[i] = procurado) entao
            encontrado <- verdadeiro
            interrompa
        fimse
    fimpara
    se encontrado entao
        escreval("Número encontrado!")
    senao
        escreval("Número não encontrado.")
    fimse
fimalgoritmo</code></pre>

<h4>Exercício</h4>
<p>Crie um programa que procure um valor específico em um vetor.</p>

<pre><code>algoritmo "BuscaNoVetor"

var
    numeros: vetor[1..5] de inteiro
    i, procurado: inteiro
    encontrado: logico
inicio
    numeros[1] <- 10
    numeros[2] <- 20
    numeros[3] <- 30
    numeros[4] <- 40
    numeros[5] <- 50
    
    escreva("Digite o número que deseja buscar: ")
    leia(procurado)
    
    encontrado <- falso
    para i de 1 ate 5 faca
        se (numeros[i] = procurado) entao
            encontrado <- verdadeiro
            interrompa
        fimse
    fimpara
    
    se encontrado entao
        escreval("Número encontrado no vetor.")
    senao
        escreval("Número não encontrado no vetor.")
    fimse
fimalgoritmo</code></pre>
<p><hr></p>

<h3>10. Tratamento de Erros e Validação de Dados</h3>
<p>Verifica se as entradas estão no formato correto para evitar erros no programa.</p>

<h4>Exemplo</h4>
<pre><code>algoritmo "ValidacaoEntrada"

var
    idade: inteiro
inicio
    escreva("Digite sua idade: ")
    leia(idade)
    se (idade > 0) e (idade < 120) entao
        escreval("Idade válida.")
    senao
        escreval("Idade inválida!")
    fimse
fimalgoritmo</code></pre>

<h4>Exercício</h4>
<p>Crie um programa que valide se a idade inserida está na faixa permitida para participação em um evento (entre 18 e 65 anos).</p>

<h4>Solução</h4>
<pre><code>algoritmo "ValidacaoEvento"
var
    idade: inteiro
inicio
    escreva("Informe sua idade para verificação do ingresso: ")
    leia(idade)
    
    se (idade >= 18) e (idade <= 65) entao
        escreval("Idade permitida! Você pode participar do evento.")
    senao
        se (idade < 18) entao
            escreval("Idade insuficiente! Permitido apenas para maiores de 18 anos.")
        senao
            escreval("Idade excedida! Permitido apenas para pessoas até 65 anos.")
        fimse
    fimse
fimalgoritmo</code></pre>
<p><hr></p>

<h3>11. Desafios e Exercícios Práticos</h3>
<ul>
<li><strong>Desafio 1</strong>: Crie um programa que exiba os números primos de 1 a 50.</li>
<li><strong>Desafio 2</strong>: Desenvolva um algoritmo para calcular a média de idades de um grupo de pessoas.</li>
<li><strong>Desafio 3</strong>: Crie um sistema de login que verifique a senha e permita ou não o acesso.</li>
</ul>

<h4>Desafio 1</h4>
<p>Crie um programa que exiba os números primos de 1 a 50.</p>
<pre><code>algoritmo "NumerosPrimos"
var
    i, j: inteiro
    primo: logico
inicio
    para i de 2 ate 50 faca
        primo <- verdadeiro
        para j de 2 ate i - 1 faca
            se (i mod j = 0) entao
                primo <- falso
                interrompa
            fimse
        fimpara
        se primo entao
            escreval(i, " é primo.")
        fimse
    fimpara
fimalgoritmo</code></pre>

<h4>Desafio 2</h4>
<p>Desenvolva um algoritmo para calcular a média de idades de um grupo de pessoas.</p>
<pre><code>algoritmo "MediaIdades"
var
    i, total, idade, soma: inteiro
    media: real
inicio
    escreva("Digite o total de pessoas: ")
    leia(total)
    soma <- 0
    para i de 1 ate total faca
        escreva("Digite a idade da pessoa ", i, ": ")
        leia(idade)
        soma <- soma + idade
    fimpara
    media <- soma / total
    escreval("A média de idades é: ", media)
fimalgoritmo</code></pre>

<h4>Desafio 3</h4>
<p>Crie um sistema de login que verifique a senha e permita ou não o acesso.</p>
<pre><code>algoritmo "SistemaDeLogin"
var
    senha: caractere
inicio
    escreva("Digite a senha: ")
    leia(senha)
    se (senha = "12345") entao
        escreval("Acesso permitido.")
    senao
        escreval("Acesso negado.")
    fimse
fimalgoritmo</code></pre>

Autor:

Status:

Voltar