elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.


Tema destacado: Los 10 CVE más críticos (peligrosos) de 2020


  Mostrar Mensajes
Páginas: 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 ... 240
151  Foros Generales / Foro Libre / ¿Cómo estuvo tu 2024? en: 2 Enero 2025, 00:14 am
No se hable de cosas que puedan hacer cerrar el tema, lo pongo en foro libre porque no va a ser sólo de programación, pero tampoco es para tirar bombas.

Proyecto 1:
Escribir libro que enseñe cosas a gente como yo era o similar.

Porque siento que no me enseñaron suficiente, así que de hecho no puedo enseñar mucho, pero en fin, algo es mejor que sólo nada.
La idea es que lo pueda entender cualquiera, más o menos como esto:
https://www.pictocuentos.com/el-patito-feo/4
Como eso es una historia, y lo más fácil es, supuestamente, contar la de uno, para empezar hago eso.
Es que ¿cómo hacer un libro que enseñe a usarlo a quien no sepa? Imagina que lo recibe un indígena que nunca vió uno, quiero que le sirva a alguien así incluso, por eso no sé bien cómo empezar y hago algo simple por ahora.
Pero es más complicado de lo que pensé, resumir cada año en 1 palabra y 1 imagen, por ahora haría eso, una versión para gente que no quiera mucho texto, luego haría otra con más. ¿Qué palabra es la más correcta? ¿qué imagen? Y hallarla no siempre es sencillo. Por suerte esta página:
https://poe.com/
tiene chats que pueden generar imágenes, por ejemplo Imagen3-Fast.
Cuando copio una tabla en Word y la pego en otro lado aparece sólo un trozo, así que tuve que ponerla en partes:
https://i.ibb.co/ZTF5M2s/Resumen-libro-parte-1.png
https://i.ibb.co/ggr36Yr/Resumen-libro-parte-2.png
https://i.ibb.co/N3X7PSZ/Resumen-libro-parte-3.png
https://i.ibb.co/ctdFN0H/Resumen-libro-parte-4.png
https://i.ibb.co/r0J6n4f/Resumen-libro-parte-5.png
Creo que va bien, aunque a velocidad de tortuga con una pata rota. Por lo explicado en una de esas imágenes, se supone que ahora avanzaré más rápido.
En cuanto a de dónde son algunas imágenes:
- Seiken Denketsu 3 y Breath of Fire 2.
- Super Dodge Ball Neo Geo y un juego de Kunio en que las protagonistas son mujeres, no recuerdo el nombre.
- Evangelion (Shinji fue sustituído) y Love Hina.
- Final Fantasy 4.
- Rescue Rangers, también conocido como Los rescatadores o algo así, capítulo "El caso del culto Cola", lo tenía en video cuando no había mucho que ver y lo vi muuuchas veces...
- El bardo que aparece en diálogos es de Ásterix.
- En el globo de pensamiento de Yugioh, Final Fantasy 6 y una carta de Magic.
- Love Hina.
- Transformers, capítulo "Dark awakening".

Proyecto 2:
Ordenar el PC.
Aún no pude averiguar mis olvidados passwords, y tampoco avanzo muy rápido, pero bue...

Proyecto 3:
Aprender a hacer programas que resuelvan dudas.
No sé bien qué pasó con esto, intenté varias cosas pero es como que no avanzo. Hace muy poco decidí, en vez de intentar imaginar dudas simples, partir de conocidas, simplificarlas y luego irlas complicando. Aún no empecé con eso.

Proyecto 4:
Hacer programa que genere todos los posibles dibujos, uno a uno, evitando los que no cumplen ciertas condiciones.
Al principio del año, el programa mostraba todos los dibujos, o al menos no vi que evitara algunos, no recuerdo. Ahora ya evita, e intento que evite más eficientemente. Tuve varios entreveros y cambié varias cosas. Hace poco me di cuenta de que el dibujo mayor (si se considera representado por un número) válido no es una / (nota: 1 es blanco, 0 es negro):
110
101
011
que es 110101011
sino este estilo
110
110
001
que es 110110001
Esta es la versión más estable que tengo, creo:
https://drive.google.com/file/d/1SAzKGQ5u2LdCQshSr1jacnrSIms9C5aw/view?usp=sharing
Incluye el editable, su swf y exe. Luego de un que se genere una imagen deben presionar espacio, pueden dejarlo presionado para que avance más rápido. La idea era ver cosas interesantes ¿conocen los test de Rorscharch? Pero resultó aburrido. Aún así, creo que me servirá esto, en mi siguiente proyecto:

Proyecto 5:
Hacer programa que genere varios dibujos, principalmente con el objetivo de servir de sprites.
Hay mucho que debo agregarle, y no todo está funcionando bien, ni evita errores. Además de poder cambiar algunas cosas con botones, pueden cliquear los dibujos, eso hará que muten un poco; la idea es ir seleccionando el que más guste, pero al final es como que conviene más editarlo en Paint xP
https://drive.google.com/file/d/1Boo6Ca33MMalrVe6uT0F8vCLJhnk0uyj/view?usp=sharing

