Lo dijo Avast, no yo, se supone que sabe más que yo del tema.

No le veo la lógica al razonamiento, me gusta el ordenador, pero no me dedico mucho al tema de la seguridad. No me atraen las piscinas.

Pero supuestamente me ha salvado de varias cosas, en general no he tenido problema.


Repito que lo dijo Avast, pero a ver ¿por qué si llevo años viendo imágenes, si he visto miles, creo que sólo hubo 3 que Avast dijo que eran peligrosas?

De crédito no tengo xP

Ya vi que es por ti sí, pero mejor sería que la pongas en un sitio más confiable, si realmente es ese el problema.

Aunque sale ese tema y usuario, pudo haber sido acá:
https://foro.elhacker.net/desarrollo_web/cual_es_el_mejor_hostingservidor_dedicado_para_proyectos-t522776.0.html;msg2282159#msg2282159

La otra página es Youtube. Estaba viendo mis temas para responder, incluido el otro por curiosidad, y me saltó ese cartel.

Al otro tema, ese del link, creo que es la 1era vez que entro. Otra cosa que no suelo hacer es entrar a 2 temas a la vez digamos, pero no debería ser un problema.

EDIT:
No sé si en el otro, pero acá:
https://foro.elhacker.net/programacion_general/generar_funciones-t522899.0.html;msg2282600;topicseen#msg2282600
me acaba de salir de nuevo el cartel.

No cambió el resultado, se cierra enseguida.

import itertools
 
def cargar_diccionario(ruta):
    """Carga el diccionario desde un archivo .txt y devuelve un conjunto de palabras en minúsculas."""
    with open(ruta, 'r', encoding='utf-8') as archivo:
        return set(palabra.strip().lower() for palabra in archivo)
 
def generar_combinaciones(alfabeto):
    """Genera todas las combinaciones posibles de dos letras del alfabeto."""
    return {a + b for a, b in itertools.product(alfabeto, repeat=2)}
 
def buscar_combinaciones(diccionario, combinaciones):
    """Busca combinaciones dentro de las palabras del diccionario."""
    presentes = set()
 
    # Buscar combinaciones dentro de palabras individuales
    for palabra in diccionario:
        for i in range(len(palabra) - 1):
            presentes.add(palabra[i:i+2])
 
    # Buscar combinaciones entre palabras consecutivas
    lista_palabras = sorted(diccionario)  # Ordenar las palabras
    for i in range(len(lista_palabras) - 1):
        ultima_letra = lista_palabras[-1]
        primera_letra = lista_palabras[i + 1][0]
        presentes.add(ultima_letra + primera_letra)
 
    return combinaciones - presentes
 
# Paso 1: Cargar diccionarios
diccionario_es = cargar_diccionario('diccionario_es.txt')
diccionario_en = cargar_diccionario('diccionario_en.txt')
 
# Paso 2: Generar combinaciones posibles
alfabeto_es = 'abcdefghijklmnñopqrstuvwxyz'
alfabeto_en = 'abcdefghijklmnopqrstuvwxyz'
combinaciones_es = generar_combinaciones(alfabeto_es)
combinaciones_en = generar_combinaciones(alfabeto_en)
 
# Paso 3: Buscar combinaciones inexistentes en cada diccionario
inexistentes_es = buscar_combinaciones(diccionario_es, combinaciones_es)
inexistentes_en = buscar_combinaciones(diccionario_en, combinaciones_en)
 
# Paso 4: Combinar resultados y mostrar combinaciones inexistentes en ambos idiomas
inexistentes_totales = inexistentes_es.intersection(inexistentes_en)
 
print(f"Combinaciones inexistentes en ambos idiomas ({len(inexistentes_totales)}):")
print(sorted(inexistentes_totales))
input("Presione Enter para continuar ...")

¿Será que requiere una versión más nueva que la que tengo?

El problema que describes probablemente no está relacionado con la versión de Python, sino con un **error en tu código** que provoca que el programa termine antes de lo esperado. Vamos a analizarlo detalladamente.

### Posibles problemas en el código

1. **Error en la sección de combinaciones entre palabras consecutivas**:
   En el método `buscar_combinaciones`, en esta línea:

   ```python
   ultima_letra = lista_palabras[-1]
   primera_letra = lista_palabras[i + 1][0]
   presentes.add(ultima_letra + primera_letra)
   ```
   
   Hay un error de lógica. La variable `ultima_letra` intenta tomar el valor de la última palabra completa de la lista (`lista_palabras[-1]`), pero lo que necesitas es la **última letra de la palabra actual** (`palabra_actual[-1]`). Aquí tienes una corrección:

   ```python
   ultima_letra = lista_palabras[-1]  # Última letra de la palabra actual
   primera_letra = lista_palabras[i + 1][0]  # Primera letra de la siguiente palabra
   presentes.add(ultima_letra + primera_letra)
   ```

