|
21
|
Seguridad Informática / Seguridad / Re: He llegado a casa y el pc estaba apagado
|
en: 9 Enero 2025, 01:08 am
|
Sólo pensé en la corriente, no tendría mucho sentido que te lo apaguen, a menos que sea pro economizar el hacker.
No sé para qué la dejas encendida, yo la apagaría para evitar riesgos de incendio, que se estropee sin estarla usando, gastos en vano de electricidad, y si vamos al caso, posibles hackeos. ¿Puede encenderla un hacker? Desenchufarla quizá es mucho pedir. Mi alargue es muy sensible, lo toco y deja de funcionar bien, así que simplemente la apago. Debe descansar la pobre. A lo mejor se cansó o se aburrió xD
|
|
|
22
|
Programación / Programación General / Re: ¿Qué método es recomendado para ordenar al azar un array?
|
en: 8 Enero 2025, 06:45 am
|
Ok a los dos. Ojo, EdePC, que según mi interpretación de tu código ningún elemento puede quedar donde estaba, o sólo el 1ero. Voy a probarlo y te aviso si me equivoqué. Me cuesta entender el por qué de tantas cuentas cuando se va de izquierda a derecha, lo voy a pensar. Edit: Hice varias pruebas y sucedió eso: Rojo,Negro,Azul,Verde,Blanco Blanco,Negro,Rojo,Verde,Azul Verde,Blanco,Rojo,Negro,Azul Verde,Negro,Rojo,Azul,Blanco Blanco,Azul,Negro,Verde,Rojo Rojo,Blanco,Negro,Verde,Azul Verde,Azul,Negro,Rojo,Blanco Rojo,Verde,Negro,Azul,Blanco Verde,Negro,Rojo,Azul,Blanco Rojo,Blanco,Negro,Verde,Azul Rojo,Verde,Blanco,Negro,Azul Negro,Blanco,Rojo,Azul,Verde Verde,Azul,Blanco,Negro,Rojo Blanco,Verde,Azul,Negro,Rojo Rojo,Verde,Negro,Azul,Blanco Verde,Blanco,Negro,Azul,Rojo Blanco,Azul,Negro,Verde,Rojo Verde,Azul,Negro,Rojo,Blanco Verde,Azul,Negro,Rojo,Blanco Blanco,Verde,Azul,Negro,Rojo Negro,Verde,Azul,Rojo,Blanco Verde,Negro,Rojo,Azul,Blanco Verde,Negro,Blanco,Rojo,Azul Blanco,Negro,Azul,Rojo,Verde Rojo,Negro,Azul,Verde,Blanco Verde,Blanco,Negro,Azul,Rojo Blanco,Verde,Negro,Rojo,Azul Verde,Blanco,Negro,Azul,Rojo Rojo,Blanco,Negro,Verde,Azul Negro,Verde,Blanco,Azul,Rojo Rojo,Blanco,Azul,Negro,Verde Negro,Verde,Blanco,Azul,Rojo Negro,Blanco,Rojo,Azul,Verde El negro nunca quedó último, el blanco nunca penúltimo, el verde nunca 3ero, el rojo nunca 2ndo, y hasta el azul nunca 1ero. No sé si fue tu intención hacerlo así porque no nos entendimos o es un error. Cuando dije reordenar, me refería a también a la posibilidad de que no haya cambios. Pensaré la solución. Edit: Solución con contador incluído: Posicion = -1; do { Posicion++; set ("AzulEn"+Posicion, 0); set ("RojoEn"+Posicion, 0); set ("VerdeEn"+Posicion, 0); set ("BlancoEn"+Posicion, 0); set ("NegroEn"+Posicion, 0); } while (Posicion<4); Repeticion = 0; do { Repeticion++; colores = ["Azul", "Rojo", "Verde", "Blanco", "Negro"]; posicion1aReubicarse = colores.length-1; while (posicion1aReubicarse>0) { posicion2aReubicarse = random(posicion1aReubicarse+1); // trace (Colores[posicion1aReubicarse]+" se intercambiará con "+Colores[posicion2aReubicarse]); saveDeElemento1 = colores[posicion1aReubicarse]; colores[posicion1aReubicarse] = colores[posicion2aReubicarse]; colores[posicion2aReubicarse] = SaveDeElemento1; Resumen = colores[posicion1aReubicarse]+"En"+posicion1aReubicarse; set (Resumen, eval(Resumen)+1); //trace(Resumen); posicion1aReubicarse--; } Resumen = colores[posicion1aReubicarse]+"En"+posicion1aReubicarse; set (Resumen, eval(Resumen)+1); //trace(Resumen); trace (Colores); } while (Repeticion<1000); Posicion = -1; do { Posicion++; trace ("AzulEn"+Posicion+": "+eval("AzulEn"+Posicion)); trace ("RojoEn"+Posicion+": "+eval("RojoEn"+Posicion)); trace ("VerdeEn"+Posicion+": "+eval("VerdeEn"+Posicion)); trace ("BlancoEn"+Posicion+": "+eval("BlancoEn"+Posicion)); trace ("NegroEn"+Posicion+": "+eval("NegroEn"+Posicion)); } while (Posicion<4);
AzulEn0: 207 RojoEn0: 205 VerdeEn0: 195 BlancoEn0: 189 NegroEn0: 204 AzulEn1: 198 RojoEn1: 195 VerdeEn1: 224 BlancoEn1: 185 NegroEn1: 198 AzulEn2: 208 RojoEn2: 198 VerdeEn2: 203 BlancoEn2: 180 NegroEn2: 211 AzulEn3: 187 RojoEn3: 194 VerdeEn3: 204 BlancoEn3: 219 NegroEn3: 196 AzulEn4: 200 RojoEn4: 208 VerdeEn4: 174 BlancoEn4: 227 NegroEn4: 191 O sea, más o menos todos quedaron en todas las posiciones la misma cantidad de veces. Tengo mis dudas sobre si es parejo en cuanto a la probabilidad de que cambien de posición pero tampoco es tan importante, ya está bastante bien.
|
|
|
23
|
Programación / Programación General / ¿Cual es el método más eficiente para ver si hay una línea de S signos?
|
en: 7 Enero 2025, 18:05 pm
|
Conocen el juego 3 en línea, tic tac toe, tateti, etc. Yo estoy haciendo un S en línea, es decir, que el juego permita elegir cuántos signos debe haber en la línea (y qué tan grande es el tablero). Anduve pensando cual es el método más eficiente de ver si alguien ganó. Se me ocurrieron 2 métodos. El 1ero es bastante bruto, más o menos así: Se apunta al superior izquierdo. Repetir: Si no está vacío: Se miran sus contiguos de diagonal derecha-arriba: Si no hay o no marcan victoria: Se miran sus contiguos de la derecha: Si no hay o no marcan victoria: Se miran sus contiguos de diagonal derecha-abajo: Si no hay o no marcan victoria: Se miran sus contiguos de abajo: Si no hay o no marcan victoria: Si hay un casillero hacia abajo: Se empieza a mirar ese. sino si hay casilleros en la derecha: Se empieza a mirar el superior de esa columna. No es necesario que los ifs se repitan, sólo que al escribirlo así nomás quedaba más claro. El otro método intentaba usar menos repeticiones o variaciones de variables, pero a medida que lo analicé llegó un punto en que me parecía igual. En la misma repetición, se apunta a 2 casilleros (al principio son el mismo), y en cada repetición se varía a cual se apunta (y analiza como puse arriba), el 1ero es cada vez más hacia la derecha y el 2ndo hacia abajo. Cuando no quedan, se apunta al diagonal derecho-abajo y se repite el proceso hasta que el apuntado sea el inferior derecho. Empecé a aplicar el método 1: // Por practicidad al calcular, las filas se cuentan desde 0: Fila = -1; // Las columnas no, desde 1: Columna = 0; do { Fila++; SemiReferenciaAlCas = "Casillero"+Fila+"_"; do { Columna++; // Si el casillero no está vacío: if (eval(SemiReferenciaAlCas+Columna != 2)) { // Esto va variando qué siguientes... // casilleros se analizan: Extra = 0; do { Extra++; //
Ahí iría lo de analizar hacia la diagonal arriba-derecha, y el resto de las cosas. Pero siento que es tan poco eficiente que prefiero que me digan algo mejor, que probablemente haya. Sino, más adelante le pregunto a GPT. Por cierto, tengo pensado que la máquina aprenda a jugar experimentando, por eso los valores de los casilleros están grabados de 2 formas, por ejemplo el superior izquierdo: // 2 es vacío, 1 es cruz, 0 es 0. Casillero1 = 2; Casillero1_1 = 2; Porque al hacer referencia a una situación es más fácil variar sólo una variable (no fila y columna). Lo necesito para hacer árboles, no sé cómo lo hacen uds, hablaremos en otra ocasión de eso. Mientras hacía el tema me di cuenta que alcanza con analizar solamente las líneas que impliquen al casillero recién modificado  así que intentaré eso y podría borrar todo esto, pero igual puede ser interesante, luego pongo lo que logre.
|
|
|
24
|
Programación / Programación General / ¿Qué método es recomendado para ordenar al azar un array?
|
en: 7 Enero 2025, 07:16 am
|
Probablemente los lenguajes modernos tienen una función que lo hace, no busco eso. Yo había pensado algo así: Colores = ["Azul", "Rojo", "Verde", "Blanco", "Negro"]; // Esto habría que hacerlo con loop pero no es lo relevante: PesoDeElementos = [Math.random(), Math.random(), Math.random(), Math.random(), Math.random()]; Elemento1aReubicarse = -1; ReordenarHasta = 4; do { Elemento1aReubicarse++; Elemento2aReubicarse = Elemento1aReubicarse+1; if (PesoDeElementos[Elemento1aReubicarse] > PesoDeElementos[Elemento2aReubicarse]) { // Intercambiar esos 2 elementos: SaveDeElemento1 = Colores[Elemento1aReubicarse]; Colores[Elemento1aReubicarse] = Colores[Elemento2aReubicarse]; Colores[Elemento1aReubicarse] = SaveDeElemento1; } if (Elemento2aReubicarse == ReordenarHasta) { // Hacia la derecha ya está reordenado, volver a la izquierda: Elemento1aReubicarse = -1; ReordenarHasta--; } } while (ReordenarHasta > 0);
Pero suponiendo que podía haber algo más sencillo (esa cosa la acabo de hacer, no sé si funciona), le pregunté a GPT. Me dijo un método de Fisher o algo así que no entendí. En Wikipedia tampoco. Pero se me ocurrió (o puede ser igual a lo que no entendí) un método que recorra los elementos, hasta el central, intercambiando los de un lado con los de otro, y luego el central con cualquiera, pero tenía dudas de cómo sería exactamente y ahora noto que no sería justo, es decir, el 1er elemento nunca quedaría 2ndo (salvo que fuesen menos de 4), y además: - Si siempre hay intercambio, nunca podrían quedar en el lugar original, lo cual debería poder suceder. - Si puede no haber intercambio, la probabilidad de que queden igual varios de ellos es muy alta. Así que eso no sirve ¿pero cual es entonces un buen método? Copio la conversación que tuve con GPT: En **Macromedia Flash 5**, que utiliza **ActionScript 1.0**, puedes implementar un algoritmo para reordenar un array al azar utilizando un enfoque conocido como el algoritmo de **Fisher-Yates Shuffle**. Aquí tienes el código que puedes usar para reordenar al azar el array `PosiblesColores`:
```actionscript // Array original PosiblesColores = [0xFFFFFF, 0xFF0000, 0]; // Puedes agregar hasta 10 elementos
// Función para reordenar el array al azar function shuffleArray(array) { var i, j, temp; for (i = array.length - 1; i > 0; i--) { j = Math.floor(Math.random() * (i + 1)); // Genera un índice aleatorio válido // Intercambia los elementos array y array[j] temp = array; array = array[j]; array[j] = temp; } }
// Llama a la función para mezclar el array shuffleArray(PosiblesColores);
// Imprime el array reordenado para verificar for (var i = 0; i < PosiblesColores.length; i++) { trace(PosiblesColores); } ```
### Explicación del código: 1. **Algoritmo Fisher-Yates**: - Este algoritmo recorre el array desde el último elemento hasta el primero. - En cada iteración, selecciona un índice aleatorio entre `0` y el índice actual, e intercambia los dos elementos. - Esto garantiza que cada permutación del array sea igualmente probable.
2. **`Math.random()`**: - Genera un número decimal aleatorio entre `0` y `1`. - Multiplicamos este número por el rango necesario (`i + 1`) para obtener un índice aleatorio válido.
3. **Intercambio de elementos**: - Usamos una variable temporal (`temp`) para almacenar el valor de uno de los elementos mientras realizamos el intercambio.
4. **`trace()`**: - Esta función imprime los valores en el panel de salida para que puedas verificar el resultado del reordenamiento.
### Ejemplo de salida: Si el array original es:
```actionscript PosiblesColores = [0xFFFFFF, 0xFF0000, 0]; ```
Después de ejecutar el código, el array podría quedar como:
```actionscript [0, 0xFFFFFF, 0xFF0000] ```
O cualquier otra permutación aleatoria de los elementos.
Puedes modificar el array `PosiblesColores` para agregar más elementos, y el algoritmo seguirá funcionando correctamente. quisiera que el índice vaya subiendo en vez de bajando y que uses while en vez de for ¡Claro! Aquí está el código modificado para que el índice vaya **subiendo** y se use un bucle `while` en lugar de `for`. El algoritmo sigue siendo equivalente al **Fisher-Yates Shuffle**, pero adaptado a tus especificaciones:
```actionscript // Array original PosiblesColores = [0xFFFFFF, 0xFF0000, 0]; // Puedes agregar hasta 10 elementos
// Función para reordenar el array al azar function shuffleArray(array) { var i = 0; // Empieza desde el primer índice var len = array.length;
while (i < len - 1) { // Genera un índice aleatorio entre i y el último índice var j = Math.floor(Math.random() * (len - i)) + i;
// Intercambia los elementos array y array[j] var temp = array; array = array[j]; array[j] = temp;
// Incrementa el índice i++; } }
// Llama a la función para mezclar el array shuffleArray(PosiblesColores);
// Imprime el array reordenado para verificar var index = 0; while (index < PosiblesColores.length) { trace(PosiblesColores[index]); index++; } ```
### Cambios realizados: 1. **Uso de `while`**: - El índice `i` comienza en `0` y se incrementa en cada iteración hasta el penúltimo elemento (`len - 1`). - El bucle `while` se detiene cuando el índice `i` alcanza el penúltimo elemento.
2. **Generación de índice aleatorio (`j`)**: - En lugar de seleccionar un índice aleatorio para cualquier posición del array, `j` se selecciona entre `i` (el índice actual) y el final del array. - Esto asegura que cada elemento solo sea intercambiado con los elementos que aún no han sido procesados.
3. **Intercambio de elementos**: - Igual que antes, usamos una variable temporal `temp` para realizar el intercambio entre `array` y `array[j]`.
4. **Impresión con `while`**: - Se utiliza un bucle `while` para imprimir cada elemento del array después de ser mezclado.
### Ejemplo de salida: Dado el array original:
```actionscript PosiblesColores = [0xFFFFFF, 0xFF0000, 0]; ```
Después de ejecutar el código, podrías obtener una permutación como:
```actionscript [0xFF0000, 0, 0xFFFFFF] ```
O cualquier otra ordenación aleatoria.
Este código es completamente funcional y cumple con las especificaciones que pediste. Intenté imitarlo pero como no sé exacto cómo funciona y esos nombres j e i me entreveran, decidí buscar en Wikipedia. https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffleCreo que ahora entiendo, va desde derecha a izquierda y "rolled" significa que eligió intercambiar con ese, el elemento posible de intercambiarse era el 4 y "rolled" un 1, yo interpretaba que había elegido por azar el 1 y no sabía de dónde había sacado el 4. ¿Es así? ¿hay otro mejor?
|
|
|
25
|
Media / Juegos y Consolas / Re: Idear un juego muy simple (es complicado).
|
en: 6 Enero 2025, 15:52 pm
|
Dejé esto, no sé hasta cuando, por ahora empecé a hacer un X en línea. Lo primero, si el personaje solo puede avanzar y no puede hacer nada más Puede detenerse. Luego lo del pergamino mágico que brilla cuando te mueves, pero se apaga si te detienes... No será más fácil poner una linterna que se queda sin pilas? No había leído eso, dejé de leer cuando al principio dió la idea sin justificarla, ya me había dado una respuesta similar y pensé que era la misma, sin justificarla. Ahora se me ocurre que cambie de plano, como eso de fantasmas que pasan del plano terrenal al espiritual o lo que sea, no sé, pero eso de que estando presente los enemigos te ignoren parece un sin sentido, por más que el papel deje de brillar, se acercaron, eso debería ser contacto, deberían estar buscándote. ¿Sin pilas cuando te quedas quieto? No tiene mucho sentido. Además acá convendría sacarle las pilas si fuese eso. ¿Cual es la ventaja de tener una luz si atrae enemigos? Una justificación podría ser que el objeto está maldito o es sagrado y no atrae demonios sino ladrones pero yo que sé, ya me cansé de esto, te muestro lo que había hecho:  Que no está bueno, lo sé, pero cumple más o menos los objetivos que quería, y usa gráficos de uno de los 1eros juegos de NES, cosa que también quería. Manejas al profesor, y cuando un delincuente está cerca tuyo debes parar, dejarlo pasar, sino se enoja y es el fin (porque te dispara, lo cual contradice lo que dije al inicio pero, el juego no lo muestra, no hay disparos en el juego). La cantidad de delincuenes es demasiada, estaba trabajando en una mejor ecuación pero como dije lo dejé. Antes de eso había pensado que el "enemigo" sean las mujeres de ese juego (Hogan Alley's), serían feministas extremas paranoicas que si te ven moverte cerca de ellas creerían que les quieres hacer algo, por eso habría que quedarse quieto, pero al probar el juego noté que eso parece aún más sospechoso xD (peor aún porque el tipo estaba al fondo, porque pensé en lo de las damas 1ero) Era muy creepy así que puse lo de los delincuentes, a mi pesar. Igual era gracioso "Two last man in the feminazi world"; el otro era un policía que habría por ahí (pensé, pero como sólo podía haber un tipo de obstáculo, no).  También dices que hay que reaccionar rápido, pero también ser paciente. Quieres que el jugador sea un ninja o un monje zen? Porque mezclar las dos cosas suena raro. Estás analizando algo que dijo GPT, por eso puse la cita O_O Yo también noté esa contradicción, pero tiene sentido, paciente para poder esperar a que lleguen las oportunidades que duran poco, rápido para que no se pierdan. Bah, no sé, es más bien calcular cuando y cuánto puedes moverte, es más bien de paciencia. Pero hay enemigos que se mueven muy rápido así que si aparecen de esos tienes que saber reaccionar rápido. La idea tiene un toque interesante No mucho. pero si esto va de ser jugable, más te vale replantearte unas cuantas cosas. Era más bien para practicar, quería hacer un juego simple, no me importaba mucho si era aburrido.
|
|
|
26
|
Foros Generales / Sugerencias y dudas sobre el Foro / Re: Physhing en el foro ¡¿?!
|
en: 6 Enero 2025, 14:59 pm
|
Vaya tela, de verdad te asustas por un logo subido a un hosting público? Lo dijo Avast, no yo, se supone que sabe más que yo del tema. Si eso te parece phishing, mejor apaga el ordenador y tírate a la piscina. 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. Cambia de antivirus porque ese parece más un detector de fantasmas que otra cosa Pero supuestamente me ha salvado de varias cosas, en general no he tenido problema. antes de seguir soltando teorías conspiranoicas. 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? PD: Te voy a robar la tarjeta con un logo, prepárate JAJAJA De crédito no tengo xP
|
|
|
29
|
Programación / Python / Re: Buscador de combinaciones inexistentes no funciona.
|
en: 5 Enero 2025, 13:16 pm
|
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.
|
|
|
30
|
Seguridad Informática / Seguridad / Re: Idea para un protocolo antibots en un sistema de registro
|
en: 5 Enero 2025, 13:10 pm
|
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.
|
|
|
|
|
|
|