Proyecto 6:
Hacer juegos.
Similarmente a con las dudas, es como que he dado muchas vueltas, sin avanzar. Hace muy poco decidí, en vez de intentar hacer juegos simples (que es complicado idear una justificación para lo que son o sucede en ellos), imitar a los de acá:
https://www.mobygames.com/game/sort:date/page:1/
simplificando. Empecé por el 3 en línea. Aún no lo tengo hecho porque empecé hace poco, además nunca había hecho ese juego ni alguno tan similar. Por ahora sólo se puede cambiar ek tamaño del tablero y poner cruces:

Si llego a tener algo que más o menos valga la pena dar, se los paso.

Proyecto 7:
Participar en competencias de juegos.
Me refiero a elegir un modo de jugar, una especie de reto (aunque debe ser medible qué tan bien se logra), y jugar.
Hice:
- En un juego de acción, Donkey Kong, obtener el máximo Score posible en el 1er loop.
- En un juego de puzzle, Lode Runner, pasar las stages intentando no hacer agujeros.
Eso ha sido difícil, con estos dedos que aún los tengo medio mal y presionaba teclas sin querer, hacer un agujero en un sitio indebido requería volver a empezar, en general no ha sido divertido. También había que ver cómo se comportaban los enemigos, dependía mucho de hallar "errores" en su comportamiento.
Ahora estoy con:
- En un juego de carreras, Excitebike, pasar los tracks... es difícil explicar cómo, hice un video sobre eso, pero aún no lo subí, estoy esperando a pasar el 4, pero básicamente es intentar pasar el juego evitando presionar botones distintos al A. Tampoco es divertido, es horrible, el juego es como muy azaroso, a veces choca y a veces no, a veces rebota un poquito aunque se caiga derecho; lo que hago entonces es buscar un modo seguro de clasificar, aunque no sea el que menos botones use, por lo que mi partida podría ser superada si se tiene suerte.
He logrado pasar el 4 usando 20 botones sin contar el A. Este mapa muestra cómo, en el video lo pondré completo:

Lo que más me gusta es hacer experimentos en juegos de estrategia, esto de evitar presionar botones también pero no en un juego tan azaroso o que depende tanto del momento justito en que hagas una cosa u otra, además como dije es jodido porque si presionas uno sin querer o por costumbre porque normalmente conviene, perdiste. Pero ya llegará el momento, ojalá.
La mayoría de competencias que hace la gente son sobre pasar el juego rápido, es algo que no limita tu habilidad, pero no soy bueno en eso, en entender qué es mejor cuando se tienen muchas opciones, así que suelo preferir limitar las opciones, aprender así, y si luego me interesa entonces limitar menos y así sucesivamente. Además aburre un poco ver siempre lo mismo, siempre todo rápido, es como si no disfrutaran los juegos, algunos hasta usan bugs que le quitan la gracia.
Por otro lado, avancé bastante en comprender cuales son las posibles competencias. Pero es difícil explicar sobre eso, pueden ver esto si quieren pero no es tan claro:
https://drive.google.com/file/d/1UrpdCxgao0r4OlUnRg9agxSu8TZThANs/view?usp=sharing
Comiencen por el exe o swf y usen las flechas de derecha o izquierda, no usen las de arriba o abajo porque nada aparecerá. Luego el archivo de Excel muestra cosas que pueden obtenerse o contarse de una partida de Dragon Warrior especialmente, pero tiene cierta validez para otros juegos.

Intenté otras cosas ese año pero avancé poco en ellas y preferí enfocarme en menos cosas para avanzar más rápido, que aún así no ha servido de mucho.

En vez de querer darme trabajo quieren darme pastillas, no tengo idea de qué hacer, mi problema además de la torpeza es que me resulta muy complicado cumplir horarios, no duermo a una hora especifica, puede cambiar. Fui a una organización donde supuestamente ayudan a la gente pero la señora de ahí no quiso leer algo que escribí, ni decirme en cuántas palabras quería que se lo diga, se puso a leer la parte final, no entendió, y me fui porque pa qué hablar con gente así.

