Neste tutorial trago um algoritmo simples, escrito em Fortran, que permite encontrar os números primos de 1 até um valor n, informado pelo usuário durante a execução do programa, para isso usando o algoritmo clássico conhecido como Crivo de Eratóstenes.

Números primos são números naturais maiores que 1 que têm apenas dois divisores: 1 e eles mesmos. Em outras palavras, são números que não podem ser divididos por nenhum outro número além de 1 e deles mesmos sem resultar em um resto.

Exemplos de números primos incluem 2, 3, 5, 7 e 11.

A propriedade fundamental dos números primos é que não podem ser formados multiplicando dois números inteiros diferentes entre si. A compreensão dos números primos é crucial em matemática, e sua identificação desempenha um papel fundamental em áreas como criptografia e teoria dos números.

O Crivo de Eratóstenes é um algoritmo antigo e eficiente para encontrar todos os números primos até um determinado limite. Ele funciona marcando os múltiplos de cada número primo encontrado, eliminando números compostos e deixando apenas os números primos. O algoritmo realiza iterações até que todos os números até o limite desejado sejam verificados.

Trata-se de uma maneira bastante eficaz de encontrar rapidamente todos os números primos dentro de um intervalo específico.

De acordo com a tradição, o Crivo de Eratóstenes foi criado pelo matemático grego Eratóstenes de Cirene por volta de 240 a.C., sendo assim uma das técnicas mais antigas conhecidas para encontrar números primos.

Busto de Eratóstenes

Neste tutorial vamos implementar este algoritmo usando a linguagem de programação Fortran.

Funcionamento do Crivo de Eratóstenes

O algoritmo do Crivo de Eratóstenes funciona da seguinte maneira:

1. Inicialização:
   Começamos criando uma lista de números a partir de 2 até o valor limite desejado pelo usuário.
   Marcamos todos esses números como não riscados, indicando que inicialmente consideramos todos como primos.
2. Seleção do Próximo Número:
   Começamos com o primeiro número não riscado, que é o 2.
   Este número é então marcado como primo, já que é o menor número não riscado (e 2 é o primeiro número primo).
3. Eliminação dos Múltiplos:
   Agora vamos riscar todos os múltiplos do número primo que acabamos de encontrar, até chegar no valor limite.
   No caso, riscamos todos os múltiplos de 2 (4, 6, 8, 10, 12, …).
4. Seleção do Próximo Número Não Riscado:
   Após riscar os múltiplos do número anterior, vamos nos mover para o próximo número não riscado na lista, que é o próximo número primo.
5. Repetição:
   Repetimos os passos 3 e 4 até que tenhamos marcado todos os números não riscados como primos ou não primos.

Ao final do processo, os números que permanecem não riscados são os números primos dentro do intervalo desejado. O Crivo de Eratóstenes é eficiente porque evita a verificação de múltiplos de números que já foram marcados como não primos, reduzindo significativamente o número de iterações necessárias.

Visualmente, o que o crivo de Eratóstenes equivale ao seguinte:

	0	1	2	3	4	5	6	7	8	9
0	1	2	3	4	5	6	7	8	9	10
1	11	12	13	14	15	16	17	18	19	20
2	21	22	23	24	25	26	27	28	29	30
3	31	32	33	34	35	36	37	38	39	40
4	41	42	43	44	45	46	47	48	49	50
5	51	52	53	54	55	56	57	58	59	60
6	61	62	63	64	65	66	67	68	69	70
7	71	72	73	74	75	76	77	78	79	80
8	81	82	83	84	85	86	87	88	89	90
9	91	92	93	94	95	96	97	98	99	100

Podemos ver que os números primos estão destacados (check verde), ao passo que os números múltiplos, que não são primos, são descartados (x vermelho).

Este algoritmo é bastante empregado em matemática computacional e é uma abordagem clássica para encontrar números primos.

Vejamos agora como implementar esse algoritmo usando uma linguagem de programação – no caso, o Fortran.

Código em Fortran

program CrivoDeEratostenes
implicit none

integer, parameter :: MAX_N = 1000000
integer :: n
logical :: e_primo(MAX_N)
integer :: i, j

! Inicializar o vetor de primos como verdadeiro
e_primo = .true.

! Solicitar ao usuário que insira o valor de 'n'
write(*,*) 'Digite um número inteiro positivo n:'
read(*,*) n

! Verificar se o valor de n está dentro dos limites permitidos para números primos
if (n <= 1 .or. n > MAX_N) then
    write(*,*) 'Valor de n fora dos limites permitidos.'
    stop
end if

! Algoritmo do Crivo de Eratóstenes
do i = 2, n
    if (e_primo(i)) then
        do j = 2*i, n, i
            e_primo(j) = .false.
        end do
    end if
end do

