As matrizes são estruturas fundamentais tanto na matemática quanto na computação. Elas permitem a organização e manipulação de dados de forma eficiente, sendo amplamente utilizadas em diversas aplicações, desde a representação de imagens até cálculos complexos em planilhas. Nesta aula vamos explorar o conceito de matrizes em computação, sua aplicação em lógica de programação e exemplos práticos de uso.

O Conceito de Matrizes

Em matemática, uma matriz é definida como um conjunto de elementos dispostos em linhas e colunas. Uma matriz  m x n  (m por n) possui m linhas e n colunas, e seus elementos são geralmente representados por índices i  (linha) e \j  (coluna). Por exemplo, uma matriz A de 3 linhas e 3 colunas pode ser representada da seguinte forma:

Matriz 3×3

Matrizes em Lógica de Programação

Na lógica de programação, uma matriz pode ser vista como um array bidimensional (vetor de duas dimensões), ou seja, uma estrutura composta por linhas e colunas que se assemelha a uma tabela. Em Portugol Studio, a declaração de uma matriz é feita especificando o tipo de dados e o número de linhas e colunas. Por exemplo, para declarar uma matriz de inteiros com 5 linhas e 3 colunas, utilizamos a seguinte sintaxe:

inteiro matriz[5][3]

Também é possível usar constantes para representar o número de linhas e colunas:

const inteiro X = 5
const inteiro Y = 3
inteiro matriz[X][Y]

Atribuição e Acesso a Valores em Matrizes

Para atribuir um valor a uma matriz, indicamos a posição do valor no formato [linha][coluna]:

matriz[0][0] = 60

Para obter um valor da matriz, utilizamos a mesma notação:

escreva(matriz[0][0])

Exemplo prático de uso de matrizes

Vamos criar e manipular uma matriz de 5 linhas e 3 colunas:

inteiro matriz[5][3]
funcao inicio()
{
    matriz[0][0] = 60
    escreva("Valor: " + matriz[0][0] + "\n")
    escreva("Digite um número: ")
    leia(matriz[1][2])
    escreva("\nValor na posição 1,2: " + matriz[1][2])
}

Manipulação de matrizes com laços de repetição

Para preencher uma matriz com dados digitados pelo usuário, podemos utilizar laços de repetição, como mostra o exemplo a seguir:

inteiro matriz[3][3]
inteiro lin, col
funcao inicio()
{
    para (lin = 0; lin <= 2; lin++ ) 
    {
        para (col = 0; col <= 2; col++ )
        {
        escreva("Digite um número para inserir na matriz: \n")
        leia(matriz[lin][col])
    }
}
    escreva("Valor na posição 0,1: " + matriz[0][1])
}

Visualização da Matriz

Para exibir todos os elementos de uma matriz na tela, podemos utilizar um laço aninhado:

para (lin = 0; lin <= 2; lin++ )
{
    para (col = 0; col <= 2; col++ )
    {
        se (col < 2)
        {
            escreva(matriz[lin][col] + " ")
        }
        senao
        {
            escreva(matriz[lin][col] + "\n")
        }
    }
}

Exercício Resolvido

Vamos criar um algoritmo que gera uma matriz 10×10 preenchida com números aleatórios entre 1 e 100 e exibe a matriz em formato tabular, além de calcular o somatório de todos os valores armazenados:

const inteiro LINHAS = 10
const inteiro COLUNAS = 10
inteiro matriz[LINHAS][COLUNAS]
inteiro soma = 0
funcao inicio()
{
    para (inteiro i = 0; i < LINHAS; i++)
    {
        para (inteiro j = 0; j < COLUNAS; j++)
        {
            matriz[i][j] = aleatorio(1, 100)
            soma = soma + matriz[i][j]
        }
    }
    para (inteiro i = 0; i < LINHAS; i++)
    {
        para (inteiro j = 0; j < COLUNAS; j++)
        {
            escreva(matriz[i][j] + "\t")
        }
        escreva("\n")
    }
    escreva("Somatório dos valores: " + soma)
}

Conclusão

As matrizes são estruturas muito importantes na programação, permitindo a manipulação eficiente de dados em duas dimensões. Compreender como declarar, atribuir e acessar valores em matrizes é essencial para resolver problemas complexos e desenvolver algoritmos eficazes.

Apresentação de Slides: 

Assista ao vídeo da Bóson com Fábio dos Reis no Youtube:

Anterior: Pesquisa Binária em Vetores

Próximo: Escolhas múltiplas com o comando Caso

O post 24 – Lógica de Programação – Matrizes – Declaração e preenchimento apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

A Torre de Hanoi é um famoso quebra-cabeça ou problema matemático, inventado pelo matemático francês François Édouard Anatole Lucas no século XIX, que consiste em mover uma pilha de discos de tamanhos diferentes de uma haste de origem para uma haste de destino, usando uma haste intermediária. A regra básica é que um disco maior nunca pode ficar em cima de um disco menor.

Torre de Hanoi com sete discos e três hastes

A configuração inicial consiste em três hastes (podemos chamá-las de A, B e C) e uma pilha de discos de tamanhos diferentes posicionados em ordem decrescente em uma das hastes (geralmente a haste A). O objetivo é mover todos os discos da haste A para a haste C, utilizando a haste B como intermediária, seguindo as seguintes regras:

1. Apenas um disco pode ser movido por vez.
2. Um disco só pode ser movido se estiver no topo da pilha em sua haste atual.
3. Um disco maior nunca pode ficar em cima de um disco menor.

O desafio é encontrar a sequência correta de movimentos para transferir todos os discos da haste A para a haste C. A solução ótima para a Torre de Hanoi requer 2ⁿ – 1 movimentos, onde n é o número de discos.

Ou seja, com 3 discos é possível resolver a torre em 2³ – 1 = 7 movimentos. Já uma torre com 7 discos necessitará de 2⁷ – 1 = 127 movimentos.

A Torre de Hanoi é um problema clássico de recursão e tem aplicações em algoritmos, programação e teoria da computação para ilustrar conceitos como recursão, pilha de chamadas e complexidade algorítmica.

Algoritmo da Torre de Hanoi

Vejamos um exemplo de algoritmo em Python que resolve uma Torre de Hanoi, recebendo como entrada do usuário o número de discos desejado. Vamos usar uma abordagem recursiva neste exemplo.

Chamaremos as hastes (torres) de A, B e C para identificação ao chamar a função no programa principal, como mostra a figura a seguir:

Hastes das Torres de Hanoi

O objetivo é mover todos os discos da torre A para a torre C. Vamos ao código agora.

