Algoritmo on kenji.blog

FizzBuzz

Fri, 18 Apr 2025 00:58:11 +0900

Afinal, o que é FizzBuzz?

Olá!

Hoje eu gostaria de escrever sobre “FizzBuzz”.

Tanto para aqueles que pensam “Ah, eu conheço isso!”, quanto para aqueles que dizem “Já ouvi falar, mas não entendo muito bem”, por favor, fiquem comigo um pouquinho. Pode ser lido em poucos minutos, e talvez você pense “Faz sentido”.

É verdade que “se você não consegue escrever FizzBuzz, você é um fracasso como programador”?

O FizzBuzz, em resumo, é assim.

1
2
3
4
5
6
7
8
9


for i in range(1, 101):
 if i % 15 == 0:
 print("FizzBuzz")
 elif i % 3 == 0:
 print("Fizz")
 elif i % 5 == 0:
 print("Buzz")
 else:
 print(i)

Sim, este é o famoso “Problema FizzBuzz”.

Você analisa os números de 1 a 100 em ordem,
se for um múltiplo de 3, exibe “Fizz”, se for um múltiplo de 5, exibe “Buzz”,
se for um múltiplo de ambos, exibe “FizzBuzz” - é algo muito simples.

E, no entanto, por algum motivo, costuma ser tratado como “o teste mínimo para um programador”. Aparece em entrevistas, e nas redes sociais você vê comentários do tipo “Alguém que não consegue nem escrever FizzBuzz…”.

Mas, espere um minuto.

Podemos realmente dizer que “não conseguir escrever FizzBuzz = não conseguir programar”?

Não é sobre poder ou não, mas se você tem o “estado” para poder

É verdade que o FizzBuzz exige compreensão da sintaxe e pensamento lógico básico. Portanto, faz sentido que seja usado para “verificar os fundamentos”.

Mas, veja bem.

Se o ambiente for diferente, os resultados serão diferentes.

Por exemplo,

Quando você está nervoso na frente de um entrevistador que acabou de conhecer
Quando você recebe um quadro branco de repente e não tem um editor à mão
Quando você não consegue se lembrar imediatamente de “Ei, o que é modulo?”

…Isso não acontece? Somos humanos. Eu acho que acontece.

Portanto, em vez de “conseguir escrever FizzBuzz”, acho que “conseguir se colocar em um estado em que consiga escrever FizzBuzz” é, na verdade, muito mais importante.

A armadilha do conselho comum de “Basta treinar e ficará tudo bem”

Quando se trata desse assunto, o conselho “Então pratique todos os dias!” tende a surgir.

É verdade que a prática repetida fará com que você o escreva com fluência, e isso em si é bom. Mas se partirmos da premissa de que “se você não conseguir escrever FizzBuzz, você é um fracasso”, isso pode se transformar em mero medo.

Em outras palavras, tende a criar uma estrutura onde você sente “Eu cometi um erro = sou inútil”.

Por exemplo, quando você acorda tarde, você não tende a pensar “Eu sou preguiçoso…”? Mas pode ser apenas que seu corpo estivesse cansado naquele momento.

O FizzBuzz é a mesma coisa.

Dito isto, o FizzBuzz ainda é uma boa pergunta

Dito isto, o FizzBuzz não é ruim.

Em vez disso, acho que é uma pergunta muito bem elaborada. As regras são simples e é fácil de expandir. Por exemplo, se você mudá-lo assim, seu pensamento se aprofundará.

1
2
3
4
5
6
7


for i in range(1, 101):
 output = ""
 if i % 3 == 0:
 output += "Fizz"
 if i % 5 == 0:
 output += "Buzz"
 print(output or i)

Este é um exemplo de “Você pode escrever isso mesmo sem usar if-elif-else”. É meio inteligente, não é?

Em outras palavras, o FizzBuzz não trata apenas de “se você conseguiu fazer”, mas também serve como ponto de partida para ver “como você o escreve” e “o quanto você entende”.

Por tanto