! Exibir os números primos encontrados
write(*,*) 'Números primos de 1 até', n, ':'
do i = 2, n
    if (e_primo(i)) then
        write(*,*) i
    end if
end do

end program CrivoDeEratostenes

Teste

Para testar, vamos pedir ao programa para retornar todos os números primos até o valor 500.000 (quinhentos mil!):

Resultado (truncado):

2
3
5
7
11
...
499943
499957
499969
499973
499979

Explicação do Código

E como exatamente funciona esse código? Vejamos uma explicação passo a passo:

1. Declaração de Variáveis – Começamos declarando algumas variáveis:

• MAX_N: Valor máximo permitido para n (limite superior para encontrar números primos).
• n: Número que será fornecido pelo usuário.
• e_primo: Um array lógico que indica se um número é primo (TRUE) ou não (FALSE).
• i e j: Índices para iteração.

2. Inicialização:

• e_primo = .TRUE.: Inicializa o vetor de primos como verdadeiro.

3. Entrada do Usuário:

• write(*,*) ‘Digite um número inteiro positivo n:’: Solicita ao usuário que insira um número inteiro positivo.
• read(*,*) n: Lê o valor inserido pelo usuário.

4. Verificação do Limite:
– if (n <= 1 .or. n > MAX_N) then: Verifica se o valor de n está dentro dos limites permitidos para números primos.
– write(*,*) ‘Valor de n fora dos limites permitidos.’: Exibe uma mensagem de erro se o valor de n estiver fora dos limites.
– stop: Encerra o programa.

5. Algoritmo do Crivo de Eratóstenes:
– A estrutura de repetição do i = 2, n itera sobre todos os números de 2 até n.
– if (e_primo(i)) then: Verifica se i é marcado como primo.
– A estrutura de repetição interna do j = 2*i, n, i marca todos os múltiplos de i como não primos, já que eles são divisíveis por i.

6. Saída dos Números Primos Encontrados:
– write(*,*) ‘Números primos de 1 até’, n, ‘:’: Exibe uma mensagem indicando que os números primos estão sendo mostrados.
– A segunda estrutura de repetição do i = 2, n itera sobre todos os números de 2 até n.
– if (e_primo(i)) then: Verifica se i é marcado como primo.
– write(*,*) i: Exibe o número primo.

Conclusão

Neste artigo vimos como empregar a técnica do Crivo de Eratóstenes para determinar números primos na linguagem de programação Fortran. Esse mesmo código pode ser adaptado para outras linguagens, como Python, C++, C# ou Rust, de acordo com sua necessidade.

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 Calcular números primos com Crivo de Eratóstenes em Fortran apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Neste tutorial vamos escrever um pequeno programa em linguagem Python que irá gerar uma lista com os números de 1 até 1000 (sequenciais), colocados depois em ordem aleatória, e então retirar um único número dessa lista, de forma aleatória também (não sabemos qual será o número retirado).

Na sequência, o programa executará uma função que varre essa lista e descobre qual o número que está faltando, informando-o ao usuário.

Qual o nosso objetivo com esse script? Estudar e praticar técnicas de programação. No caso iremos trabalhar com geração de números aleatórios, embaralhamento de listas, definição de funções e aplicação de lógica para resolver problemas.

Abaixo temos o código usado, e na sequência a explicação detalhada de seu funcionamento. Fique à vontade para alterar o código a seu gosto, modificando ou acrescentando funcionalidades ao script.

Código em Python

import random

# Função para encontrar o número que está faltando
def encontrar_numero_faltando(lista):
    # A soma esperada dos números de 1 a 1000
    soma_esperada = sum(range(1, 1001))
    # A soma dos números na lista com um número faltando
    soma_lista = sum(lista)
    # O número que está faltando será a diferença entre a soma esperada e a soma da lista
    return soma_esperada - soma_lista

# Gerar uma lista de 1 a 1000
lista_numeros = list(range(1, 1001))

# Embaralhar a lista de forma aleatória
random.shuffle(lista_numeros)

# Remove um número aleatório da lista
numero_removido = random.choice(lista_numeros)
lista_numeros.remove(numero_removido)

# Mostrar a lista
print(f'Lista de números: \n{lista_numeros}')

# Encontrar o número faltando e exibir para o usuário
numero_faltando = encontrar_numero_faltando(lista_numeros)
print(f'\nO número faltando é: {numero_faltando}')

Como funciona esse script

Inicialmente, importamos o módulo random, que será necessário para a geração e manipulação dos números aleatórios (na verdade, pseudoaleatórios) que necessitaremos.

Na sequência, definimos a função “encontrar_numero_faltando“, que recebe como argumento a lista de números que será analisada.

Para determinar o número que está ausente nesta lista (haverá apenas um único número ausente dentre os mil valores), podemos aplicar várias técnicas. Aqui, iremos calcular a soma dos números de 1 até 1000 (armazenada na variável soma_esperada), e na sequência somaremos todos os números da lista passada à função, armazenado esse valor na variável soma_lista.

