Bem sei que a idade não se compadece com o profissionalismo e por isso a conhecida Dina Aguiar, de 72 anos de idade, e 47 de carreira, deixa a RTP e o seu lugar de pivô no excelente programa "Portugal em Directo". De resto este vai mudar de nome, esperando eu que não signifique desvios da linha editorial e objectivos.

Bem sei que contou a idade e uma certa justificação de "renovação". Dizem que também o ordenado, o que não deixa de ser ridículo face ao que por ali se gasta com menos substância. Pergunto eu quanto não paga a estação dita pública naqueles cozinhados diários, a chefes, a canários, a malhoas, a zés amaros e companhia, quase por ali residentes, no que dizem ser a praça da alegria?

Podia aproveitar a RTP o balanço da foice e terminar com os monos e programas de encher chouriços como "O Preço Certo" e o "Praça da Alegria", e outros mais do género. Bem sei que têm audiências, sobretudo o concurso onde se dá prémios mesmo sem qualquer mérito de acertar nos desafios (-Está errado ou está errado?), mas para um serviço público e para o qual também pago na justa medida, não pode valer tudo. Não está em causa a qualidade do Fernando Mendes para o lugar, mas é de facto tempo a mais para um programa e que já nada acrescenta, para além de um entretenimento oco. Um serviço de televisão pública tem de ser bem mais que isso. Para isso, existem as outras estações.

Temos assim programas e figuras que se perpetuam, intocáveis. A inovação e renovação são, assim, eufemismos que em rigor nada significam. É o que temos e mais valia entulhar esse poço de despesismo público.

Em todo o caso, a minha opinião vale zero. Só me dou ao trabalho destes reparos por ser contribuinte da coisa. Não fora isso e a preocupação também seria zero, bola. 

Dina, até amanhã, se Deus quiser! Deus até quereria, mas não te quiseram o Vitor Gonçalves e companhia. Temos pena, é a vida!

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)