Tal vez debería escribir menos y hacer más, escribo diarios de lo que hago, pero creo que me ayuda a pensar mejor, concentrarme mejor, además me olvido muchas cosas y tener anotadas las cosas claro que ayuda, por ejemplo errores que debo corregir o cosas que se me ocurrieron agregar.
152  Informática / Software / Re: ¿Qué son los archivos ~$algo.xlsx o docx? en: 1 Enero 2025, 10:29 am
Actualmente hay 2, pero he visto más. Al usar AllDup, un programa que busca duplicados, en ciertas carpetas encuentra 2 iguales de esos. Pero según he visto no tengo un doc ahí con esos nombres (quitando los $ y demás). Ni siquiera puedo ver esos archivos raros. Windows dice que recomienda ocultar archivos protegidos así que lo dejo así, pero ¿están protegidos esos o por qué no los veo? ¿cuántos más tipos de archivos invisibles pude haber movido al mover carpetas enteras o haber borrado al borrarlas porque aparentemente estaban vacías? Me ha dejado confuso esto ¿qué sentido tiene que me oculten archivos que no deberían existir? No sé cómo quedaron ahí, ponele que tenía un archivo llamado Hola.doc y lo moví o borré o le cambié el nombre y quedó este otro ~$ o lo que sea, es cualquiera.
153  Foros Generales / Foro Libre / Re: ¿Qué pasa con el foro 3DJuegos? en: 30 Diciembre 2024, 20:34 pm
Era la curiosidad por saber qué pasa, si alguien estaba ahí, si les pasaba lo mismo, cosas así.
154  Foros Generales / Foro Libre / Re: ¿Qué pasa con el foro 3DJuegos? en: 30 Diciembre 2024, 20:04 pm
Pensé que podía ser una medida anti troll o anti usuario poco serio/sincero, según su criterio. Lo de que sólo funcione para españoles también lo pensé, pero sea el caso o no, comprenderás que me parece un disparate tener que usar un VPN para usar un foro o hacer trámites sin sentido.
155  Programación / Programación General / Re: Evitar o corregir entrada de valores inaplicables. en: 30 Diciembre 2024, 18:35 pm
No sabía que se podía hacer eso  ;-) pero no había tenido en cuenta lo que dices al final. Considerando que se requiere una correccion que no puede hacerlo ese código, al final no tiene mucho sentido usarlo, sólo para evitar el ingreso de caracteres extraños, sí, pero se pueden descartar en el otro lado.
156  Programación / Programación General / Generar funciones. en: 30 Diciembre 2024, 06:30 am
Al parecer todas las dudas relacionadas con quitar caracteres requieren 3 variables mínimo, yo quería sólo 2, así que voy a por operaciones comúnes donde parece que sí pueden ser 2.

El programa intentaría resolver una duda variable, algo así:
Definir Constante.
Seleccionar al azar cómo se aplicará el Candidato.
Definirlo.
Aplicarlo.
Variarlo hasa que Constante < Resultado.

Quiero ayuda con lo de seleccionar. El paso de aplicar el candidato sería llamar a una función especificada por el paso de seleccionar. Seleccionarla es fácil. Llamar a una función variable no es el problema. Es que son muchas posibles aplicaciones, o funciones, por ejemplo:
Aplicacion0 () {
   Resultado = Candidato;
}
Aplicacion1 () {
   Resultado = Candidato+Constante;
}
Aplicacion2 () {
   Resultado = Candidato+Candidato;
}
Aplicacion3 () {
   Resultado = Candidato-Constante;
}
etc

O sea, el programa intentaría resolver una duda al azar, dependiendo de qué función elija al principio, por ejemplo si elige la 2 es:
¿Qué valor conviene darle a Candidato para que Constante < Candidato+Candidato?
Pero la condición en el código sería Constante < Resultado, en eso se guardaría el resultado de las operaciones que hagan falta.

Así pues, necesito generar una lista de funciones o aplicaciones. En la definición de Resultado pueden usarse sólo las 2 variables mencionadas. Y operaciones matemáticas comúnes. Y paréntesis. 3 operaciones máximo.

Bueno, supongo que es algo como:
Aplicacion = 0
Repetir:
   Mostrar en pantalla "Aplicacion"+Aplicacion+" () {"+salto de línea+"   Resultado = "
...es decir, falta una parte, que no sé, pero la idea es que un programa genere esas funciones, las muestre, yo las copio y las pego en el programa que quiero hacer, o sea, el generador es como un subprograma, un medio.

Hay que variar lo que viene luego de "= ".

¿Ideas?

No tengo puntos para GPTear, cuando pueda lo hago.
157  Informática / Software / ¿Qué son los archivos ~$algo.xlsx o docx? en: 30 Diciembre 2024, 05:11 am
Entiendo que son como trozos de recuperación de otros archivos, modificaciones que no fueron guardadas ¿alguien me confirma o me da más info?

Intento eliminar archivos repetidos y no sé bien qué hacer con estos, al no saber bien qué son.
158  Informática / Software / Re: Programa para ordenar archivos, Windows 7 "cierra" el buscador al abrir la carpeta contenedora. en: 30 Diciembre 2024, 05:06 am
Por ahora sigo usando el buscador común y lo resolví usando lo último que dijiste.

Me entrevera un poco lo de Control + Enter ¿no abre las propiedades eso? ¿en qué casos no?
159  Seguridad Informática / Hacking / Re: Descartar combinaciones de caracteres al buscar password. en: 30 Diciembre 2024, 01:17 am
A GPT:
Quiero saber qué combinaciones de 2 letras no ocurren en español ni inglés, pudiéndose juntar palabras. Por ejemplo hh parece imposible, debería ser una palabra que termine en h seguida de otra que empiece por h. ¿Cuales son las combinaciones inexistentes?