Acho que não devemos atribuir muito significado excessivo a se você consegue ou não fazer o FizzBuzz.

Mesmo que você não tenha conseguido escrever, pode ser apenas que “você não estava se sentindo bem agora”, e muitas vezes você conseguirá se pensar com cuidado mais tarde.

Não se apresse, vamos avançar devagar.

O código é escrito por humanos. Porque somos humanos, às vezes esquecemos coisas e ficamos nervosos. Aceitando isso, acho que basta se pudermos avançar pouco a pouco.

Então, vamos escrever o código de maneira descontraída hoje.

Torre de Hanói

Thu, 17 Apr 2025 22:23:14 +0900

Torre de Hanói

Olá!

Hoje, gostaria de explicar sobre a “Torre de Hanói”, usando um programa de exemplo em Python.

O que é a Torre de Hanói?

A Torre de Hanói é um quebra-cabeça que usa 3 hastes e vários discos. Os discos têm tamanhos diferentes e, no início, estão empilhados em uma haste em ordem decrescente de tamanho. As regras são as seguintes:

Apenas um disco pode ser movido por vez.
Não é possível colocar um disco maior em cima de um disco menor.

Este quebra-cabeça é considerado um excelente material de ensino para aprender o pensamento recursivo. A recursividade é um método de resolver um problema dividindo-o em problemas menores do mesmo tipo. Na Torre de Hanói, para mover n discos, repete-se a operação de mover n-1 discos.

Vamos resolver a Torre de Hanói com Python

Abaixo está um código de exemplo para resolver a Torre de Hanói em Python.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


def hanoi(n, source, target, auxiliary):
 if n == 1:
 print(f"Move disk 1 from {source} to {target}")
 return
 hanoi(n - 1, source, auxiliary, target)
 print(f"Move disk {n} from {source} to {target}")
 hanoi(n - 1, auxiliary, target, source)

# Exemplo: Mover 3 discos de A para C
hanoi(3, 'A', 'C', 'B')

Neste código, a função hanoi é chamada recursivamente e os passos para mover os discos são exibidos. Por exemplo, no caso de 3 discos, a seguinte saída é obtida:

1
2
3
4
5
6
7


Move disk 1 from A to C
Move disk 2 from A to B
Move disk 1 from C to B
Move disk 3 from A to C
Move disk 1 from B to A
Move disk 2 from B to C
Move disk 1 from A to C

Desta forma, ao usar uma abordagem recursiva, problemas complexos podem ser resolvidos de forma simples.

Quanto tempo leva para mover 64 discos?

O número de movimentos na Torre de Hanói requer no mínimo 2^n - 1 vezes. Ou seja, para mover 64 discos, são necessários 2^64 - 1 movimentos, o que dá aproximadamente 1,84×10^19 movimentos. Mesmo que você pudesse mover um por segundo, levaria cerca de 584 bilhões de anos. Isso é cerca de 42 vezes a idade do universo (aproximadamente 13,7 bilhões de anos).

Desta forma, conforme o número de discos aumenta, o número necessário de movimentos aumenta exponencialmente. Portanto, mover 64 discos na prática não é realista.

Resumo

A Torre de Hanói é um quebra-cabeça perfeito para aprender o pensamento recursivo. Com Python, você pode facilmente implementar a sua solução. No entanto, é preciso ter cuidado, pois à medida que o número de discos aumenta, o número de movimentos necessários aumenta drasticamente.

Ao entender a abordagem recursiva e tentar escrever código de fato, você pode melhorar suas habilidades de programação. Por favor, experimente enfrentar o desafio da Torre de Hanói.

Código C para gerar números primos

Sat, 24 Aug 2024 09:38:10 +0900

Abaixo está um código C simples que gera números primos dentro de um intervalo especificado. Neste exemplo, enumeramos números primos de 1 a n.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


#include <stdio.h>
#include <stdbool.h>

bool isPrime(int num) {
 if (num <= 1) return false;
 if (num <= 3) return true;
 if (num % 2 == 0 || num % 3 == 0) return false;

 for (int i = 5; i * i <= num; i += 6) {
 if (num % i == 0 || num % (i + 2) == 0) return false;
 }
 return true;
}