def torre_hanoi(n, origem, destino, auxiliar):
    if n == 1:
        print(f"Mova o disco 1 de {origem} para {destino}")
        return
    torre_hanoi(n-1, origem, auxiliar, destino)
    print(f"Mova o disco {n} de {origem} para {destino}")
    torre_hanoi(n-1, auxiliar, destino, origem)

if __name__=='__main__':
    # Exemplo de uso
    n = int(input("Digite o número de discos: "))
    torre_hanoi(n, "A", "C", "B")

Testando:

Digite o número de discos: 
3
Mova o disco 1 de A para C
Mova o disco 2 de A para B
Mova o disco 1 de C para B
Mova o disco 3 de A para C
Mova o disco 1 de B para A
Mova o disco 2 de B para C
Mova o disco 1 de A para C

Funcionamento

Nesse algoritmo, a função torre_hanoi() recebe quatro parâmetros: o número de discos n, a torre de origem origem, a torre de destino destino e a torre auxiliar auxiliar. A função utiliza a recursão para resolver o problema da Torre de Hanoi.

Quando há apenas um disco, ele é movido diretamente da torre de origem para a torre de destino. Caso contrário, a função chama recursivamente a si mesma para mover n-1 discos da torre de origem para a torre auxiliar, em seguida move o disco restante da torre de origem para a torre de destino e, por fim, move os n-1 discos da torre auxiliar para a torre de destino.

O algoritmo exibe as instruções para mover cada disco, indicando de qual torre para qual torre ele deve ser movido. Basta executar o algoritmo informando o número de discos desejado para ver a solução para a Torre de Hanoi.

Modificação do algoritmo

Vamos modificar o algoritmo anterior para que ele mostre também o número de movimentos realizados para resolver a torre:

def torre_hanoi(n, origem, destino, auxiliar):
    if n == 1:
        print(f"Mova o disco 1 de {origem} para {destino}")
    return 1
    movimentos = torre_hanoi(n-1, origem, auxiliar, destino)
    print(f"Mova o disco {n} de {origem} para {destino}")
    movimentos += 1
    movimentos += torre_hanoi(n-1, auxiliar, destino, origem)
    return movimentos

if __name__=='__main__':
    # Exemplo de uso
    n = int(input("Digite o número de discos: "))
    total_movimentos = torre_hanoi(n, "A", "C", "B")
    print(f"Total de movimentos realizados: {total_movimentos}")

Testando:

Digite o número de discos: 
3
Mova o disco 1 de A para C
Mova o disco 2 de A para B
Mova o disco 1 de C para B
Mova o disco 3 de A para C
Mova o disco 1 de B para A
Mova o disco 2 de B para C
Mova o disco 1 de A para C
Total de movimentos realizados: 7

Funcionamento

1. Definimos a função torre_hanoi, que recebe como parâmetros o número de discos n, os nomes das torres origem, destino e auxiliar.

2. Dentro da função, verificamos se n é igual a 1. Se sim, significa que temos apenas um disco a ser movido, então imprimimos a instrução para mover o disco da origem para o destino e retornamos 1, indicando que foi realizado um movimento.

3. Caso contrário, temos mais de um disco. Chamamos recursivamente a função torre_hanoi para mover n-1 discos da origem para a auxiliar, usando o destino como torre auxiliar. Armazenamos o número de movimentos retornados em movimentos.

4. Imprimimos a instrução para mover o disco n da origem para o destino e incrementamos movimentos em 1, já que realizamos mais um movimento.

5. Chamamos novamente recursivamente a função torre_hanoi para mover os n-1 discos restantes da auxiliar para o destino, usando a origem como torre auxiliar. Somamos o número de movimentos retornados ao total de movimentos atual.

6. Retornamos o total de movimentos realizados.

7. No exemplo de uso, solicitamos ao usuário que digite o número de discos desejado.

8. Chamamos a função torre_hanoi passando o número de discos, os nomes das torres “A”, “C” e “B” como argumentos, respectivamente. Armazenamos o total de movimentos retornados em total_movimentos.

9. Por fim, exibimos o total de movimentos realizados na solução.

Conclusão

Concluindo, vimos que a Torre de Hanoi é um enigma matemático fascinante que desafia a mente e tem sido objeto de estudo e entretenimento há muito tempo.

Por meio dos exemplos de algoritmos em Python, ficou claro que a solução para o que aparenta ser um quebra-cabeça complexo é surpreendentemente elegante e simples. Com a implementação da função recursiva (pode ser feito de forma iterativa também), pudemos observar uma abordagem para a resolução da Torre de Hanoi, perfeita para o estudo de recursividade em algoritmos e lógica de programação.

Além de ser uma demonstração de habilidades de programação e lógica, o estudo da Torre de Hanoi oferece insights valiosos para a computação e outras áreas da matemática. Como vimos, é um excelente exercício para compreender a recursividade e a otimização de algoritmos.

Colabore com a Bóson Treinamentos

Ajude o canal adquirindo meus cursos na Udemy:

• Bancos de Dados com MySQL Básico: https://bit.ly/35QdWE4
• Lógica de Programação com Português Estruturado: https://bit.ly/3QKPn22
• Programação em Python do Zero: https://bit.ly/python-boson

Adquira também livros e outros itens na loja da Bóson Treinamentos na Amazon e ajude o canal a se manter e crescer: https://www.amazon.com.br/shop/bosontreinamentos

O post Algoritmo Torre de Hanoi em Python apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Recursividade (ou Recursão) é um conceito em ciência da computação que se refere à capacidade de uma função ou procedimento chamar a si mesmo de forma direta ou indireta durante a sua execução. Em outras palavras, é quando uma função é definida em termos dela mesma.

Ao utilizar a recursividade, uma função pode ser dividida em problemas menores e mais simples, resolvendo-os em etapas sucessivas até alcançar um caso base, que é uma condição que não requer chamadas recursivas e permite a conclusão do processo.

A recursividade é frequentemente usada para resolver problemas que podem ser subdivididos em subproblemas do mesmo tipo. Essa abordagem é especialmente útil quando a estrutura do problema é recursiva por natureza. Alguns exemplos de algoritmos recursivos comuns incluem a busca em árvores, a ordenação rápida (quicksort) e o cálculo do fatorial.

Uma função recursiva geralmente possui dois componentes principais:

1. Caso base: É uma condição especial que determina quando a recursão deve parar. Quando a condição do caso base é atendida, a função recursiva não faz mais chamadas a si mesma e retorna um resultado específico.
2. Caso recursivo: É o caso em que a função se chama novamente com um problema menor ou uma instância simplificada do problema original. A chamada recursiva permite que a função trabalhe em direção ao caso base, resolvendo os subproblemas até que o resultado final seja alcançado.