2. **Falta de manejo de excepciones en la lectura de los archivos**:
   Si los archivos `diccionario_es.txt` o `diccionario_en.txt` no existen, el programa lanzará un error y se cerrará. Asegúrate de manejar este caso con un bloque `try-except` para evitar que el programa termine inesperadamente:

   ```python
   def cargar_diccionario(ruta):
       """Carga el diccionario desde un archivo .txt y devuelve un conjunto de palabras en minúsculas."""
       try:
           with open(ruta, 'r', encoding='utf-8') as archivo:
               return set(palabra.strip().lower() for palabra in archivo)
       except FileNotFoundError:
           print(f"Error: No se encontró el archivo {ruta}.")
           return set()
   ```

3. **Errores en los datos de entrada**:
   Si el archivo de diccionario contiene caracteres especiales, líneas vacías o palabras que no se procesan correctamente, el programa podría comportarse de manera inesperada. Asegúrate de que los archivos de entrada estén en el formato correcto (palabras en minúsculas, una por línea).

4. **El programa finaliza correctamente pero no esperas ese comportamiento**:
   Si el programa no tiene errores, la última línea:

   ```python
   input("Presione Enter para continuar ...")
   ```

   debería mantener la ventana abierta hasta que presiones **Enter**. Sin embargo, si estás ejecutándolo desde un entorno donde la ventana se cierra automáticamente al finalizar (por ejemplo, al ejecutar un archivo `.py` en Windows haciendo doble clic), esto puede parecer un cierre inesperado.

   Para evitar este problema, te recomiendo ejecutar el programa desde una terminal o consola manualmente con:

   ```bash
   python tu_programa.py
   ```

   Esto asegurará que la ventana no se cierre automáticamente después de la ejecución.

---

### Solución ajustada del código

Aquí está el código corregido con las observaciones mencionadas:

```python
import itertools

def cargar_diccionario(ruta):
    """Carga el diccionario desde un archivo .txt y devuelve un conjunto de palabras en minúsculas."""
    try:
        with open(ruta, 'r', encoding='utf-8') as archivo:
            return set(palabra.strip().lower() for palabra in archivo if palabra.strip())
    except FileNotFoundError:
        print(f"Error: No se encontró el archivo {ruta}.")
        return set()

def generar_combinaciones(alfabeto):
    """Genera todas las combinaciones posibles de dos letras del alfabeto."""
    return {a + b for a, b in itertools.product(alfabeto, repeat=2)}

def buscar_combinaciones(diccionario, combinaciones):
    """Busca combinaciones dentro de las palabras del diccionario."""
    presentes = set()
   
    # Buscar combinaciones dentro de palabras individuales
    for palabra in diccionario:
        for i in range(len(palabra) - 1):
            presentes.add(palabra[i:i+2])
   
    # Buscar combinaciones entre palabras consecutivas
    lista_palabras = sorted(diccionario)  # Ordenar las palabras
    for i in range(len(lista_palabras) - 1):
        ultima_letra = lista_palabras[-1]  # Última letra de la palabra actual
        primera_letra = lista_palabras[i + 1][0]  # Primera letra de la siguiente palabra
        presentes.add(ultima_letra + primera_letra)
   
    return combinaciones - presentes

# Paso 1: Cargar diccionarios
diccionario_es = cargar_diccionario('diccionario_es.txt')
diccionario_en = cargar_diccionario('diccionario_en.txt')

# Verificar si los diccionarios se cargaron correctamente
if not diccionario_es or not diccionario_en:
    print("No se pudieron cargar los diccionarios. Por favor, verifica los archivos.")
    exit()

# Paso 2: Generar combinaciones posibles
alfabeto_es = 'abcdefghijklmnñopqrstuvwxyz'
alfabeto_en = 'abcdefghijklmnopqrstuvwxyz'
combinaciones_es = generar_combinaciones(alfabeto_es)
combinaciones_en = generar_combinaciones(alfabeto_en)

# Paso 3: Buscar combinaciones inexistentes en cada diccionario
inexistentes_es = buscar_combinaciones(diccionario_es, combinaciones_es)
inexistentes_en = buscar_combinaciones(diccionario_en, combinaciones_en)

# Paso 4: Combinar resultados y mostrar combinaciones inexistentes en ambos idiomas
inexistentes_totales = inexistentes_es.intersection(inexistentes_en)

print(f"Combinaciones inexistentes en ambos idiomas ({len(inexistentes_totales)}):")
print(sorted(inexistentes_totales))
input("Presione Enter para continuar ...")
```