void printPrimes(int n) {
 printf("2 ");
 for (int i = 3; i <= n; i += 2) {
 if (isPrime(i)) {
 printf("%d ", i);
 }
 }
 printf("\n");
}

int main() {
 int n;
 printf("Digite o valor máximo do intervalo para gerar números primos: ");
 scanf("%d", &n);
 printf("Os números primos de 1 a %d são:\n", n);
 printPrimes(n);
 return 0;
}

Este código funciona da seguinte forma:

Função isPrime: Determina se um determinado número é primo. Por uma questão de eficiência, primeiro verifica-se se é divisível por 2 e 3 e, em seguida, prossegue verificando em múltiplos de 6.
Função printPrimes: Gera números primos dentro de um intervalo especificado. O 2 é impresso primeiro e, em seguida, apenas os números ímpares são verificados.
Função main: Solicita que o usuário insira o valor máximo do intervalo e imprime os números primos dentro desse intervalo.

Se você compilar e executar este código, os números primos dentro do intervalo especificado serão exibidos.

Resolvendo o Problema do Caixeiro Viajante com Mathematica

Wed, 12 Oct 2022 19:05:58 +0900

Resolvendo o Problema do Caixeiro Viajante com Mathematica

Problema

電車でこんな広告を見かけました😁📸 pic.twitter.com/iXEgvtXrpL
— 早稲田大学早水桃子研究室 (@hayamizu_lab) October 11, 2022

Solução

1

d=SparseArray[{{1,2}->10,{2,1}->10,{1,5}->15,{5,1}->15,{1,4}->12,{4,1}->12,{1,3}->20,{3,1}->20,{2,5}->10,{5,2}->10,{3,4}->10,{4,3}->10,{3,8}->30,{8,3}->30,{3,7}->20,{7,3}->20,{3,6}->25,{6,3}->25,{4,5}->15,{5,4}->15,{4,8}->20,{8,4}->20,{5,9}->18,{9,5}->18,{5,8}->15,{8,5}->15,{6,7}->5,{7,6}->5,{7,8}->35,{8,7}->35,{8,9}->12,{9,8}->12},{9,9},Infinity];

Crie uma matriz usando a função SparseArray. Cada elemento representa a distância entre as cidades em sua respectiva linha e coluna. Por exemplo, o primeiro elemento {1,2}->10 significa que a distância entre 1 e 2 é 10. O penúltimo elemento {9,9} indica o tamanho da matriz, e o último elemento Infinity significa que o comprimento do caminho entre cidades não especificadas é infinito, ou seja, não há caminho.

1

{len,tour}=FindShortestTour[{1,2,3,4,5,6,7,8,9},DistanceFunction->(d[[#1,#2]]&)]

Com a função FindShortestTour, você pode resolver facilmente o problema do caixeiro viajante. {1,2,3,4,5,6,7,8,9} representa os números das cidades. DistanceFunction->(d[[#1,#2]]&) passa a matriz d que representa a distância entre as cidades.

Saída

1

{137, {1, 2, 5, 9, 8, 7, 6, 3, 4}}

A saída mostra a distância mais curta e a rota correspondente. A distância mais curta é 137, e a rota é 1→2→5→9→8→7→6→3→4→1. Convertendo para ordem alfabética ABC, torna-se A, B, E, I, H, G, F, C, D.

Enumerando Números Primos em Rust

Fri, 09 Sep 2022 07:08:49 +0900

Escrevi um programa para enumerar números primos em Rust.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


fn main() {
 let max = 1000;
 let mut primes = vec![2];
 let mut n = 3;
 loop {
 let mut is_prime = true;
 for p in &primes {
 if n % p == 0 {
 is_prime = false;
 break;
 }
 }
 if is_prime {
 primes.push(n);
 }
 n += 2;
 if n > max {
 break;
 }
 }
 for p in &primes {
 println!("{}", p);
 }
}