Então, basta subtrair da soma_esperada o valor de soma_lista, e o resultado será o número que falta (ausente). A função então retorna esse valor.

Fora da função, geramos uma lista de 1 até 1000 usando a função list() combinada com a função range, embaralhamos os números com o método random.shuffle, e retiramos um número da lista com os métodos random.choice (escolhe o número) e lista_numeros.remove (remove esse número da lista).

Na sequência, exibimos a lista na tela com a função print, e finalmente encontramos o número faltante chamando a função criada encontrar_numero_faltando, exibindo no final seu valor para o usuário.

Note que cada vez que o script for executado, um número diferente será sacado da lista, pois a escolha do valor a ser retirado pelo método choice é aleatória.

Conclusão

Com este pequeno script pudemos treinar o emprego e manipulação de números aleatórios, além da criação de funções e da aplicação de raciocínio lógico para a resolução de problemas com programação.

Você pode alterar o algoritmo para, por exemplo, gerar mais de 1000 números (que tal 1 milhão de valores?) e rodá-lo para testar sua performance e verificar sua utilidade. Será que ele ainda roda de forma satisfatória?

Você também pode tentar portar esse script para outras linguagens de programação que prefira, como por exemplo JavaScript, C# ou Rust, para treinar abordagens ligeiramente diferentes de codificação.

O post Descobrir número que falta em lista de 1000 números sequenciais em Python apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Exercício: Escreva um programa em Python que retorne uma lista de números primos compreendidos em um intervalo fornecido pelo usuário (incluindo os extremos). Use funções para tal.

Por exemplo, ao executar o script se o usuário solicitar a lista de primos entre 7 e 50, o programa deve retornar um resultado como segue:

Entre com o menor valor: 
7
Entre com o maior valor: 
50
Os números primos no intervalo de 7 a 50 são:
7 11 13 17 19 23 29 31 37 41 43 47 

Vejamos o código que permite gerar números primos em Python.

Código

# Como gerar números primos em um intervalo numérico
# Função para verificar os números primos
def primo(n):
    if n < 2:
        return False
    for i in range(2, int(n/2)+1):
        if n % i == 0:
            return False
    return True

if __name__=='__main__':
    # Usuário escolhe o intervalo
    inf = int(input('Entre com o menor valor: '))
    sup = int(input('Entre com o maior valor: '))

    print('Os primos no intervalo de {} a {} são:'.format(inf, sup))

    for i in range(inf, sup + 1):
        if primo(i):
            print(i, end=' ')

Funcionamento do script

Vou dividir a explicação em duas partes: a função primo e o bloco principal do programa.

Função primo(n)

A função primo(n) é definida para verificar se um número n é primo ou não. Ela funciona da seguinte maneira:

1. Verifica se um valor n passado como parâmetro é menor que 2. Se for, retorna False, pois números menores que 2 não são primos.
2. Se n não for menor do que 2, a função inicia um loop que percorre os valores de i de 2 até n/2 + 1 (metade +1 do valor informado).
3. Para cada valor de i, verifica se n é divisível por i (ou seja, se n % i == 0). Se essa condição for verdadeira, significa que n não é primo, pois possui um divisor além de 1 e ele mesmo. Portanto, a função retorna False.
4. Caso nenhum valor de i resulte em uma divisão exata de n, a função retorna True, indicando que n é um número primo.

Bloco if __name__==’__main__’:

No bloco principal, o programa realiza as seguintes ações:

1. Solicita que o usuário insira o valor mínimo (inf) e o valor máximo (sup) do intervalo a gerar.
2. Exibe uma mensagem informando que os números primos no intervalo de inf a sup serão exibidos na sequência.
3. Usando um laço for, percorre todos os valores de i no intervalo de inf a sup + 1.
4. Para cada valor de i, chama a função primo(i) para verificar se i é um número primo.
5. Se i for primo (ou seja, se a função primo(i) retornar True), o valor de i é impresso na mesma linha, seguido de um espaço. Isso ocorre para todos os números primos encontrados no intervalo.

Portanto, o programa vai iterar por todos os números no intervalo especificado pelo usuário, verificar se cada número é primo usando a função primo(n), e imprimir os números primos encontrados.

Veja que essa implementação é funcional, porém não é a mais eficiente em termos de tempo de execução para encontrar números primos, especialmente para intervalos maiores, pois realiza uma divisão para cada número no intervalo.

Existem algoritmos mais eficientes para geração de números primos, como o Crivo de Eratóstenes .

O post Como gerar números primos em Python em um intervalo especificado 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.

Neste tutorial mostro como realizar o cálculo do dígito verificador para validação de RG emitido no estado de SP, usando um script criado em Python – e que você pode adaptar para a linguagem de programação que desejar.