---

### Resumen de los cambios

1. **Corrección de la lógica al buscar combinaciones entre palabras consecutivas.**
2. **Manejo de excepciones al cargar los archivos.**
3. **Validación para asegurarte de que los diccionarios se carguen correctamente.**
4. **Sugerencia de ejecutar el programa desde la terminal para evitar que la ventana se cierre automáticamente.**

Con estas correcciones, el programa debería funcionar correctamente si tienes una versión de Python reciente (3.6 o superior).

Demasiado lío, el código me lo dió él, si ahora dice que tiene errores mejor empiezo por algo más simple que yo pueda entender.

Lo mejor que vi es que los mensajes de nuevos usuarios no se muestren hasta que son aprobados por moderadores. Claro que tiene desventajas...
- Más trabajo para los mods, pero es casi lo mismo, los mensajes los tienen que mirar igual, deberían tener un par de botones grandes arriba o abajo que digan aprobar/desaprobar, que se manden a una papelera en caso de desaprobar, por si se desaprobó por error, y listo. Hasta podría funcionar con sus voces, que si dicen aprobado o algo así, se aprueba.
- El foro se enlentece para los nuevos (especialmente si como en otros foros el admin desaparece y los mods también, pero eso es malo en cualquier caso), pero no debería ser un gran problema salvo que necesiten algo urgente pero si es el caso... No sé, no le veo mucho sentido a querer que te resuelvan urgentemente algo en un foro, ya es bastante pedir que lo resuelvan.

Creo que los bots podrían imitar dibujos mal hechos y que ciertas personas podría ser que dibujen bien.

¿Cómo una máquina distingue un humano de un bot? Más de una vez pensé en preguntarlo aquí. Claro que no me refiero a páginas en que debes seleccionar las imágenes que tengan bicicletas o cosas así, sino esas donde debes cliquear un cuadrito y a veces tarda en aprobarlo ¿qué está haciendo? Una posibilidad es que chequeé cómo muevo el mouse, o algunos archivos o configuraciones del navegador, pero imagino que una máquina podría imitar todo eso.

"Elabora un sistema que distinga humanos de bots, para una página de Internet", podría ser algo que te interese preguntarle a GPT.

"los bots estan diseñados para ser amables"
Puede que cambie para que sean menos detectables.

"Igual no se si los bots saben que son solo cosas en una computadora y no humanos reales. Los bots saben eso?"
Creo que es innecesario que lo sepan, a menos que sea un superbot.

"Pareceria cuando en Digital Circus Gumigoo se da cuenta de que es solo un npc"
No lo conozco, pero si te gustan esas cosas te recomiendo Doki Doki Literature Club, ver un resumen, pero el juego es perturbador.

Tuve la impresión de que quedaba demasiado desprolijo, a veces en una nueva línea no quedaba el nombre de una carta sino parte del texto de una.

Cuento lo que hice, aunque aún no es una buena solución, quiero la lista para hacer ciertos mazos, pero aunque ahora puedo hacer que quede prolija, faltaría que las cartas se clasifiquen de algún modo.

Cuando se guarda un mazo, queda en una carpeta rara, es cuestión de buscar el nombre del archivo.

Esos archivos son así:
;Nombre
;
;Player
;
;Fecha
;?
;Edition
;

.964   4   Beast of Burden
.1331   1   Nuisance Engine
Eso último es un ejemplo.
Las cartas tienen un identificador, el número tras el .
Luego otro número indica cuántas de esas hay en el mazo.
Luego dice qué carta es.

Probé, usando Excel, generar un texto así:
.1   1
.2   1
.3   1
...
.100   1

Lo puse en el archivo. Al abrirlo en el juego y guardarlo, se graban la cartas, o sea, en la derecha, automáticamente, eso que no puse.

Le dije a GPT:
Haz un archivo bat que genere un txt con este contenido:
;Txt1
;
;
;
;04/01/2025
;1
;4th Edition
;

.1   1
.2   1
.3   1
etc, hasta 100

