| |
 Mostrar Temas
|
|
Páginas: [1] 2 3 4 5 6
|
|
1
|
Sistemas Operativos / GNU/Linux / Encuesta/experimento para cuando estéis aburridos.
|
en: 17 Abril 2017, 16:49 pm
|
|
¡Buenas!
Me he venido a casa de mis padres a pasar las vacaciones, y como no tenemos internet utilizo la tarifa de datos que tengo contratada para conectarme a internet. Esta mañana me he llevado una sorpresa. Teniendo el móvil conectado al ordenador por medio del cable USB, si al entrar en el GRUB activo el modo "módem USB" desde Android antes de que se seleccione el sistema operativo, GRUB se queda completamente colgado.
Os dejo la versión de Android y la del GRUB:
- Android 2.3.6
- grub-pc 2.02~beta3-5 (Debian 9 stretch)
El único sistema operativo que tengo instalado es Debian.
Siento curiosidad por saber si pasa lo mismo en vuestros equipos al activar el modo módem USB cuando salta GRUB.
¡Saludos!
|
|
|
|
|
2
|
Programación / Programación C/C++ / Listas - ¿Cómo enfocaríais el valor de retorno de las búsquedas?
|
en: 4 Enero 2017, 00:26 am
|
|
¡Buenas!
He retomado un proyecto que empecé hace un tiempo sobre crear esctructuras de datos genéricas en C, y tengo alguna duda sobre qué tipo de dato debería devolver una búsqueda sobre una lista. La estructura contiene un puntero void* en el que se almacena el dato, y en un principio lo que estoy devolviendo en NULL si no encuentro el dato y void const* si lo encuentro para evitar modificar el dato (de momento estoy trabajando con listas ordenadas).
La cuestión es que este valor de retorno no da ningún tipo de información sobre la posicion que el elemento ocupa dentro de la lista, por lo que, por ejemplo, no se podría combinar una busqueda con la extracción de una sublista en caso de que haga falta seleccionar elementos dentro de un rango determinado. Si por el contrario utilizo un entero (lo más lógico sería un unsigned long) como valor de retorno, estaría limitando la cantidad de datos que se podrían almacenar al rango de valores de ese tipo de entero (un valor menos, teniendo en cuenta que tendría que escoger un valor de retorno, por ejemplo (unsigned long)(-1) para informar de que no ha habido ninguna coincidencia).
Otra alternativa sería buscar un elemento y devolver un puntero como comentaba antes, y en caso de que la búsqueda tuviese éxito utilizar una función que me devuelva la posición, pero seguiría existiendo la limitación sobre la cantidad máxima de datos que la lista podría contener.
Si alguna vez habéis trabajado con listas, ¿Cómo habéis enfocado el problema de la busqueda/posición de un elemento dentro de ésta?
|
|
|
|
|
3
|
Foros Generales / Sugerencias y dudas sobre el Foro / Obligación de iniciar sesión para consultar el foro
|
en: 31 Diciembre 2016, 09:28 am
|
|
¡Buenas!
Desde hace unos meses (no recuerdo exactamente desde cuándo) y de forma que al menos a mi me parece completamente aleatoria no siempre es posible consultar el foro como visitante. En cuanto se accede al foro se redirige directamente a la página de inicio de sesión. Resulta molesto si solo se quiere entrar para ver por encima que novedades hay. No se si es un error o alguna medida de seguridad. Si es lo primero aquí queda el aviso, si es lo segundo, pues tocará pasar por el aro. XD
¡Saludos!
|
|
|
|
|
5
|
Programación / Ingeniería Inversa / ¿Hay algún manual/curso completo sobre cracking para GNU/Linux?
|
en: 7 Diciembre 2016, 21:55 pm
|
|
¡Buenas!
Hace tiempo empecé el curso de cracking de Ricardo Narvaja y recuerdo que el tema era la mar de entretenido, no avancé demasiado porque tuve que centrarme en los estudios, pero el tema de los crackme y programar keygens estaba chulo.
Hace un par de años me pasé a GNU/Linux y me estaba preguntando si para los pingüineros hay algún curso equivalente al del señor Ricardo o si me va a tocar recopilar documentación por mi cuenta.
El tema de las herramientas no me molesta demasiado, simplemente se trata de buscar las que más me gusten (no se si me tocará adaptarme a la notacion ATT&T o si se podría seguir en Intel, supongo que dependerá del debugger y tampoco es algo que me moleste), el problema sería encontrar documentación sobre la estructura de los ejecutables explicada paso a paso, los distintos segmentos, secciones en los que se especifican los permisos de acceso al código binario... refrescar la memoria y adaptarme al nuevo formato.
¿Hay algo parecido al curso de introducción al cracking con OllyDbg, yendo paso a paso, para GNU/Linux?
|
|
|
|
|
6
|
Foros Generales / Sugerencias y dudas sobre el Foro / Hay algún problema con la publicidad.
|
en: 23 Septiembre 2016, 02:03 am
|
|
¡Buenas!
Os aviso de que en XUbuntu 16.04 + Firefox 48 no se ve la publicidad, no se si hay algún error, si os he pillado cambiándola o si la habéis quitado de forma voluntaria. Por si a caso os dejo el aviso. Yo no soy partidario de ella, pero el foro es uno de los pocos sitios en los que tengo desactivado uBlock.
¡Saludos!
|
|
|
|
|
7
|
Programación / Programación C/C++ / Resolucion minijuego Tetris en The Talos Principle
|
en: 15 Julio 2016, 04:47 am
|
¡Buenas! Para el que no sepa de que va la cosa, se trata de un tablero rectangular (o cuadrado) vacío y se dispone de varias piezas de tetris que colocadas de una forma determinada llenan todo el tablero. Ayer me aburrí de probar distintas disposiciones de piezas en el minijuego de tetris de The Talos principle y hoy he creado un programa que resuelve el juego. La solución está basa en backtracking: - unas cuantas funciones para manipular las piezas y cargar las condiciones del juego... - una funcion que decide si es correcto o no poner una pieza en una posicion dada - una funcion recursiva que soluciona probando para cada uno de los giros posibles de las piezas todas las posiciones del tablero en las que cabe. Para tableros no muy grandes, entre unas 20-36 casillas y no más de 10 piezas, la solución normalmente no tarda nada, o en algún caso raro tarda algunos segundos, pero si pasamos a tableros con más datos, en algún caso después de media hora de ejecución todavía no ha encontrado la solución. La verdad es que ya estoy cansado de código por hoy. Quería pediros que si se os ocurren condiciones nuevas, por ejemplo que descarten callejones sin salida, para añadir a la función que detecta la corrección, o si conocéis o se os ocurre algún método eurístico para buscar posiciones iniciales más óptimas de las piezas que me lo digáis, o si queréis modificad el código que os dejo en el enlace y compartidlo por aquí. Podéis descargar el código desde aquí. Creo que se entiende bien, pero si no lo entiendo yo que soy el que lo ha escrito mal vamos, si no entendéis algo o hace falta introducir más comentarios avisad y actualizo el enlace. ¡Saludos! Enlace actualizado: Alguna pincelada en main y ahora las piezas guardan la posición fila-columna en la que se han colocado por si una vez resuelto se quiere representar de alguna forma menos cutre que la actual (mensaje para los que manejan SDL, Allego u otra librería gráfica  ) y se ha añadido una función para comprobar si un hueco en el tablero está formado por menos de cuatro casillas vacías, en cuyo caso, al no caber ninguna pieza en ese hueco, se vuelve atrás en la función recursiva que busca la solución. El algoritmo ha mejorado, con el juego del ejemplo 2 la solución es instantánea. Podéis comprobar la diferencia comentando y descomentando la parte:if(huecos_inutiles(juego)) return 0;
en la función resolver.Se me olvidaba. El programa funciona por línea de comandos. La sintaxis es nombre_programa fichero1 [fichero2 ... ficheroN]Cada uno de los ficheros tiene que contener un juego con la siguiente información: 1ª línea: Numero de filas del tablero. 2ª línea: Numero de columnas del tablero 3ª línea: Numero de piezas. - Tantas líneas como numero de piezas y en cada una de ellas el nombre de una de las piezas del juego (CUADRADO, L_NORMAL, L_SIMETRICA, T, Z_NORMAL, Z_SIMETRICA o BARRA) Por ejemplo: 8
5
10
2 Z_NORMAL
1 Z_SIMETRICA
2 T
2 BARRA
2 L_NORMAL
1 CUADRADO
Ejemplo 2: 8
7
14
2 T
4 Z_NORMAL
2 Z_SIMETRICA
3 L_NORMAL
3 L_SIMETRICA
La leyenda de la solución es: C-Cuadrado: L-L normal en alguno de sus giros: l-L simétrica en alguno de sus giros: T: Z: z: -, barra: Sigo con el culebrón. Al final la versión en la que utilizaba un árbol para almacenar las situaciones que no llevaban a ninguna solución ha resultado ser mucho mas lenta, así que en el enlace inicial dejo la última solución que tengo.
De todas formas, tengo pendiente un algoritmo en el que para tablas grandes, de más de 60 casillas (15 piezas), trocee la tabla en fragmentos más pequeños para intentar solucionarlos y luego solapar las distintas soluciones. Si me da por hacerlo y consigo algo mejor que lo actual colgaré el código por aquí.
Por cierto, he modificado el formato de los archivos para que queden más compactos. Ahora las filas con las piezas contienen pares Repeticiones-Nombre de la pieza, que indican, como bien habréis deducido, el número de veces que se repite cada pieza.
El primero de los siguientes ejemplos, 15 piezas (60 casillas) se resuelve, en un Intel Core 2 Duo viejete, en un poco más de 9 segundos, el segundo, 64 casillas y 16 piezas, en 11 minutos y 3 segundos y el tercero, con 33 piezas, ni idea, pero mejor ni lo intento.6
10
15
2 Z_NORMAL
3 L_NORMAL
4 T
3 Z_SIMETRICA
3 L_SIMETRICA
8
8
16
5 Z_SIMETRICA
1 Z_NORMAL
1 L_NORMAL
3 L_SIMETRICA
6 T
11
12
33
4 Z_SIMETRICA
11 L_SIMETRICA
4 T
2 Z_NORMAL
12 L_NORMAL
La idea esta vez es, en lugar de resolver el puzzle completo con todas las piezas, delimitar sectores con una cantidad determinada de filas y columnas, como si fuesen baldosas que cubren el tablero de juego, e intentar resolver cada uno de ellos por completo, sin tener en cuenta que por los bordes sobresalgan las piezas, pues el propio algoritmo se encargara de rellenas los huecos que queden al llegar al sector hacia el que sobresalgan.
La línea de comandos queda:
nombre_programa filasxsector columnasxsector fichero1 [fichero2 ... ficheroN]
En cuanto a tiempos de ejecución el resultado ha sido muy irregular.
Los mejores resultados los he obtenido con sectores 2x2 y aumentar el numero de filas o columnas por sector hace que los tiempos de ejecución se disparen. Por ejemplo, con sectores 2x2, de los tres juegos anteriores el primero ha pasado a resolverse en 0'0037 segundos, el segundo en 3'731 segundos y el tercero sigo sin saber cuanto tiempo le cuesta, porque me aburro de esperar y lo corto.
Pero por ejemplo, el juego que muestro a continuación, con el algoritmo del primer enlace se resuelve en 0'026 segundos, pero con el nuevo algoritmo y siendo que el tablero es de menor tamaño que cualquiera de los tres anteriores (y por lo tanto con menos piezas) tarda 4 minutos y 21 segundos en resolverlo:
8
7
14
2 T
4 Z_NORMAL
2 Z_SIMETRICA
3 L_NORMAL
3 L_SIMETRICA
Yo solo usaría este nuevo código para puzzles de más de 14-15 piezas y solo por si hay suerte y lo resuelve en un tiempo relativamente razonable.
Hasta aquí ha llegado mi aventura con este problema. Si alguien puede mejorar alguno de los dos algoritmos que lo haga y nos deje las mejoras por aquí, o si encuentra uno mejor y puede hacérmelo llegar se lo agradecería, pero lo que es por mi parte, abandono, tengo mejores cosas que hacer que estar perdiendo el tiempo con esto. 
¡Buenas!
Hay veces que parezco tonto. Me acabo de dar cuenta de que los huecos inútiles no son aquellos con una cantidad de espacios menor que tres, sino los que no tienen una cantidad de espacios que sea múltiplo de cuatro.
He corregido el código y he actualizado los enlaces. No esperéis que los puzzles que antes no resolvían en un tiempo razonable ahora si lo hagan, simplemente han mejorado algo los tiempos de los puzzles que ya se podían resolver.
Por cierto, jugando un poco con las dimensiones de las celdas os podéis llevar alguna sorpresa. Por ejemplo, en el último ejemplo que he colgado con sectores 3x5 la solución es casi inmediata (0'225 segundos en mi caso)
¡Saludos!
Ya se que dije que iba a dejar el tema, pero no he podido hacerlo, y por fin tengo una solución que mejora, y mucho, las anteriores.
La idea esta vez ha sido ir llenando primero los huecos más pequeños, valorando cada una de las casillas vacías de forma que guarden el numero de casillas vacías que haya en el hueco en el que se encuentra... lío. Mejor lo pongo con un ejemplo:
123456
------
1|
2| **
3| **
4|
5|
En la segunda fila vemos que hay dos espacios, una pieza y después otros dos espacios libres, así que las dos primeras casillas indican que están en una fila de un hueco, y que el hueco en esa fila tiene dos espacios horizontales libre. Lo mismo con las dos últimas casillas.
En la tercera columna hay un espacio vacío, una pieza y tres espacios vacíos más, así que la primera casilla tendrá un uno como espacio vertical y las casillas 3, 4 y 5 un tres como valor de espacio vertical, ya que la columna en la que se encuentran está en un hueco de 3 espacios.
Una vez que se ha asignado a cada casilla vacía el espacio vertical y horizontal, buscamos la que tenga el valor más pequeño (da lo mismo que sea vertical u horizontal, ya que buscamos el hueco más pequeño), e intentamos rellenarlo con los distintos tipos de pieza que queden por usar (fuerza bruta para rellenar el hueco, vamos).
Aquí os dejo el último código. Como ejemplo, el siguiente puzzle lo resuelve, en mi ordenador, en unos dos minutos y medio. La mejora con respecto a los algoritmos anteriores es muy grande. 11
12
33
4 Z_SIMETRICA
11 L_SIMETRICA
4 T
2 Z_NORMAL
12 L_NORMAL
Ahora que he llegado a este resultado si que doy el tema por zanjado.
¡Saludos!
Hala, ahora si que paro con el tema. XD
El enlace al código definitivo.
Acabo de añadir una función que da "color" a la solución. Realmente lo que se hace es asignar al campo color del struct Pieza el índice de un color dentro de una paleta de colores. He decidido no incluir el código que da "color" directamente a la solución dentro de la funcion colorear_solucion para que el código sea independiente de cualquier sistema de representación de los datos. La contrapartida de esta independencia es que la persona que vaya a usar el código tiene que crear la paleta de colores (en este caso un conjunto de cuatro caracteres) y luego tiene que acceder a los campos que correspondan en las estructuras de datos para poder crear su propia representación de la solución. En main hay un ejemplo sobre como hacerlo.
Como en linux los caracteres bonitos para dibujar las piezas salen como interrogantes he tenido que recurrir a x, o, + y *. Los que uséis Windows podéis imprimir los caracteres de la tabla ASCII en la forma valor-caracter y veréis que hay caracteres cuadrados con distintos dibujos que podéis usar para hacer que la representación quede más bonita.
Enlace actualizado: he econtrado algún error en el código que podía hacer que el programa cascase.
|
|
|
|
|
8
|
Comunicaciones / Redes / ¿Los navegadores para terminal ahorran ancho de banda?
|
en: 31 Mayo 2016, 13:34 pm
|
|
¡Buenas!
Durante unos días tengo que depender de la conexión móvil, y ya ya llevo un par tirando de elinks. Quería saber si estoy ahorrando datos o si por el contrario, aunque no muestre ni imágenes ni publicidad ni nada que no sea texto recibe la información completa y luego solo descarta la que no va a mostrar, vamos, si estoy haciendo el tonto.
¡Saludos!
|
|
|
|
|
10
|
Sistemas Operativos / GNU/Linux / [¿lightdm? ¿Xfce?] ¿Cómo cambio la imagen mostrada en la carga del escritorio?
|
en: 6 Abril 2016, 14:06 pm
|
|
¡Buenas!
La cosa no tiene ninguna gravedad, simplemente es una cuestión estética.
Después de loguearme y mientras se carga el escritorio aparece una ventana en la que se muestra el avance en la carga del escritorio. Por mucho que busco en Google, si introduzco los términos de búsqueda imagen, image o picture me salen un montón de enlaces que no tienen ninguna relación con lo que me interesa.
¿No sabréis por alguna casualidad cual es el archivo de configuración en el que se guarda la información de ésta ventana de carga?
Por cierto, el display manager que utilizo es lightdm y el entorno de escritorio Xfce. No se con cual de los dos puede estar relacionado el dichoso archivo...
¡Saludos y gracias por vuestro tiempo!
Se me olvidaba, utilizo Debian. Aviso por si cambia la localización y nombre del archivo entre las distintas distros.
¡Saludos!
|
|
|
|
|
|
| |
|