No entanto, é importante ter cuidado ao usar recursão, pois um uso incorreto ou ineficiente pode levar a problemas de desempenho e até mesmo a erros como estouro de pilha (stack overflow) se não houver controle adequado das chamadas recursivas.

Existem duas categorias gerais de recursividade: Recursão Direta e Recursão Indireta.

Recursão Direta

Em uma recursão direta, uma função f(A) chama a si própria diretamente – f(A) chama f(A), em um passo recursivo único.

Recursão Indireta

Já a recursividade indireta consiste em uma função f(A) que chama uma função diferente f(B), que por sua vez chama f(A) novamente, Ou seja, é um processo recursivo de dois passos, onde a função original chama outra função que por sua vez chama a função original novamente.

Vamos estudar dois exemplos populares de algoritmos recursivos para ver a recursividade em ação: Fatorial e Fibonacci

Exemplos de algoritmos recursivos

Fatorial recursivo

O fatorial de um número inteiro positivo qualquer é dado pela fórmula:

n! = n * (n-1) * (n-2) * … * 1

Por exemplo, 5! é igual a:

5! = 5 * 4 * 3 * 2 * 1 = 120

Note que o fatorial é uma sequência de operações semelhantes, multiplicações cada vez mais básicas até chegar em 1. Perfeito para a recursão!

O fatorial pode ser calculado de forma recursiva de acordo com a seguinte sequência de operações:

Um exemplo de código recursivo em português estruturado é a função fatorial() mostrada a seguir, que calcula o fatorial de um número inteiro passado como argumento:

// Fatorial recursivo
funcao inteiro fatorial(inteiro x) {
  se (x <= 1) {
    retorne 1
  }
  senao {
    retorne x * fatorial(x - 1)
  }
}

Esta função funciona dividindo o problema de calcular o fatorial de um número em dois subproblemas menores: calcular o fatorial de x – 1 e multiplicar o resultado por x. O subproblema de calcular o fatorial de x – 1 é resolvido por uma chamada recursiva para a própria função fatorial().

O resultado da chamada recursiva é então multiplicado por n para obter o resultado do problema original.

Fibonacci recursivo

A série de fibonacci é uma sequência numérica que inicia com 0 e 1 e onde cada número subsequente é a soma dos dois números anteriores a ele:

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, ...

Trata-se de uma série numérica que ocorre repetidamente na natureza e descreve uma forma em espiral. A razão entre dois Fibonaccis sucessivos converge para o valor 1,618…, chamado de “Proporção Áurea”, que é esteticamente muito agradável e aproveitado em várias áreas do conhecimento, como engenharia e arquitetura.

Bem, podemos definir a série de fibonacci recursivamente da seguinte forma:

fibonacci(0) = 0
fibonacci(1) = 1
fibonacci(n) = fibonacci(n-1) + fibonacci(n-2)

Novamente uma sequência de operações semelhantes. Perfeito para a recursão!

A seguir temos um exemplo de código recursivo em português estruturado que calcula um número de Fibonacci a partir de um número inteiro x passado como argumento:

// Função fibonacci recursivo
funcao inteiro fibonacci(inteiro x) {
  se ((x == 0) ou (x == 1)) {
    retorne x
  }
  retorne fibonacci(x-1) + fibonacci(x-2)
}

Quais problemas a recursividade pode causar?

A recursividade é uma técnica de programação que pode ser útil para resolver problemas que podem ser quebrados em subproblemas menores, cada um dos quais pode ser resolvido com uma chamada recursiva. No entanto, a recursividade também pode causar alguns problemas, como:

• Escopo de variáveis: Quando uma função é chamada recursivamente, ela cria uma nova cópia de seu escopo de variáveis. Isso pode levar a problemas se as variáveis no escopo forem modificadas dentro da função.
• Eficiência: Os algoritmos recursivos podem ser muito ineficientes, especialmente para grandes problemas. Isso ocorre porque cada chamada recursiva cria uma nova pilha de chamadas. A pilha de chamadas pode crescer rapidamente e levar a problemas de memória.
• Dificuldade de depuração: Os algoritmos recursivos podem ser difíceis de depurar, pois podem ser difíceis de acompanhar o fluxo de controle da função.

É importante pesar os riscos e benefícios da recursividade antes de usá-la para resolver um problema. Em alguns casos, a recursividade pode ser a melhor solução, mas em outros casos, pode ser melhor usar uma abordagem iterativa. Se não for usada com cuidado, a recursão pode levar a programas que são lentos ou difíceis de entender.

Dicas para usar a recursividade com segurança

• Use a recursividade apenas quando necessário: Não use a recursividade apenas porque é legal. Use-a apenas quando for a melhor maneira de resolver um problema.
• Evite usar recursividade para problemas grandes: Os algoritmos recursivos podem ser muito ineficientes para problemas grandes. Se você estiver enfrentando um problema grande, considere usar uma abordagem iterativa.
• Use a recursividade com cuidado: A recursividade pode ser uma ferramenta poderosa, mas é importante usá-la com cuidado. Se não for usada com cuidado, a recursão pode levar a programas que são lentos, difíceis de entender e difíceis de depurar.

É isso aí! Nas próximas lições veremos mais técnicas de programação e algoritmos específicos que são importantes para estudantes e profissionais na área de desenvolvimento de software.

Colabore com a Bóson Treinamentos

Ajude o canal adquirindo meus cursos na Udemy:

• Bancos de Dados com MySQL Básico: https://bit.ly/35QdWE4
• Lógica de Programação com Português Estruturado: https://bit.ly/3QKPn22
• Programação em Python do Zero: https://bit.ly/python-boson

Adquira também livros e outros itens na loja da Bóson Treinamentos na Amazon e ajude o canal a se manter e crescer: https://www.amazon.com.br/shop/bosontreinamentos

O post O que é Recursividade apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

O que é a sequência de Fibonacci

Como saber se um número pertence à série de Fibonacci?

“Um número é Fibonacci se e apenas se uma ou ambas as expressões 5*n² + 4 ou 5*n² – 4 retornarem um quadrado perfeito.”

Algoritmo em Português Estruturado