Y que el proceso se repita, o sea, que se generen muchos archivos así, pero:
Donde dice Txt1, ese 1 debe ir aumentando.
El 1er archivo tiene desde .1 hasta .100, el 2ndo debe tener desde .101 hasta .200, el 3ero debe tener desde .201 hasta .300, y así sucesivamente

Acá está:

@echo off
setlocal enabledelayedexpansion
 
rem Configuración inicial
set "fecha=04/01/2025"        rem Fecha para los archivos
set "edicion=4th Edition"     rem Edición para los archivos
set "cantidad=100"            rem Cantidad de líneas por archivo
set /a "inicio=1"             rem Número inicial de la primera línea
set /a "archivos=10"          rem Número de archivos que deseas generar
 
rem Bucle para crear múltiples archivos
for /l %%A in (1,1,%archivos%) do (
    rem Crear el archivo con nombre File%%A.txt
    set /a "fin=inicio+cantidad-1"
    set "nombreArchivo=File%%A.txt"
    echo Creando %%A: !nombreArchivo!
 
    rem Escribir contenido en el archivo
    (
        echo ;Txt%%A
        echo ;
        echo ;
        echo ;
        echo ;%fecha%
        echo ;%%A
        echo ;%edicion%
        echo ;
 
        rem Generar las líneas desde el inicio hasta el fin
        for /l %%B in (!inicio!,1,!fin!) do (
            echo .%%B^	1
        )
    ) > "!nombreArchivo!"
 
    rem Actualizar el inicio para el siguiente archivo
    set /a "inicio=fin+1"
)
 
echo Proceso completado.
pause

Con algunos cambios, se hace más fácil. Ahora sólo es cuestión de abrir los archivos y guardarlos, aunque en algunos casos hay cartas inexistentes (o sea, están pero no tienen dibujo ni texto, etc, o en otros casos hay menos de 100), ah, y un gran problema digamos, es que no están en orden alfabético, no sé qué criterio es, quizá según cuan vieja sea la carta, la edición, y dentro de cada edición sí están ordenadas.

Un ejemplo:
;Mazo1
;
;
;
;04/01/2025
;1
;4th Edition
;

.1   1   Ancestral Recall
.2   1   Animate Artifact
.3   1   Animate Dead
.4   1   Animate Wall
.5   1   Ankh of Mishra
.6   1   Armageddon
.7   1   Aspect of Wolf
.8   1   Bad Moon
.9   1   Badlands
.10   1   Balance

.964   es Beast of Burden, o sea, si fuera alfabético debería estar mucho antes.

Ahora le podría pedir a GPT que las clasifique según criterios que le diga, pero ya es otro tema.

Para ver todos los dibujos posibles uno a uno, hice un programa que los genera así, aunque por ahora sólo son en blanco y negro, de esos 2 colores nada más.

Luego indiqué que no mostrara dibujos que no cumplieran ciertas características.

A:
Luego empecé a indicar cómo pasar de uno aceptable al siguiente aceptable, para evitar generar los que no van a mostrarse. Por si no se entiende:
Supongamos que quieres ver todos los números divisibles entre 3. Puedes generar todos los enteros y mostrar sólo los divisibles entre 3 (se genera el 1 pero no se muestra, luego el 2 pero tampoco, el 3 sí, luego el 4 pero no...), o puedes simplemente indicar que se generen sólo los necesarios (3, 6...). Pero no en todo contexto es simple.
Noté una falla en eso que hice. Tengo una idea sobre cómo corregirlo pero, si lo que hice antes estuvo mal ¿por qué creer que ahora estará bien? Tampoco es que deba creer que estará mal, no se debe creer que se puede prever el futuro tanto, es cuestión de probar, pero me tiene un poco cansado, no sé, me pregunto hasta qué punto tiene sentido fallar, fallar, fallar y cuando no se notan errores no estar seguro de si no hay o uno está fallando en detectarlos. Es como "Mejor que lo haga otro, alguien que no falle tanto".

Había concluido que lo mejor era dejar de intentar hacer A, pero eso en última instancia es como creer que no tiene sentido intentar programar, es dejar de programar. Por eso estoy un poco confuso, el programa en sí tampoco tiene mucho sentido, los dibujos que muestra es como que son nada, grandes cuadrados cerca, así o asá. Una IA o como se llame, hoy en día hace dibujos bastante bien de lo que se le pida, así que pa qué. En parte era porque quería demostrar que los dibujos no son una creación, que deba tener dueño, es algo que puede ser generado pintando ciertos puntos de ciertos colores, duh, y se puede lograr probando combinaciones. Y por ver dibujos interesantes, no sé. Ah, y era una práctica para otras cosas, no puedo generar películas o representaciones de cerebros, si no puedo generar dibujos... Mejor empezar por lo más fácil. No sé si es un error dejar esto o no. Y la cuestión es más profunda que eso, quizá debería dejar la programación misma, pero para hacer qué, no sé, si igual la cuestión de que puedo fallar sigue.