Citar
Encontrar combinaciones de dos letras que no ocurren ni en español ni en inglés es un problema interesante, pero también algo complejo. Para resolverlo, podemos plantear un método lógico basado en las siguientes consideraciones:

1. **Las combinaciones de letras posibles**: Hay 26 letras en el alfabeto inglés y 27 en el español (incluyendo la "ñ"), lo que da lugar a **676 combinaciones posibles en inglés** (26 × 26) y **729 combinaciones posibles en español** (27 × 27).

2. **Análisis de las combinaciones**: Para identificar combinaciones que no existen, necesitamos revisar listas extensas de palabras en ambos idiomas, considerando no solo palabras individuales sino también casos donde una palabra termina en una letra y la siguiente comienza con otra.

3. **Ejemplo de combinaciones poco probables**:
   - En español, combinaciones como **hh**, **ñk**, o **wq** son muy improbables porque no se corresponden con patrones fonéticos comunes ni reglas del idioma.
   - En inglés, combinaciones como **ñx**, **qq**, o **ww** son igualmente improbables.

4. **Método detallado para encontrar combinaciones inexistentes**:
   - Revisar diccionarios completos de español e inglés.
   - Analizar combinaciones de letras en palabras individuales y en pares de palabras consecutivas.
   - Identificar combinaciones que no aparecen ni dentro de las palabras ni entre palabras consecutivas.

Sin acceso directo a bases de datos de vocabulario, no puedo generar una lista exhaustiva ahora, pero puedo ofrecerte **algunos ejemplos de combinaciones que probablemente no existan**:

---

### Ejemplos de combinaciones improbables:

#### En español:
- **hh**: No hay palabras que terminen en "h" y otras que comiencen en "h".
- **ñk**: La "ñ" nunca se combina con "k".
- **wq**: La "w" en español ya es rara, y no se combina con "q".
- **qx**: La combinación "q" siempre va seguida de "u" en español.
- **ñw**: No hay palabras en español que incluyan esta combinación.

#### En inglés:
- **ñx**: La "ñ" no existe en inglés.
- **qq**: Aunque hay palabras que contienen "q", no se repite consecutivamente.
- **hh**: Aunque palabras como "happiness" tienen "h", la doble "h" no ocurre en inglés estándar.
- **ww**: No hay palabras con "ww" consecutivo.
- **kx**: La combinación "k" seguida de "x" no ocurre.

---

### Cómo verificar combinaciones inexistentes
Si quieres una lista completa y precisa de combinaciones inexistentes, necesitarías:
1. Bases de datos de vocabulario en español e inglés (como los diccionarios de la RAE o el Oxford English Dictionary).
2. Un programa que recorra todas las combinaciones posibles de dos letras y revise si ocurren en las palabras o entre palabras consecutivas.

Puedo ayudarte a diseñar un algoritmo para esto. Por ejemplo:

---

#### Algoritmo para encontrar combinaciones inexistentes:

1. Genera todas las combinaciones de dos letras (por ejemplo, usando un bucle en Python).
2. Busca esas combinaciones en listas de palabras en español e inglés.
3. Marca las combinaciones que no aparecen en ninguna palabra ni entre palabras consecutivas.

Si estás interesado, puedo escribir un programa básico para ello en pseudocódigo o Python. ¿Te interesa?

Sí, ya tengo un diccionario txt en español y otro en inglés

Citar
¡Perfecto! Con los diccionarios en formato `.txt`, podemos usar un programa en Python para analizar todas las combinaciones posibles de dos letras y verificar cuáles no aparecen ni en el diccionario de español ni en el de inglés. A continuación, te muestro un script paso a paso que hace esto.

### Suposiciones:
1. Tienes dos archivos `.txt`:
   - `diccionario_es.txt` (para español).
   - `diccionario_en.txt` (para inglés).
2. Cada palabra está en una línea separada dentro de los archivos.

El programa hará lo siguiente:
1. Leerá las palabras de ambos diccionarios.
2. Generará todas las combinaciones de dos letras posibles (676 combinaciones en inglés y 729 en español).
3. Verificará si esas combinaciones aparecen dentro de las palabras o entre palabras consecutivas.
4. Listará las combinaciones que no aparecen en ninguno de los dos diccionarios.

### Código Python

```python
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))
```

### Explicación del código:

1. **Cargar el diccionario**:
   - La función `cargar_diccionario` lee las palabras del archivo `.txt`, las convierte a minúsculas y las guarda en un conjunto (`set`) para facilitar búsquedas rápidas.

2. **Generar combinaciones**:
   - La función `generar_combinaciones` utiliza `itertools.product` para generar todas las combinaciones posibles de dos letras en el alfabeto.