programa
{
inclua biblioteca Matematica --> m
inclua biblioteca Tipos --> t

real num
inteiro raiz

  funcao inicio()
  {
  escreva("Descobrir se número é Fibonacci\n")
  escreva("Entre com um número: ")
  leia(num)

  se (eFibonacci(num)) {
      escreva(num + " pertence à série de Fibonacci.")
  }
  senao {
      escreva(num + " não pertence à série de Fibonacci.")
  }
}

  // Função para determinar se número é quadrado perfeito
  funcao logico quadradoPerfeito(real x) {
      raiz = t.real_para_inteiro(m.raiz(x, 2.0))
      retorne raiz * raiz == x
  }

  // Função para verificar se número pertence à série de Fibonacci
  funcao logico eFibonacci(real n){
      // n é Fibonacci se o resultado de 5*n² + 4 ou 5*n² - 4 (ou ambos) for quadrado perfeito.
      retorne quadradoPerfeito(5*n*n + 4) ou quadradoPerfeito(5*n*n - 4)
  }
}

Descobrir se número é Fibonacci
Entre com um número: 17711
17711.0 pertence à série de Fibonacci.

Descobrir se número é Fibonacci
Entre com um número: 12290
12290.0 não pertence à série de Fibonacci.

Algoritmo em Python

import math

# Função que verifica se n é um quadrado perfeito.
def quadradoPerfeito(x):
    raiz = int(math.sqrt(x))
    return raiz*raiz == x
  
# Verifica se número n pertence à série de Fibonacci
# n é Fibonacci se o resultado de 5*n*n + 4 ou 5*n*n - 4 ou ambos
# forem quadrados perfeitos.
def eFibonacci(n):
    return quadradoPerfeito(5*n*n + 4) or quadradoPerfeito(5*n*n - 4)

if __name__=='__main__':
    print("Verificar se número é Fibonacci")
    n = int(input('Digite um número qualquer, positivo: '))

    if(eFibonacci(n)):
        print(f"{n} pertence à série de Fibonacci.")
    else:
        print(f"{n} não pertence à série de Fibonacci.")

O post Algoritmo para verificar se um número pertence à série de Fibonacci apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Algoritmo para verificar se um número é um quadrado perfeito

1. Calculamos a raiz quadrada do número n fornecido.
2. Eliminamos a parte decimal da raiz calculada.
3. Multiplicamos a parte inteira que restou por ela própria.
4. Comparamos o resultado dessa multiplicação com o valor n original.
5. Se os valores forem idênticos, o número é um quadrado perfeito; caso contrário, não o é.

Algoritmo em Português Estruturado

programa
{
inclua biblioteca Matematica --> m
inclua biblioteca Tipos --> t

real n
inteiro raiz 

funcao inicio()
{
  escreva("Verificar se número é quadrado perfeito")
  escreva("\nDigite um número qualquer, positivo: ")
  leia(n)

  se(quadradoPerfeito(n)){
      escreva(n + " é quadrado perfeito.")
  }
  senao {
      escreva(n + " não é quadrado perfeito.")
  }
}

funcao logico quadradoPerfeito(real x) {
  raiz = t.real_para_inteiro(m.raiz(x, 2.0))
  retorne raiz * raiz == x
}
}

Algoritmo em Python

import math

# Função que retorna true se n for quadrado perfeito, e false se não for.
def quadradoPerfeito(x):
    raiz = int(math.sqrt(x))
    return raiz*raiz == x

if __name__=='__main__':
    print("Verificar se número é quadrado perfeito")
    n = float(input('Digite um número qualquer, positivo: '))
    if(quadradoPerfeito(n)):
        print(f"{n} é quadrado perfeito.")
    else:
        print(f"{n} não é quadrado perfeito.")

O post Algoritmo para verificar se número é quadrado perfeito apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

A série de Fibonacci é uma sequência numérica infinita em que cada número subsequente é a soma dos dois números anteriores. A sequência começa com os números 0 e 1, e a partir deles, cada número seguinte é calculado somando os dois números anteriores.

Portanto, a sequência começa da seguinte forma:

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, e assim por diante.

A sequência começa em 0 e 1, porém alguns autores dizem que a sequência começa em 1 e 1, e o próprio Fibonacci iniciava a sequência em 1 e 2.

O algoritmo para gerar a sequência permanece o mesmo para todos os casos, com ajustes mínimos no valor inicial.

Por conta desse padrão numérico interessante, a série de Fibonacci é amplamente estudada e aplicada em vários campos, como matemática, ciência da computação, biologia, arte e finanças.

Além disso, a proporção entre os números adjacentes na sequência de Fibonacci, chamada de “razão áurea”, “proporção áurea” ou “número de ouro”, que é aproximadamente 1,618, é considerada esteticamente agradável e é encontrada em muitas formas naturais, como conchas, flores e galáxias (descrevendo uma forma em espiral), além de ser utilizada em projetos de arquitetura e design.

Espiral que representa a sequência de Fibonacci

Neste tutorial vou mostrar como criar algoritmos para lógica de programação com Portugol que permitem gerar a sequência de Fibonacci, tanto de forma recursiva quanto iterativa.

De onde vem o nome “Fibonacci”?

Fibonacci, cujo nome verdadeiro era Leonardo de Pisa, foi um matemático italiano do século XIII. Ele é mais conhecido por introduzir a sequência numérica que leva seu nome, a sequência de Fibonacci, em seu livro “Liber Abaci” (Livro do Ábaco), publicado em 1202. Fibonacci significa filius Bonacci, ou filho de Bonaccio

Fibonacci viajou extensivamente pelo Mediterrâneo e estudou os sistemas numéricos usados na época, incluindo o sistema de numeração hindu-arábico. Ele ficou fascinado pelas propriedades matemáticas desses sistemas e, em seu livro, introduziu essa sequência numérica como um exemplo de progressão aritmética encontrada em um problema envolvendo a reprodução de coelhos.

Leonardo de Pisa, o Fibonacci

Embora não tenha sido o descobridor da sequência em si, Fibonacci popularizou a sequência e demonstrou suas propriedades matemáticas e aplicações em várias áreas. Seu trabalho teve um impacto duradouro na matemática e continua sendo estudado e aplicado até hoje.

Curiosidade: O nome “sequência de Fibonacci” foi empregado pela primeira vez pelo matemático francês François Édouard Anatole Lucas, no século XIX (o mesmo matemático que inventou a Torre de Hanói).

Algoritmo de Fibonacci Recursivo

Podemos definir a série de fibonacci recursivamente da seguinte forma:

Casos base:
fibonacci(0) = 0
fibonacci(1) = 1

Caso geral:
fibonacci(n) = fibonacci(n-1) + fibonacci(n-2)

Uma sequência de operações semelhantes. Perfeito para a recursão!