Probablemente no es un tema de programación entonces, pero aquí lo dejo, como "testimonio" de lo que es programar sin saber hacerlo bien, o el problema que sea.


Recientemente vi este video:
https://www.youtube.com/watch?v=4zk6uodm7tY
Yo no entendí Matrix y no recordaba tanto, aparentemente el programador comete fallas que no sabe corregir.

Una vez le di a un técnico una PC que tenía contraseña al iniciar Windows, habiéndome olvidado de decirle, y cuando me la dió o hablamos el tipo me dijo que tenía contraseña, luego levantó la seja, pero llegué a la conclusión de que para él fue como una piedrita en el camino xD

Quizá haya una forma de que la PC sólo la puedan usar quienes sepan un password, podrías preguntar eso en un nuevo tema si te interesa.

La seguridad tiene costos:
Poner las cosas en rars con password y a esos en discos externos y al usarlas apagar el Router o lo que sea (en mi caso es desconectar un cable, no sé si mi PC tiene como una "antena" o si envía señales, creo que no)
¿Quién quiere tomarse tantas molestias? La CIA quizá, nadie normal debería.
Además si no las usas en mucho tiempo puede que olvides los passwords, como me pasó a mí >___<

Bueno, quizá existen mejores formas, pero todo es un paso extra que aburre.

Es un archivo py abierto con Python, eso me lo enseñaron aquí, posiblemente tú.

Luego te digo el resultado.

Relacionado con:
https://foro.elhacker.net/hacking/descartar_combinaciones_de_caracteres_al_buscar_password-t522886.0.html

Código dado por GPT:

import itertools
 
def cargar_diccionario(ruta):
    """Carga el diccionario desde un archivo .txt y devuelve un conjunto de palabras en minúsculas."""
    with open(ruta, 'r', encoding='utf-8') as archivo:
        return set(palabra.strip().lower() for palabra in archivo)
 
def generar_combinaciones(alfabeto):
    """Genera todas las combinaciones posibles de dos letras del alfabeto."""
    return {a + b for a, b in itertools.product(alfabeto, repeat=2)}
 
def buscar_combinaciones(diccionario, combinaciones):
    """Busca combinaciones dentro de las palabras del diccionario."""
    presentes = set()
 
    # Buscar combinaciones dentro de palabras individuales
    for palabra in diccionario:
        for i in range(len(palabra) - 1):
            presentes.add(palabra[i:i+2])
 
    # Buscar combinaciones entre palabras consecutivas
    lista_palabras = sorted(diccionario)  # Ordenar las palabras
    for i in range(len(lista_palabras) - 1):
        ultima_letra = lista_palabras[-1]
        primera_letra = lista_palabras[i + 1][0]
        presentes.add(ultima_letra + primera_letra)
 
    return combinaciones - presentes
 
# Paso 1: Cargar diccionarios
diccionario_es = cargar_diccionario('diccionario_es.txt')
diccionario_en = cargar_diccionario('diccionario_en.txt')
 
# Paso 2: Generar combinaciones posibles
alfabeto_es = 'abcdefghijklmnñopqrstuvwxyz'
alfabeto_en = 'abcdefghijklmnopqrstuvwxyz'
combinaciones_es = generar_combinaciones(alfabeto_es)
combinaciones_en = generar_combinaciones(alfabeto_en)
 
# Paso 3: Buscar combinaciones inexistentes en cada diccionario
inexistentes_es = buscar_combinaciones(diccionario_es, combinaciones_es)
inexistentes_en = buscar_combinaciones(diccionario_en, combinaciones_en)
 
# Paso 4: Combinar resultados y mostrar combinaciones inexistentes en ambos idiomas
inexistentes_totales = inexistentes_es.intersection(inexistentes_en)
 
print(f"Combinaciones inexistentes en ambos idiomas ({len(inexistentes_totales)}):")
print(sorted(inexistentes_totales))

Tengo los diccionarios y les puse los nombres que dice ahí:
diccionario_es.txt
diccionario_en.txt

El programa se cierra enseguida sin que yo pueda ver qué pasa. ¿Cual es la falla, cómo lo arreglo?