Formato do RG

O formato de um RG (Registro Geral) de São Paulo é composto por 9 dígitos no no formato XX.XXX.XXX-Y, onde os “X” representam os dígitos numéricos e o “Y” representa o dígito verificador (DV). 

Esse dígito verificador é o módulo 11 dos 8 dígitos anteriores, calculado usando um algoritmo específico – que vamos criar em Python.

No caso do RG, o DV corresponde ao resto da divisão por 11 do somatório da multiplicação de cada um dos outros oito algarismos respectivamente por 9, 8, 7, 6, 5, 4, 3, 2, a partir do dígito mais à esquerda. O resto 10 é considerado como valor X.

Observação importante: Em outros estados o formato do RG pode ser levemente diferente, e o algoritmo que mostrarei aqui pode não funcionar corretamente para realizar a validação, sendo necessário criar um algoritmo diferente.

Como calcular o dígito verificador do RG: Exemplo

Vejamos como realizar o cálculo do dígito verificador do RG por meio de um exemplo. Suponhamos o RG de número 29.465.327-2. Como verificar se ele é válido?

Para isso temos de efetuar a validação do dígito verificador – que no caso é o valor 2. Vamos ao processo:

Passo 1

Multiplicar os oito primeiros dígitos do RG pela sequência numérica de 9 a 2 e realizar sua soma:

Somatório dos valores obtidos:

18 + 72 + 28 + 36 + 25 + 12 + 6 + 14 = 211

Passo 2

Calcular o módulo 11 do somatório – ou seja, o resto da divisão por 11 do somatório obtido no passo 1.

O valor resultante desse cálculo é o dígito verificador do RG:

211 % 11 = 2

Dígito verificador calculado: 2 → RG validado

Obs.: O símbolo % representa a operação de módulo.

Note que existe um caso especial a ser tratado aqui:

1. Caso o resto calculado seja igual a 10, o dígito verificador será considerado como a letra X (que representa 10 em algarismos romanos).

Programa em Python para validação de RG SSP/SP

# Função de validação do dígito verificador de RG SSP/SP em Python
def validaRG(rg):
    cont = 9
    soma = 0
    # Somatório das multiplicações dos 8 primeiros dígitos do rg
    for digito in rg[0:8]:
        soma += int(digito) * cont
        cont -= 1
  
    # Calcula dv fazendo somatório mód 11
    dv = soma % 11

  # Verifica se dv calculado coincide com dv fornecido no RG (último dígito)
    if ((dv == 10) & (rg[-1] == 'X')):
        return(True)
    elif (int(rg[-1]) == dv):
        return(True)
    else:
        return(False)

if __name__=='__main__':
    rg = input("Digite seu RG, sem pontos ou traço: ")
    res = validaRG(rg)
    if (res == True):
        print("RG validado com sucesso.")
    else:
        print("Documento inválido.")

Funcionamento do algoritmo

O algoritmo começa definindo uma função de nome validaRG(rg) e criando dentro dela as variáveis cont e soma. A variável cont é inicializada com o valor 9 e a variável soma é inicializada com o valor 0.

Em seguida, é iniciado um laço for que percorre os primeiros 8 dígitos do número de RG fornecido. Para cada dígito, o algoritmo multiplica o valor do dígito pela variável cont (que é decrementada em cada iteração) e acumula o resultado na variável soma.

Após o término do laço, o algoritmo calcula o dígito verificador (dv) fazendo o módulo 11 da soma.

Em seguida, o algoritmo verifica se o dígito verificador calculado coincide com o dígito verificador fornecido no RG (último dígito).

Se o dígito verificador calculado for 10 e o último dígito do RG for ‘X’, isso é considerado uma coincidência e retorna True. Caso contrário, se o último dígito do RG for um número e for igual ao dígito verificador calculado, também retorna True.

Caso contrário, retorna False.

No corpo principal do programa if __name__==’__main__’:, o algoritmo solicita que o usuário digite o número do RG, sem pontos ou traços. Em seguida, chama a função definida validaRG() passando o número do RG como argumento e armazena o resultado na variável res.

Por fim, o algoritmo imprime uma mensagem indicando se o RG foi validado com sucesso ou se é inválido, com base no resultado retornado pela função validaRG.

Teste

Teste o algoritmo com seu número de RG, e com outros números, como 45.727.503-0 (contém DV zero no final) e 37.606.335-X (dígito verificador é a letra X), para verificar também os casos especiais.

Tente também melhorar o programa para que aceite a digitação dos documentos com pontos e traços, como exercício.

É isso aí!

Veja também: Como calcular e validar dígitos verificadores em números de CPF

O post Algoritmo para validação de RG SSP/SP (dígitos verificadores) em Python 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.