Exemplo: Qual o terceiro valor de Fibonacci da sequência?

fib(3) = ?
fib(3) = fib(3-1) + fib(3-2) →
fib(3) = fib(2) + fib(1) →
fib(3) = fib(2-1) + fib(2-2) + 1 →
fib(3) = fib(1) + fib(0) + 1 →
fib(3) = 1 + 0 + 1 →
fib(3) = 2

Isso significa que o terceiro fibonacci (assumindo que o primeiro é o zerésimo valor) é o número 2:

Vamos criar um algoritmo usando o Portugol Studio para obter a sequência de fibonacci com a quantidade de elementos determinados pelo usuário:

programa
{

inteiro num

funcao inicio()
{

  escreva("Obter sequência de Fibonacci\n")
  escreva("Entre com um número: ")
  leia(num)
  escreva(num + "º fibonacci: " + fibonacci(num) + "\n") 

  escreva("\nMostrar a sequência completa:\n")
  para (inteiro i = 0; i < num; i++) {
    escreva(fibonacci(i) + " ")
  }

}

// Função fibonacci recursivo
funcao inteiro fibonacci(inteiro x) {
  se ((x == 0) ou (x == 1)) {
      retorne x
  }
  retorne fibonacci(x-1) + fibonacci(x-2)
}

}

1. A função “fibonacci()” recebe um número inteiro x como parâmetro.
2. Primeiro, ela verifica se x é igual a 0 ou 1 usando a condição ((x == 0) ou (x == 1)). Esses são os casos base da sequência de Fibonacci, em que o valor é conhecido e não precisa ser calculado. Se x for igual a 0 ou 1, a função retorna o próprio valor de x, utilizando a instrução “retorne x“.
3. Se o valor de x não for 0 ou 1, a função chama a si mesma para calcular os termos anteriores necessários para calcular o valor atual. Ela retorna a soma dos resultados de duas chamadas recursivas: fibonacci(x-1) e fibonacci(x-2).
   fibonacci(x-1) calcula o valor do termo anterior ao termo x.
   fibonacci(x-2) calcula o valor do termo dois lugares antes do termo x.
   A soma desses dois valores representa o valor do termo x na sequência de Fibonacci.
4. A função continua a se chamar recursivamente até que atinja um dos casos base (x = 0 ou x = 1), momento em que retorna o valor correspondente.
5. A função retorna o valor do termo de Fibonacci correspondente ao número x fornecido.

Algoritmo de Fibonacci Iterativo

programa
{

inteiro num

funcao inicio()
{

  escreva("Obter sequencia de Fibonacci\n")
  escreva("Entre com um número: ")
  leia(num)
  
  escreva("\nMostrar a sequência completa:\n")
  para (inteiro i = 1; i <= num; i++) {
    escreva(fibonacci(i) + " ")
  }

}

// Função fibonacci iterativo
funcao inteiro fibonacci(inteiro x) {
  inteiro antepNum, penNum = 0, numAtual = 1

  se ((x == 0) ou (x == 1)) {
       retorne x
  }
  para (inteiro i = 2; i <= x; i++) {
    antepNum = penNum
    penNum = numAtual
    numAtual = antepNum + penNum
  }
  retorne numAtual
}

}

1. A função “fibonacci()” recebe um número inteiro x como parâmetro.
2. Em seguida, três variáveis inteiras são declaradas: antepNum, penNum e numAtual. Inicialmente, antepNum e penNum são definidos como 0, e numAtual é definido como 1. Essas variáveis são usadas para acompanhar os valores dos termos anteriores e atual da sequência de Fibonacci.
3. É iniciado um loop “para” com uma variável de controle inteira i, que começa em 2 e vai até x. Esse loop irá iterar x-2 vezes, pois os primeiros termos já são conhecidos.
4. Dentro do loop, os valores antigos são atualizados para avançar na sequência de Fibonacci. A variável antepNum recebe o valor de penNum, que é o termo anterior, e penNum recebe o valor de numAtual, que é o termo atual.
5. Em seguida, a variável numAtual é atualizada somando antepNum e penNum. Essa soma representa o próximo termo da sequência de Fibonacci.
6. O loop continua até que i alcance o valor x, momento em que todos os termos necessários terão sido calculados.
7. Após o término do loop, a função retorna o valor de numAtual, que é o termo de Fibonacci correspondente ao número x fornecido.

Comparação entre fibonacci iterativo e recursivo

O post Algoritmo para Fibonacci Recursivo e Iterativo – Lógica de Programação apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Como calcular os dígitos verificadores do CPF: Exemplo

Passo 1 – Calcular DV1:

Passo 2 – Calcular DV2:

Algoritmo em Portugol para calcular o dígito verificador de um CPF     

programa
{

inclua biblioteca Texto --> t
inclua biblioteca Tipos --> ti
cadeia cpf
inteiro cpf_digitos[11]
inteiro digito1, digito2
logico res = falso

funcao inicio()
{

  escreva("Digite o CPF: ")
  leia(cpf)

  para (inteiro i = 0; i < 11; i++) {
    cpf_digitos[i] = ti.caracter_para_inteiro(t.obter_caracter(cpf, i))
  }

  res = ValidaCPF(cpf_digitos)

  se  (res == verdadeiro) {
    escreva("CPF válido!")
  }
  senao {
    escreva("CPF inválido!")
  }

}

  funcao logico ValidaCPF(inteiro num[]) {
    inteiro i, j, soma, resto, dv1, dv2

    // Dígito verificador #1
    soma = 0
    j = 10

    para (i = 0; i < 9; i++) {
      soma += num[i] * j
      j -= 1
    }

    resto = soma % 11

    se (resto < 2) {
      dv1 = 0
    }
    senao {
      dv1 = 11 - resto
    }

    // Dígito verificador #2
    soma = 0
    j = 11

    para (i = 0; i < 10; i++) {
      soma += (num[i]) * j
      j -= 1
    }

    resto = soma % 11

    se (resto < 2) {
      dv2 = 0
    }
    senao {
      dv2 = 11 - resto
    }

    se ((num[9] == dv1) e (num[10] == dv2)) {
      retorne verdadeiro
    }
    senao {
      retorne falso
    }

  }

}

1. Dentro da função inicio(), o programa solicita ao usuário que digite o CPF e lê o valor digitado, armazenando-o na a variável cpf.
2. Em seguida, o programa percorre cada caractere do CPF digitado e os converte para números inteiros, armazenando-os no array cpf_digitos.
3. O programa então chama a função ValidaCPF passando o array cpf_digitos como argumento, e armazena o resultado retornado na variável booleana res.
4. O programa verifica se res é verdadeiro, ou seja, se a função ValidaCPF retornou verdadeiro. Se sim, imprime a mensagem “CPF válido!”. Caso contrário, imprime a mensagem “CPF inválido!”.

E se preferir, assista a um vídeo da Bóson Treinamentos onde explico como implementar esse algoritmo para testes:

O post Algoritmo para validação de CPF (dígitos verificadores) – Lógica de Programação apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Neste post trago um questionário de Lógica de Programação e Algoritmos, contendo 25 questões de múltipla escolha sobre tópicos variados dentro do assunto, como variáveis, tipos de dados, condicionais, arrays, laços de repetição e muitos outros.

No final da página há um gabarito com as respostas das questões para você avaliar seu conhecimento no assunto, e assim descobrir quais pontos precisa estudar melhor ou revisar.

Bom questionário!

Questões

1. Sequência de comandos ordenados, infinitos e ambíguos que são empregados para executar uma tarefa.
2. Sequência de instruções ordenadas, infinitas e não-ambíguas que são empregadas para executar uma tarefa.
3. Sequência de instruções ordenadas, finitas e não-ambíguas que são empregadas para executar uma tarefa.
4. Sequência de comandos ordenados, infinitos e não-ambíguos que são empregados para executar uma tarefa.
5. Sequência de comandos desordenados, infinitos e não-ambivalentes que são empregados para executar uma tarefa.

1. Inteiro, Temporal, Caractere, Double
2. Booleano, Real, Inteiro, Irracional
3. Inteiro, Booleano, Tipografia, Double
4. Inteiro, Booleano, Caractere, Double
5. Temporal, Triple, Caractere, Double

var
   num : inteiro
início
   num <- 1
   enquanto (num <= 10) faca
     escreval (num)
     num <- num += 0
   fimenquanto
   se (num > 10) entao
     escreva(num)
   fimse
fimalgoritmo

1. Loop Truncado
2. Loop Infinito
3. Erro de Compilação
4. Bloco SE sem SENAO
5. Declaração das Variáveis

1. Verdadeiro, Duvidoso
2. Falso, Duvidoso, Verdadeiro
3. Incerto, Certo
4. Verdadeiro, Falso
5. Verdadeiro, Errado

1. AND
2. XOR
3. NOT
4. NAND
5. OR

1. Salário de um Funcionário
2. Valor da Temperatura no final de semana
3. Valor matemático de Pi
4. Distância da Terra à Lua
5. Velocidade de um carro em movimento

1. Não, somente é possível ter valores em ordem se os valores forem inseridos em ordem
2. Sim, mas somente se os números forem inteiros. Números decimais não podem ser ordenados
3. Sim, mas para isso é necessário usar um algoritmo para ordenação de vetores
4. Vetores não permitem o armazenamento de números decimais, somente números reais
5. Não, não é possível ordenar valores já armazenados em um vetor em nenhuma hipótese

1. Array Unidimensional de 3 posições, de nome N
2. Array Bidimensional de 4 posições, sem nome
3. Vetor Bidimensional de 4 posições, com nome não atribuído
4. Array Unidimensional de 4 posições, de nome N
5. Vetor Quadridimensional, de nome N

1. Unidimensional (linha), Bidimensional (vetor), Tridimensional (cubo)
2. Dimensional (com dimensões), Adimensional (sem dimensões), Paradimensional (com e sem dimensões)
3. Unidimensional (vetor), Bidimensional (quadrado), Tridimensional (esfera)
4. Unidimensional (vetor), Bidimensional (matriz), Tridimensional (cubo)
5. Unidimensional (ponto), Bidimensional (matriz), Tridimensional (campo)

1. nome Aluno, nota2, CEP, RuaNumero
2. nomeAluno, 2nota, CEP, RuAnUmErO
3. nomeAluno, nota2, CEP, RuAnUmErO
4. nomeAluno, nota2, CEP, Rua+Número
5. AlunoNumero, nota00002, cep, ruaComNumeroDaCasa

para CONTA de 1 ate 9 faca
 para CONTB de CONTA + 1 ate 10 faca
   se VET[CONTA] > VET[CONTB] entao
    AUX < -VET[CONTB]
    VET[CONTB] <- VET[CONTA]
    VET[CONTA] <- AUX
   fimse
 fimpara
fimpara

1. Realiza busca binária em um array
2. Compara valores usando estrutura condicional SE
3. Realiza busca sequencial em um array
4. Ordena os elementos de um array
5. Insere elementos em uma lista de valores

1. Comandos contidos no código-fonte são executados à medida em que são traduzidos, sendo necessária a interpretação toda vez que se quiser rodar o programa.
2. Tradução do código-fonte em um ou mais arquivos que podem ser armazenados e executados quantas vezes se desejar, sem necessitar de nova compilação.
3. Junção de comandos do código-fonte em um arquivo empacotado para distribuição por um meio específico para instalação do programa.
4. Execução das instruções contidas em um script contendo o código-fonte, de forma sequencial.
5. Organização do código-fonte em uma pasta contendo arquivos em ordem alfabética

1. salarios : vetor [0..15] de real
2. salarios : vetor [1..15] de numeros
3. salarios : vetor [0..14] de salario
4. salarios : vetor [0..14] de inteiro
5. salarios : vetor [0..14] de real

1. para (con = 1; con < 10; con–) { instruções }
2. para (con = 10; con >= 1; con++) { instruções }
3. para (con = 10; con < 10; con–) { instruções }
4. para (con = 1; con <= 10; con++) { instruções }
5. para (con == 10; con > 1; con–) { instruções }

1. Entrada / Saída, Processo, Decisão
2. Decisão, Início / Fim, Repetição
3. Entrada / Saída, Repetição, Decisão
4. Decisão, Processo, Entrada / Saída
5. Processo, Decisão, Repetição

1. Local na memória CMOS do computador empregado para armazenar de forma temporária os dados que são utilizados pelo programa.
2. Valor que varia conforme passa o tempo, sendo sempre modificado conforme o programa vai sendo executado.
3. Estado lógico de uma constante, que pode variar entre verdadeiro e falso
4. Local na memória RAM do computador utilizado para armazenar temporariamente dados que são utilizados pelo programa.
5. Valor armazenado em locais variáveis no computador, como HD, RAM ou Memória Cache.

1. Podemos acessar todos os elementos individuais de uma array por meio de uma posição de índice, começando sempre em 1.
2. Um array é uma estrutura que pode armazenar uma série de elementos de dados de mesmo tipo.
3. Um array é uma estrutura que permite armazenar até 10 elementos de dados, sempre do mesmo tipo
4. Podemos acessar os elementos individuais de uma array por meio de uma posição de índice, começando em A.
5. Um vetor é uma estrutura bidimensional que pode armazenar uma série de elementos de dados de tipos diferentes.

1. Decisão Condicional Simples
2. Decisão Condicional Composta
3. Decisão Condicional Encadeada
4. Decisão Condicional Complexa
5. Decisão Condicional Aninhada

1. Um laço while repete o bloco de código associado enquanto um teste lógico realizado retornar falso.
2. Um laço while não repete o bloco de código associado enquanto um teste lógico realizado retornar verdadeiro.
3. Um laço while repete o bloco de código associado um número de vezes específico, determinado em sua declaração.
4. Um laço while espera enquanto o usuário não pressiona uma tecla para decidir qual caminho tomar no fluxo do algoritmo
5. Um laço while repete o bloco de código associado enquanto um teste lógico realizado retornar verdadeiro

1. Operador que realiza cálculo de porcentagens
2. Realizar cálculos aritméticos de investimentos
3. Retornar o módulo matemático (valor absoluto)
4. Calcular o resto de uma divisão inteira
5. Calcular o retorno de uma função variável

1. AND retorna V apenas se todas as expressões de entrada forem verdadeiras, e o OR retorna V se ao menos uma delas for verdadeira
2. OR retorna V apenas se todas as expressões de entrada forem verdadeiras, e o AND retorna V se ao menos uma delas for verdadeira
3. AND retorna F apenas se todas as expressões de entrada forem verdadeiras, e o OR retorna F se ao menos uma das expressões de entrada for verdadeira
4. AND retorna F apenas se todas as expressões de entrada forem verdadeiras, e o OR retorna F se todas as expressões de entrada forem verdadeiras
5. OR retorna V apenas se todas as expressões de entrada forem falsas, e o AND retorna V se ao menos uma delas for verdadeira

1. +
2. *
3. →
4. ;
5. ” “

escolha (opção) {
    caso valor1:
        comandos a executar
        pare
    caso valor2:
        comandos a executar
        pare
    caso valor3:
        comandos a executar
        pare
    caso contrario:
        comandos-padrão
}

1. Para parar de executar os comandos do caso selecionado
2. Para parar a comparação dos próximos valores com a opção
3. Para encerrar o programa
4. Para pular a execução do caso atual e realizar o loop
5. Nenhuma das opções anteriores

1. Para que os usuários possam consultar e tomar emprestados livros de assuntos variados
2. Para que os programadores possam consultar a documentação da linguagem com facilidade
3. Uma biblioteca é um programa que permite escrever e testar código-fonte, também conhecida como IDE.
4. Para modularizar o desenvolvimento de estruturas de comparação e repetição
5. Uma biblioteca é um arquivo que organiza código pré-definido para o uso em aplicações

1. Uma planilha do Excel
2. Uma tabela de banco de dados
3. Um vetor de 16 posições
4. Uma cartela de bingo
5. Um array de duas dimensões (matriz)

RESPOSTAS

1. C
2. D
3. B
4. D
5. E
6. C
7. C
8. D
9. D
10. C, E
11. D
12. B
13. E
14. D
15. D
16. D
17. B
18. B
19. E
20. D
21. A
22. A
23. B
24. E
25. E

Espero que você tenha ido bem. Se precisar revisar ou aprender algum tópico relacionado, não deixe de consultar os artigos de Lógica de Programação aqui do blog, ou ainda o Curso Completo de Lógica de Programação em vídeo no canal do YouTube da Bóson Treinamentos em Tecnologia.

O post Questionário de Lógica de Programação com respostas apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Um algoritmo de pesquisa binária é um método bastante eficiente para encontrar um determinado valor em um vetor ordenado. Ele funciona dividindo repetidamente o vetor ao meio (por isso “binário”) até que o valor desejado seja encontrado ou seja determinado que o valor não está presente no vetor.

Como funciona uma algoritmo de pesquisa binária

O funcionamento do algoritmo de pesquisa binária é o seguinte:

1. Definir os limites inferior e superior do vetor. O limite inferior é definido como o índice 0 e o limite superior como o índice do último elemento do vetor.
2. Calcular o índice médio como a média dos limites inferior e superior: índice médio = (limite inferior + limite superior) / 2.
3. Comparar o valor desejado com o elemento do vetor no índice médio.
4. Se o valor desejado for igual ao elemento do índice médio, a pesquisa é bem-sucedida e o índice médio é retornado como o índice onde o valor foi encontrado.
5. Se o valor desejado for menor que o elemento do índice médio, a pesquisa será repetida no subvetor à esquerda do índice médio. O novo limite superior será definido como o índice médio – 1 e o passo 2 será repetido.
6. Se o valor desejado for maior que o elemento do índice médio, a pesquisa será repetida no subvetor à direita do índice médio. O novo limite inferior será definido como o índice médio + 1 e o passo 2 será repetido.
7. Repetir os passos 2 e 3 até que o valor desejado seja encontrado ou os limites inferior e superior se cruzem. Se os limites inferior e superior se cruzarem sem encontrar o valor desejado, isso significa que o valor não está presente no vetor.

No vídeo a seguir explico com detalhes como realizar a pesquisa binária em vetores, usando português estruturado.

Códigos usados no vídeo

algoritmo "Pesquisa Binária"
 // Função : Estudar a pesquisa binária em vetores
 // Autor : Fábio dos Reis
 // Data : 18/09/2013
 var
 CONTADORA, CONTADORB: inteiro
 NUM, AUX: inteiro
 VET: vetor[1..10] de inteiro
 BUSCA: inteiro

 //Variáveis para busca binária:
 inicial, final, meio: inteiro
 dado_encontrado: logico

 inicio
 //Preencher o array criado

para CONTADORA de 0 ate 1 faca
   para CONTADORB de CONTADORA + 1 ate 2 faca
      se VET[CONTADORA] > VET[CONTADORB] entao
         AUX <-VET[CONTADORB]
         VET[CONTADORB] <- VET[CONTADORA]
         VET[CONTADORA] <- AUX
      fimse
   fimpara
fimpara

 //Exibir o vetor ordenado
 escreval ("Vetor ordenado. Preparado para busca binária:")
 para CONTADORA de 1 ate 10 faca
    escreval(VET[CONTADORA])
 fimpara
 escreval()

//Entrar com valor a pesquisar no vetor
 escreva ("Digite um valor para procurar no vetor:")
 leia (busca)

//Efetuar a pesquisa binária
inicial <- 1
final <- 10
dado_encontrado <- falso

enquanto (inicial <= final) e nao dado_encontrado faca
   meio <- (inicial + final) DIV 2
   se VET[meio] = busca entao
      dado_encontrado <- verdadeiro
   fimse
   se VET[meio] > busca entao
      final <- meio - 1
   senao
      inicial <- meio + 1
   fimse
fimenquanto

//Exibir Resultados da busca
se dado_encontrado = verdadeiro entao
  escreva ("Dado encontrado na posição", meio)
senao
  escreva ("Informação não encontrada no vetor")
fimse
fimalgoritmo

Conclusão

O algoritmo de pesquisa binária é eficiente porque a cada iteração, a metade do vetor é descartada como candidata, reduzindo pela metade o espaço de pesquisa. Em vez de percorrer linearmente todo o vetor, o algoritmo aproveita a ordenação do vetor para realizar buscas rápidas.

É importante notar que o algoritmo de pesquisa binária requer que o vetor esteja ordenado em ordem crescente ou decrescente. Caso contrário, o algoritmo não funcionará corretamente. Além disso, o desempenho do algoritmo de pesquisa binária é mais eficiente em vetores grandes, onde a diferença entre os métodos de pesquisa linear e binária se torna mais evidente.

O post 23 – Lógica de Programação – Pesquisa Binária em Vetores (Arrays) apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Neste artigo trago alguns exercícios com resolução de Lógica de Programação, usando o software Portugol Studio.

Os exercícios listados aqui cobrem os assuntos Variáveis e Tipos de Dados, Constantes, Operadores variados e Comandos de Entrada e Saída em lógica de programação. Os códigos de resolução dos exercícios estão no final da postagem, logo após a listagem de exercícios.

Bons estudos!

Exercício 1

Escreva um algoritmo que:

1. Pergunte o nome de uma pessoa;
2. Pergunte qual o sobrenome da pessoa;
3. Mostre o nome completo na tela

Exercício 2

Escreva um algoritmo que leia dois valores numéricos e depois mostre a diferença entre eles (o primeiro menos o segundo).

Exercício 3

Crie um algoritmo que leia dois números nas variáveis numA e numB, nessa ordem, e os mostre na tela em ordem inversa, isto é, se os dados lidos forem 7 e 15, por exemplo, devem ser mostrados na ordem 15 e 7, um embaixo do outro (em linhas distintas).

Exercício 4

O sistema de avaliação de determinada disciplina é composto por três provas. A primeira prova tem peso 2, a segunda tem peso 3 e a terceira tem peso 5.

Elabore um algoritmo que calcule a média final de um aluno desta disciplina.

Dica: Neste caso você irá usar uma Média Aritmética Ponderada. Caso tenha dúvidas sobre esse tipo de cálculo, recomendo assistir a esse vídeo: Média Ponderada – Como calcular

Exercício 5

Crie um programa no qual o usuário deverá inserir os valores da altura, largura e profundidade de uma caixa d’água, em cm. No final, exiba o volume dessa caixa d’água.

Dica: Volume = Altura x Largura x Profundidade

Exercício 6

Crie um programa que peça para o usuário informar os valores da base e da altura de um triângulo, em centímetros,, e então mostre na tela o valor da área desse triângulo.

Dica: Área do triângulo = Base x Altura / 2

Exercício 7

Escreva um algoritmo que leia a velocidade de um veículo em km/h, e então calcule e exiba na tela a velocidade convertida em m/s (metros por segundo).

O algoritmo deve também informar quanto tempo irá levar uma viagem na velocidade média informada de São Paulo até o Rio de Janeiro.

Dicas: Para converter de km/h para m/s divida a velocidade pelo fator 3,6. Considere a distância aproximada de São Paulo até o Rio de Janeiro como sendo de 435 km.

Resolução dos Exercícios de Lógica de Programação

Exercício 1

programa
{
  cadeia nome, sobrenome
  funcao inicio()
  {
    escreva("Qual o seu nome? ")
    leia(nome)
    escreva("Qual o seu sobrenome? ")
    leia(sobrenome)
    escreva("Nome completo: " + nome + " " + sobrenome)
  }
}

Exercício 2

programa
{
  inteiro num1, num2, resultado
  funcao inicio()
  {
    escreva("Digite um número inteiro:\n")
    leia(num1)
    escreva("Digite outro número inteiro:\n")
    leia(num2)
    result = num1 - num2
    escreva(num1 + " - " + num2 + " = " + resultado)
  }
}

Exercício 3

programa
{
  inteiro numA, numB
  funcao inicio()
  {
    escreva("Digite um número: ")
    leia(numA)
    escreva("Digite outro número: ")
    leia(numB)
    escreva(numB + "\n" + numA)
  }
}

Exercício 4

programa
{
  real p1, p2, p3, media
  funcao inicio()
  {
    escreva("Qual a primeira nota? ")
    leia(p1)
    escreva("Qual a segunda nota? ")
    leia(p2)
    escreva("Qual a terceira nota? ")
    leia(p3)
    media = (p1 * 2 + p2 * 3 + p3 * 5) / 10
    escreva("Média final: " + media)
  }
}

Exercício 5

programa
{
  inteiro altura, largura, profundidade, volume
  funcao inicio()
  {
    escreva("Qual a altura da caixa d´água em cm? ")
    leia(altura)
    escreva("Qual a largura da caixa d´água em cm? ")
    leia(largura)
    escreva("Qual a profundidade da caixa d´água? em cm ")
    leia(profundidade)
    volume = altura * largura * profundidade
    escreva("A caixa d´água tem capacidade de " + volume + " cm³")
  }
}

Exercício 6

programa
{
  inteiro base, altura, area
  funcao inicio()
  {
    escreva("Qual o valor da base do triângulo, em cm? ")
    leia(base)
    escreva("E qual a altura desse triângulo, em cm? ")
    leia(altura)
    area = base * altura / 2
    escreva("A área do triângulo é de " + area + " cm²")
  }
}

Exercício 7

programa
{
  real velKmH, velMS, tempo
  funcao inicio()
  {
    escreva("Qual a velocidade do veículo, em km/h? ")
    leia(velKmH)
    velMS = velKmH / 3.6
    tempo = 435 / velKmH
    escreva("A velocidade do veículo é de " + velMS + "m/s\n")
    escreva("Uma viagem de São Paulo para o Rio irá levar " + tempo + "horas")
  }
}

O post Exercícios de Lógica de Programação – Variáveis, Operadores e Comandos de Entrada e Saída apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.