3. **Buscar combinaciones dentro de las palabras**:
   - Se recorren todas las palabras del diccionario para encontrar combinaciones de dos letras consecutivas (por ejemplo, "ab" en "caballo").
   - También se buscan combinaciones entre palabras consecutivas. Por ejemplo, si una palabra termina en "a" y la siguiente empieza con "b", la combinación "ab" se considera presente.

4. **Identificar combinaciones inexistentes**:
   - Las combinaciones que no aparecen en las palabras ni entre palabras consecutivas se guardan como "inexistentes".

5. **Cruzar resultados**:
   - Las combinaciones inexistentes en español y en inglés se cruzan (`intersection`) para obtener el conjunto final de combinaciones que no ocurren en ninguno de los dos idiomas.

---

### Ejemplo de uso:

Supón que tienes los siguientes archivos:

**`diccionario_es.txt`**:
```
hola
mundo
árbol
niño
```

**`diccionario_en.txt`**:
```
hello
world
tree
child
```

Cuando ejecutes el programa, obtendrás un resultado similar a este:

```
Combinaciones inexistentes en ambos idiomas (ejemplo):
['hh', 'ñk', 'ñw', 'ww', 'qx', 'zñ']
```

---

### Requisitos:
1. **Python 3.x**.
2. Instala cualquier editor de texto para modificar los diccionarios, si es necesario.
3. Asegúrate de que los archivos `diccionario_es.txt` y `diccionario_en.txt` estén en la misma carpeta que el script.

---

### Personalización:
Si necesitas ajustar el alfabeto o realizar análisis adicionales (por ejemplo, incluir más idiomas o caracteres especiales), puedes modificar las variables `alfabeto_es` y `alfabeto_en` fácilmente.

¿Te gustaría que te ayude a extender este programa o resolver algún detalle adicional? 😊

¿Cual es el resultado más o menos exacto de:
Código
  1. def cargar_diccionario(ruta):
  2.    """Carga el diccionario desde un archivo .txt y devuelve un conjunto de palabras en minúsculas."""
  3.    with open(ruta, 'r', encoding='utf-8') as archivo:
  4.        return set(palabra.strip().lower() for palabra in archivo)
  5.  
?
Entiendo que depende de cómo sea el diccionario, supongamos que fuera:
Ábaco
Abajo
Abeja
Abejorro

Citar
Si el archivo del diccionario (`ruta`) contiene las palabras:

```
Ábaco
Abajo
Abeja
Abejorro
```

El resultado de la función **`cargar_diccionario`** será un **conjunto (`set`) de palabras en minúsculas** y sin espacios adicionales. Vamos a analizar el proceso paso a paso:

1. **Lectura del archivo**: La función abre el archivo en modo lectura (`'r'`) con codificación `utf-8`.
2. **Procesamiento línea por línea**:
   - Cada línea se limpia con `.strip()` para quitar espacios en blanco (como saltos de línea `\n`).
   - Luego se convierte a minúsculas con `.lower()`.
3. **Conversión a un conjunto (`set`)**:
   - Se eliminan duplicados automáticamente, ya que un conjunto solo contiene elementos únicos.

### Resultado esperado

El archivo contiene estas palabras:

```
Ábaco
Abajo
Abeja
Abejorro
```

Después de aplicar la función, obtendremos:

```python
{'ábaco', 'abajo', 'abeja', 'abejorro'}
```

### Detalles importantes

1. **Conversión a minúsculas**:
   - Las palabras como "Ábaco" se convierten a "ábaco" porque `.lower()` transforma las letras mayúsculas en minúsculas.

2. **Espacios en blanco**:
   - Si las líneas del archivo tienen espacios al inicio o al final, `.strip()` los elimina. Por ejemplo:
     ```
     "   Ábaco   " → "ábaco"
     ```

3. **Eliminación de duplicados**:
   - Si el archivo contiene palabras repetidas, solo se conservará una instancia en el conjunto. Por ejemplo:
     ```
     Ábaco
     Abajo
     Ábaco
     ```
     Resultado:
     ```python
     {'ábaco', 'abajo'}
     ```

### ¿Qué pasa con caracteres especiales?

La función no elimina caracteres especiales (como tildes o signos de puntuación). Si el archivo contiene palabras como:

```
Ábaco.
Abajo,
Abeja!
```

El resultado será:

```python
{'ábaco.', 'abajo,', 'abeja!'}
```

Si quisieras limpiar estos caracteres (por ejemplo, eliminando puntos, comas o signos), habría que modificar la función para incluir procesamiento adicional, como el uso de expresiones regulares.

---

### Resumen

Dado tu diccionario de ejemplo, el resultado exacto será:

```python
{'ábaco', 'abajo', 'abeja', 'abejorro'}
```

Esto asume que no hay duplicados ni caracteres especiales en el archivo. Si quieres extender el procesamiento (por ejemplo, para limpiar caracteres o normalizar acentos), puedo ayudarte a ajustar la función. 😊

