Tenho alguns conhecimentos básicos de programação Python. Com eles e com a ajuda da IA, e com alguma paciência, porque ainda comete asneiras, cheguei a este código que, em ficheiro PDF, gera passatempos de "Sopa de Letras".
Um exemplo, com 20 palavras alusivas ao Natal, que o programa dispõe de forma aleatória, e que podem ser encontradas na vertical, na horizontal, na diagonal e em várias direcções de leitura.
As palavras, separadas por vírgulas, são previamente colocadas num ficheiro TXT, que o executável lê. Fiz poucos testes para detectar erros na escrita das palavras e sua disposição na grelha, mas creio que estará a funcionar.
O código gera ainda uma grelha com as soluções. Será que o futuro dos programadores está em risco?
=============
import random
from fpdf import FPDF
def gravar_log(mensagem):
"""Grava a mensagem de log em um arquivo de texto"""
with open("log_debug.txt", "a") as log_file:
log_file.write(mensagem + "\n")
def ler_palavras(arquivo):
"""Lê as palavras de um arquivo de texto, separadas por vírgulas."""
try:
with open(arquivo, 'r') as f:
conteudo = f.read()
palavras = [palavra.strip().upper() for palavra in conteudo.split(',')]
gravar_log(f"Palavras carregadas: {palavras}") # Log: Palavras carregadas
return palavras
except Exception as e:
gravar_log(f"Erro ao ler o arquivo: {e}") # Log: Erro ao ler o arquivo
return []
def criar_grelha(tamanho):
"""Cria uma grelha vazia do tamanho especificado."""
return [[' ' for _ in range(tamanho)] for _ in range(tamanho)]
def pode_colocar_palavra(grelha, palavra, linha, coluna, delta_l, delta_c):
"""Verifica se uma palavra pode ser colocada na posição dada."""
tamanho = len(grelha)
for i in range(len(palavra)):
nova_linha = linha + i * delta_l
nova_coluna = coluna + i * delta_c
if not (0 <= nova_linha < tamanho and 0 <= nova_coluna < tamanho):
return False
if grelha[nova_linha][nova_coluna] not in (' ', palavra[i]):
return False
return True
def colocar_palavra(grelha, palavra, linha, coluna, delta_l, delta_c):
"""Coloca uma palavra na grelha na posição dada."""
for i in range(len(palavra)):
grelha[linha + i * delta_l][coluna + i * delta_c] = palavra[i]
def preencher_espacos_vazios_com_letras(grelha):
"""Preenche os espaços vazios da primeira grelha com letras aleatórias."""
letras = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
for i in range(len(grelha)):
for j in range(len(grelha[i])):
if grelha[i][j] == ' ':
grelha[i][j] = random.choice(letras)
def preencher_espacos_vazios_com_asterisco(grelha):
"""Preenche os espaços vazios da grelha de soluções com o símbolo '*'."""
for i in range(len(grelha)):
for j in range(len(grelha[i])):
if grelha[i][j] == ' ':
grelha[i][j] = '*'
def salvar_grelha_pdf(grelha, palavras, grelha_respostas, nome_arquivo):
"""Salva a grelha e a lista de palavras em um arquivo PDF com a sopa de letras."""
try:
pdf = FPDF()
pdf.set_auto_page_break(auto=True, margin=15)
# Definir margens e tamanhos
margem_esquerda = 10
tamanho = len(grelha)
celula_tamanho = 10
largura_grelha = tamanho * celula_tamanho
altura_grelha = tamanho * celula_tamanho
# Página da sopa de letras
pdf.add_page()
pdf.set_font('Arial', size=12)
pdf.cell(200, 10, txt="Sopa de Letras", ln=True, align='C')
pdf.ln(10)
# Desenha a grelha (Sopa de Letras) à esquerda
x_grelha = margem_esquerda
y_grelha = 50
for i, linha in enumerate(grelha):
for j, letra in enumerate(linha):
x = x_grelha + j * celula_tamanho
y = y_grelha + i * celula_tamanho
pdf.rect(x, y, celula_tamanho, celula_tamanho)
pdf.set_xy(x, y)
pdf.set_text_color(0, 0, 0) # Cor das letras (preto)
pdf.cell(celula_tamanho, celula_tamanho, letra, align='C')
# Espaço abaixo da grelha para a lista de palavras
y_lista_palavras = y_grelha + altura_grelha + 10
# Lista de palavras abaixo da grelha (todas na mesma linha, separadas por espaços)
pdf.set_xy(margem_esquerda, y_lista_palavras)
pdf.set_text_color(0, 0, 0) # Cor do texto (preto)
palavras_line = ' '.join(palavras) # Juntar as palavras com espaço entre elas
pdf.multi_cell(0, 10, txt=palavras_line)
# Página das respostas (Soluções)
pdf.add_page()
pdf.cell(200, 10, txt="Soluções", ln=True, align='C')
pdf.ln(10)
# Posição para desenhar a grelha de soluções
x_respostas = 10
y_respostas = 50
# Desenha a grelha de soluções
for i, linha in enumerate(grelha_respostas):
for j, letra in enumerate(linha):
x = x_respostas + j * celula_tamanho
y = y_respostas + i * celula_tamanho
if letra != ' ':
pdf.set_fill_color(192, 192, 192) # Cor de preenchimento (cinza claro)
pdf.rect(x, y, celula_tamanho, celula_tamanho, style='F')
if letra == '*' and grelha_respostas[i][j] == '*':
# Sem cor de fundo para os '*'
pdf.set_fill_color(255, 255, 255)
pdf.rect(x, y, celula_tamanho, celula_tamanho, style='F')
pdf.set_xy(x, y)
pdf.set_text_color(0, 0, 0) # Cor das letras (preto)
pdf.cell(celula_tamanho, celula_tamanho, letra, align='C')
# Desenha a borda externa da grelha de soluções
x_borda = 10
y_borda = 50
pdf.set_line_width(0.5)
pdf.rect(x_borda - 1, y_borda - 1, largura_grelha + 2, altura_grelha + 2) # Borda externa
pdf.output(nome_arquivo)
gravar_log(f"PDF gerado com sucesso como {nome_arquivo}") # Log: PDF gerado
except Exception as e:
gravar_log(f"Erro ao gerar o PDF: {e}") # Log: Erro ao gerar o PDF
def criar_sopa_de_letras(arquivo_palavras, tamanho=15):
"""Cria uma sopa de letras a partir de palavras fornecidas em um arquivo."""
palavras = ler_palavras(arquivo_palavras)
if len(palavras) > 20:
palavras = palavras[:20] # Limita a 20 palavras
grelha = criar_grelha(tamanho)
grelha_respostas = criar_grelha(tamanho) # Grelha para as respostas
direcoes = [(-1, 0), (1, 0), (0, -1), (0, 1), (-1, -1), (-1, 1), (1, -1), (1, 1)] # Direções
for palavra in palavras:
colocada = False
tentativas = 0
while not colocada and tentativas < 100:
linha = random.randint(0, tamanho - 1)
coluna = random.randint(0, tamanho - 1)
delta_l, delta_c = random.choice(direcoes)
if pode_colocar_palavra(grelha, palavra, linha, coluna, delta_l, delta_c):
colocar_palavra(grelha, palavra, linha, coluna, delta_l, delta_c)
colocar_palavra(grelha_respostas, palavra, linha, coluna, delta_l, delta_c)
colocada = True
tentativas += 1
preencher_espacos_vazios_com_letras(grelha) # Preenche a primeira grelha com letras aleatórias
preencher_espacos_vazios_com_asterisco(grelha_respostas) # Preenche a grelha de respostas com "*"
nome_arquivo = "sopa_de_letras.pdf"
salvar_grelha_pdf(grelha, palavras, grelha_respostas, nome_arquivo)
gravar_log(f"Sopa de letras salva como {nome_arquivo}")
# Caminho para o arquivo de palavras
arquivo_palavras = 'sopaletras.txt'
criar_sopa_de_letras(arquivo_palavras)