Pasa que cuando dijo "    """Carga el diccionario desde un archivo .txt y devuelve un conjunto de palabras en minúsculas.""" "
no lo entendí, más claro sería:
"""Carga el diccionario desde un archivo .txt y devuelve un conjunto de palabras tal como las del diccionario pero convertidas en minúsculas, sin incluir espacios ni repetidas"""


¿Deberé hacer algo con respecto a tildes? ¿agregarlos en los caracteres de alfabeto_es? Ya que "a" no es lo mismo que "á" ¿no?

Citar
¡Excelente pregunta! Efectivamente, en Python (y muchos lenguajes de programación), **"a" y "á" son caracteres distintos**, ya que las tildes son técnicamente caracteres diferentes en Unicode. Esto significa que si deseas incluir combinaciones que contengan letras con tildes, deberás **ampliar el alfabeto** que se utiliza para generar las combinaciones.

---

### ¿Qué hacer con las tildes?

1. **Ampliar el alfabeto**:
   - El alfabeto en español no solo incluye las letras estándar (a-z y ñ), sino también las vocales con tilde: `á, é, í, ó, ú`.
   - Si no incluyes estas vocales con tilde en `alfabeto_es`, no se generarán combinaciones que las contengan.

2. **Revisar las palabras del diccionario**:
   - Si en el diccionario aparecen palabras con tildes (como "árbol" o "niño"), esas combinaciones (por ejemplo, "á" seguida de "r") deben estar en el alfabeto para poder encontrarlas y analizarlas.

3. **Normalización de tildes (opcional)**:
   - Si no quieres diferenciar entre vocales con y sin tilde, puedes "normalizar" las palabras del diccionario eliminando las tildes. Esto simplificaría el análisis, pero perderías la distinción entre "a" y "á".

---

### ¿Cómo modificar el código para incluir tildes?

Debes agregar las vocales con tilde al alfabeto español que se utiliza para generar las combinaciones. El alfabeto quedaría así:

```python
alfabeto_es = 'abcdefghijklmnñopqrstuvwxyzáéíóú'
```

Esto asegura que las combinaciones como "áb", "éx", "ñá", etc., se generen y puedan ser verificadas.

---

### Si decides ignorar tildes

Si prefieres no trabajar con tildes y tratar "a" y "á" como equivalentes, puedes **normalizar** las palabras del diccionario eliminando las tildes. Para ello, puedes usar la biblioteca `unicodedata` de Python:

```python
import unicodedata

def normalizar_palabra(palabra):
    """Elimina tildes y normaliza una palabra."""
    nfkd = unicodedata.normalize('NFKD', palabra)
    return ''.join(c for c in nfkd if not unicodedata.combining(c))

def cargar_diccionario_normalizado(ruta):
    """Carga el diccionario y normaliza eliminando tildes."""
    with open(ruta, 'r', encoding='utf-8') as archivo:
        return set(normalizar_palabra(palabra.strip().lower()) for palabra in archivo)
```

Con esta función, palabras como "árbol" se convertirán en "arbol". Esto significa que no necesitarás agregar las vocales con tilde al alfabeto, ya que todo estará simplificado.

El inconveniente aquí es que pierdes la distinción entre palabras con y sin tilde, lo cual podría ser problemático en análisis lingüísticos más precisos.

---

### Ejemplo práctico

#### Si no normalizas (trabajas con tildes):

**Diccionario (`diccionario_es.txt`):**
```
árbol
niño
canción
abeja
```

**Configuración del alfabeto:**
```python
alfabeto_es = 'abcdefghijklmnñopqrstuvwxyzáéíóú'
```

El programa generará y buscará combinaciones como:
- "ár", "ró", "ól" (de "árbol").
- "ni", "iñ", "ño" (de "niño").
- "ca", "an", "nc", "ci", "ió", "ón" (de "canción").

**Resultado (combinaciones inexistentes):**
Incluirá cualquier combinación que no aparezca entre las palabras del diccionario (respetando tildes).

---

#### Si normalizas (eliminas tildes):

**Diccionario (`diccionario_es.txt`):**
```
árbol
niño
canción
abeja
```

**Configuración del alfabeto:**
```python
alfabeto_es = 'abcdefghijklmnñopqrstuvwxyz'
```

Después de la normalización, las palabras se transformarán en:
```
arbol
nino
cancion
abeja
```

El programa buscará combinaciones como:
- "ar", "rb", "bo", "ol" (de "arbol").
- "ni", "in", "no" (de "nino").
- "ca", "an", "nc", "ci", "io", "on" (de "cancion").

**Resultado (combinaciones inexistentes):**
El análisis será más simple, pero no distinguirá entre "a" y "á", "e" y "é", etc.

---

### ¿Qué método es mejor?

Depende del nivel de precisión que busques:

1. **Si quieres un análisis preciso y respetar las tildes**, incluye las vocales con tilde en el alfabeto (`áéíóú`) y no normalices las palabras.

2. **Si prefieres simplificar el análisis y no diferenciar entre vocales acentuadas y no acentuadas**, normaliza las palabras eliminando las tildes.

Ambos enfoques son válidos, pero **normalizar es más simple si no tienes un requerimiento específico de distinguir tildes**.

¿Te gustaría que ajuste el código para alguno de los dos enfoques? 😊

Entiendo que el siguiente código genera las combinaciones posibles, como "aa", "ab", etc, pero ¿cómo lo hace, qué son las sumas y restas?
Código
  1. def buscar_combinaciones(diccionario, combinaciones):
  2.    """Busca combinaciones dentro de las palabras del diccionario."""
  3.    presentes = set()
  4.  
  5.    # Buscar combinaciones dentro de palabras individuales
  6.    for palabra in diccionario:
  7.        for i in range(len(palabra) - 1):
  8.            presentes.add(palabra[i:i+2])
  9.  
  10.    # Buscar combinaciones entre palabras consecutivas
  11.    lista_palabras = sorted(diccionario)  # Ordenar las palabras
  12.    for i in range(len(lista_palabras) - 1):
  13.        ultima_letra = lista_palabras[i][-1]
  14.        primera_letra = lista_palabras[i + 1][0]
  15.        presentes.add(ultima_letra + primera_letra)
  16.  
  17.    return combinaciones - presentes

Citar
¡Buena pregunta! Vamos a analizar el código línea por línea, explicando cómo funciona y qué significa cada operación, especialmente las que parecen "sumas" y "restas" en el contexto del programa.

El código tiene dos partes principales:

1. **Buscar combinaciones dentro de palabras individuales**.
2. **Buscar combinaciones entre palabras consecutivas**.

Finalmente, hace una operación de **diferencia de conjuntos** para devolver las combinaciones inexistentes.

---

### **Primera parte: Buscar combinaciones dentro de palabras individuales**

```python
for palabra in diccionario:
    for i in range(len(palabra) - 1):
        presentes.add(palabra[i:i+2])
```

#### ¿Qué hace?

Este bucle recorre cada palabra en el `diccionario` y busca **combinaciones de dos letras consecutivas** dentro de cada palabra.

1. `palabra[i:i+2]`:
   - Esto es **slicing** en Python, que toma un segmento de la palabra.
   - Por ejemplo, si `palabra = "abeja"`, el bucle producirá los siguientes pares:
     - `palabra[0:2] = "ab"`
     - `palabra[1:3] = "be"`
     - `palabra[2:4] = "ej"`
     - `palabra[3:5] = "ja"`
   - Estas combinaciones se añaden al conjunto `presentes`.

2. `len(palabra) - 1`:
   - El rango del bucle termina en `len(palabra) - 1` porque estamos tomando dos letras a la vez (`i:i+2`). Si no restáramos 1, intentaríamos acceder a una posición fuera del límite de la palabra.

#### Resultado:

Después de este bucle, el conjunto `presentes` contendrá todas las combinaciones de dos letras consecutivas que aparecen **dentro de las palabras individuales** en el diccionario.

---

### **Segunda parte: Buscar combinaciones entre palabras consecutivas**

```python
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)
```

#### ¿Qué hace?

Este bucle busca combinaciones **entre la última letra de una palabra y la primera letra de la siguiente**. Esto sirve para capturar combinaciones que podrían formarse cuando dos palabras están juntas.

1. `sorted(diccionario)`:
   - Se ordena el diccionario alfabéticamente (no es estrictamente necesario para el análisis, pero puede ayudar a mantener un orden lógico en los pares de palabras consecutivas).

2. `for i in range(len(lista_palabras) - 1)`:
   - Se recorre la lista de palabras, pero solo hasta la penúltima palabra (`len(lista_palabras) - 1`), ya que estamos comparando cada palabra con la siguiente.

3. `ultima_letra = lista_palabras[-1]`:
   - Esto selecciona la **última letra** de la palabra en la posición `i`.
   - Por ejemplo, si la palabra es `"abeja"`, entonces `lista_palabras[-1] = "a"`.

4. `primera_letra = lista_palabras[i + 1][0]`:
   - Esto selecciona la **primera letra** de la siguiente palabra (`i + 1`).
   - Por ejemplo, si la siguiente palabra es `"mundo"`, entonces `lista_palabras[i + 1][0] = "m"`.

5. `presentes.add(ultima_letra + primera_letra)`:
   - Las letras se concatenan (se "suman") usando el operador `+` para formar la combinación.
   - Por ejemplo, `"a"` (de `"abeja"`) y `"m"` (de `"mundo"`) formarían `"am"`, que se agrega al conjunto `presentes`.

#### Resultado:

Después de este bucle, el conjunto `presentes` incluirá combinaciones formadas **entre palabras consecutivas**, además de las combinaciones dentro de palabras individuales que ya se agregaron en la primera parte.

---

### **Tercera parte: Diferencia de conjuntos**

```python
return combinaciones - presentes
```

#### ¿Qué hace?

1. `combinaciones`:
   - Es un conjunto que contiene **todas las combinaciones posibles de dos letras** generadas previamente (por ejemplo, usando `itertools.product`).

2. `presentes`:
   - Es el conjunto de combinaciones que realmente aparecen en las palabras del diccionario (ya sea dentro de palabras individuales o entre palabras consecutivas).

3. `combinaciones - presentes`:
   - Esta es una **diferencia de conjuntos** en Python.
   - Devuelve un nuevo conjunto que contiene las combinaciones que están en `combinaciones` pero no en `presentes` (es decir, las combinaciones que no aparecen en el diccionario).

#### Resultado:

El resultado es un conjunto que contiene todas las combinaciones de dos letras que **no aparecen ni dentro de palabras individuales ni entre palabras consecutivas**.

---

### **Resumen del flujo del código**

1. **Primera parte**:
   - Busca todas las combinaciones de dos letras consecutivas **dentro de las palabras individuales** y las agrega al conjunto `presentes`.

2. **Segunda parte**:
   - Busca combinaciones entre la última letra de una palabra y la primera letra de la siguiente, y las agrega al conjunto `presentes`.

3. **Diferencia de conjuntos**:
   - Compara el conjunto de todas las combinaciones posibles (`combinaciones`) con las combinaciones encontradas (`presentes`) y devuelve las combinaciones que no se encontraron.

---

### **¿Qué son las "sumas y restas"?**

1. **Suma (`+`)**:
   - En este contexto, se usa para **concatenar dos letras** y formar una combinación, como `"a" + "b" = "ab"`.
   - No es una suma matemática; es una operación de concatenación de cadenas.

2. **Resta (`-`)**:
   - Aquí, se refiere a la **diferencia de conjuntos**, que elimina los elementos de `presentes` del conjunto `combinaciones`.
   - Por ejemplo:
     ```python
     combinaciones = {'aa', 'ab', 'ac', 'ad'}
     presentes = {'aa', 'ab'}
     resultado = combinaciones - presentes  # {'ac', 'ad'}
     ```

---

### Ejemplo práctico:

Supongamos que el diccionario tiene las palabras:

```python
diccionario = {'abeja', 'mundo'}
```

1. **Combinaciones dentro de palabras:**
   - `"abeja"` produce: `{'ab', 'be', 'ej', 'ja'}`
   - `"mundo"` produce: `{'mu', 'un', 'nd', 'do'}`

2. **Combinaciones entre palabras consecutivas:**
   - Última letra de `"abeja"` (`a`) + primera letra de `"mundo"` (`m`) produce: `{'am'}`

3. **Total de combinaciones presentes:**
   - `presentes = {'ab', 'be', 'ej', 'ja', 'mu', 'un', 'nd', 'do', 'am'}`

4. **Combinaciones posibles (`combinaciones`):**
   - Supongamos que son todas las combinaciones posibles del alfabeto: `{'aa', 'ab', 'ac', ..., 'zz'}`.

5. **Faltantes:**
   - `combinaciones - presentes` devolverá todas las combinaciones que no están en `presentes`.

---

¿Te gustaría que haga un ejemplo más detallado con combinaciones generadas y resultados completos? 😊

Otro día sigo, demasiada cosa rara para mí por hoy.

¿Sugerencias?
160  Programación / Programación General / Evitar o corregir entrada de valores inaplicables. en: 28 Diciembre 2024, 14:38 pm
Tengo deshabilitado que se pueda editar los colores escribiendo en sus cuadros de texto:

porque si lo habilito tendría que hacer lo que menciono en el título, y por ahora no quería. De hecho mejor sigo con otra cosa más importante, pero por curiosidad, supongamos que escribo algo inaplicable, algo que no sea un color tal como el programa lo entiende ¿luego qué? Creo que en MF5 no existe un corrector automático mientras uno escribe ¿debería poner una función correctora, antes de que se generen las imágenes?
Se generan al principio y cuando se presiona algún botón. Supongo que es lo más sencillo.

Lo que vi en el tutorial es que tienen un botón de "aplicar", o sea, se ingresa el valor, y luego se aplica con el botón, que se podría programar que se active con Enter también. Pero en el tutorial es un cuadro de texto y un botón, acá como que ya no me queda espacio para poner eso xP (abajo irían unas flechitas para cambiar las opciones, pero el botón en cuestión debería verse con estas) Además en este caso deberían ser 10 botones o uno que revise si cada texto está bien.

Otra posibilidad es que cliquear el texto agregue una ventana donde se pueda editar, esté el botón de "Modificar" y si el valor ingresado está mal entonces avisa que no se modificó, debido a eso.

¿Qué recomiendan?

¿Y cuales son los riesgos de Flash? GPT me dijo que se podía poner eval algo en los cuadros de texto, quizá leí mal, porque no le presté mucha atención a eso en ese momento.
Páginas: 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 ... 240
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines