Con la cantidad de deficientes mentales que hay en EEUU seguro que antes prohiben en uso de Pokemon GO que el de las armas...

La que nunca me ha dado problemas ha sido XUbuntu, ni la 14.04 ni la 16.04. Debian Jessie (actual stable) también funcionaba muy bien, y Debian Stretch (actual testing) me dió algún problema en youtube pero parece que ya se ha arreglado todo, aunque si te digo la verdad la tengo instalada en el portátil y últimamente no lo uso demasiado.

¡Saludos!

Se me olvidaba, mi portátil, salvo por la gráfica, que es una tarjeta integrada que da asco, tiene las mismas características que el ordenador que mencionas, así que con Debian te debería de ir fino, stable o testing ya te toca escogerlo a ti.

Ah, y el escritorio XFCE. El que viene por defecto es tan feo que a uno le dan ganas de arrancarse los ojos, pero instalando xfwm4-themes o instalando algún otro tema que encuentres por ahí mejora bastante, no hace falta perder mucho el tiempo para dejarlo decente.

Y la conexión que tengo son 12 Mb/s, que en ancho de banda real anda entre los 7 y los 9 (en el mejor de los casos un poco más de 1MB/s), ya ves que no es gran cosa. Cuando decía que cargaba a la velocidad del rayo quería decir que la carga es constante y que los vídeos no se quedan atascados cada dos por tres. Me he expresado mal. Lo que ya no se es si es que las webs que visito han mejorado el servicio que dan o si realmente HTML5 supone una ventaja frente a flash en estos temas...

¡Saludos!

Yo hace bastante que abandoné flash y sólo veo vídeos en páginas que tienen reproductores HTML5 y me va a las mil maravillas, los vídeos cargan a la velocidad del rayo, no tengo cortes y la CPU se calienta muchísimo menos.

¡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:

Ejemplo 2:

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.

Hola otra vez. Aquí os dejo el último código que tengo. Esta vez repartido en varios ficheros fuente.

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:



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:


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.

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.

Lo primero, el paquete se llama wine, no Wine, asi que no te toman el pelo cuando te dicen que ejecutes apt-get install wine, y lo segundo, Ubuntu 10.10 es una versión de desarrollo antigua, con paquetes completamente desfasados, que hace ya muchos años que dejó de recibir soporte por parte de Canonical, deberías de utilizar Ubuntu 14.04 o 16.04.

Advertencia - mientras estabas escribiendo, una nueva respuesta fue publicada. Probablemente desees revisar tu mensaje.

¡Buenas!

Si sabes que la lista no está ordenada, lo que yo haría seria introducir los datos en un árbol binario y luego generar una nueva lista haciendo un recorrido inorden. Siempre puedes crear árboles binarios según distintos criterios de comparación. La forma más sencilla sería pasar como argumento la función de comparación a la función que inserte los nuevos nodos en el árbol:

int insertar_nodo_arbol(tuestruct *dato, int (*cmp)(struct1,struct2));
 

De esta manera puedes tener funciones que devuelvan <0, 0, >0 según se comparen los structs siguiendo distintos criterios.

Por ejemplo con un árbol de enteros podrías tener una función

int intcmp(int a, int b)
{
    return a-b;
}
 

para cadenas de caracteres podrías utilizar strcmp, o para un struct con un campo entero y otro una cadena podrías tener dos funciones para ordenarlo con distintos criterios:

struct Cosa
{
    int x;
    char *s;
};
 
int cmp_cosa_int(struct Cosa *a, struct Cosa *b)
{
    return a->x - b->x;
}
 
int cmp_cosa_str(struct Cosa *a, struct Cosa *b)
{
    return strcmp(a->s , b->s);
}
 

Así al pasar los nodos de la lista al arbol solo tendrías que pasar como segundo argumento la función de comparación que quisieses.

int insertar_nodo_arbol(struct Cosa **raiz, struct Cosa *dato, int (*cmp)(struct Cosa *, struct Cosa *))
{
    //...
}
 

¡Saludos!

Pues el siguiente que compre será sin procesador. 

Para mi, unas elecciones en las que un poco más del 30% de la población no ha votado no tienen ninguna legitimidad. Somos muchos los que no votamos porque estamos hartos de la fauna política española.

Lo que el PP ahorra favoreciendo el sector privado en la educación y la sanidad, lo derrocha el PSOE subvencionando operaciones de cambio de sexo y equipos de futbol en países extranjeros, y lo que el PSOE avanza en materia de política social lo deshace el PP en cuanto puede. Luego están los carroñeros como Podemos y Ciudadanos pululando no se sabe por donde para ver que pescan y a costa de quien, y los nacionalistas barriendo para sus propias casas sin que les importe un pimiento las consecuencias que implican sus intenciones para los que no viven en sus propias comunidades autónomas. "¡Oh! Ha descarrilado un tren y han muerto no se cuantas personas. Vamos a darnos prisa en salir por la televisión con cara de pena y vamos a ir a hacernos unas fotos, que siempre queda bien de cara a futuras campañas electorales...", sin contar con que en cualquiera de los dos o tres partidos que históricamente han sido más importantes hay grupos de ladrones que dejan a los cuarenta del cuento de Alí Babá como auténticos aficionados. Partidos políticos haciendo leyes a su medida y utilizando a las fuerzas del estado para proteger el culo de sus militantes del descontento general que provocan sus propias acciones... Todo esto entre otras preciosas perlas... Vergüenza, eso es lo que da la clase política española.

Ningún político español merece ni mi respeto ni mi voto.

Si utilizase Debian, nada más instalarlo tendría que editar su sources.list para añadir los repositorios contrib y non-free y después añadir la arquitectura de 32 bits para poder usar todos los programas disponibles (por ejemplo steam), además de tener que estar actualizando por terminal sin saber exactamente lo que estaría ejecutando, posiblemente sin hacer autoclean o clean de vez en cuando para limpiar el sistema de paquetes desfasados ni purgar los paquetes que quedasen huerfanos después de eliminar los que los tuviesen como dependencias. Además para buscar paquetes y filtrarlos tendría que recurrir a apt-cache -search algo | grep loquesea, y para instalar paquetes ajenos a la distro a un dpkg -i a pelo o a gdebi que no está instalado por defecto (si mal no recuerdo). En *Ubuntu de todo eso se encargaba el centro de software y ahora el gestor de software de GNOME. Aunque también podría utilizar aptitude o synaptic...

Viendo la elección que hizo de su sistema operativo mejor que se olvide de momento de todo eso y que recurra a un sistema operativo que va a hacer todo eso por él.

Primero infórmate de lo que le estás metiendo a tu ordenador. 15.10 no es una versión para utilizar en el día a día, es una versión de desarrollo, con todos lo posibles errores que ésto puede conllevar, y 12.04 es una versión de ubuntu con la que posiblemente tengas más problemas de drivers que con una más actual como la 14.04 o la reciente 16.04.

Si te hubieses molestado en saber que es lo que estabas utilizando habrías descubierto (en los primeros 10 minutos de lectura) que las versiones de Ubuntu son de la forma año.mes, y que en abril de los años pares suelen sacar las versiones LTS, por lo que habrías escogido cualquiera de las dos últimas que he mencionado en el párrafo anterior. Si vas a utilizar Ubuntu tienes que utilizar, en principio, la 16.04, porque de las versiones LTS que existen en este momento es la que trae un núcleo más moderno y con mejor soporte de hardware.

Segundo, antes de instalar nada prueba la distro en forma LiveCD/LiveUSB. Comprueba si las cosas funcionan y si no lo hiciesen busca información sobre porqué no lo hacen. Lo más probable es que no seas el primero en tener problemas y que la solución a éstos ya exista en cualquier página web. Y antes de instalar cualquier porquería que vaya a romper tu distro que recomienden en cualquier página web, comprueba si los drivers que te hacen falta están el los repositorios (nvidia, broadcom, realtek...)

Tercero, no se que hardware tiene el portátil que mencionas, tampoco me importa. Lo que tienes que hacer es escoger un entorno de escritorio que se ajuste a las características del hardware que usas. Aun así, yo soy partidario de utilizar un entorno de escritorio ligero y completo, como XFCE, y dejar el resto de los recursos para los programas, que son a los que realmente les hacen falta. De poco te va a servir tener un escritorio como GNOME, KDE o Unity si luego no te queda RAM para ejecutar ningún programa. Y si las características de tu portátil son similares a éstas, deberías de olvidarte de esos tres entornos de escritorio. Incluso pensar en usar LXDE en lugar de XFCE.

Sumando todo lo anterior, deberías de probar XUbuntu 16.04 con un LiveUSB, buscar la solución a los problemas que te pudieran surgir y una vez que lo tienes todo controlado instalar el sistema. Incluso si con XUbuntu fueses justo de RAM (unos 270 MB recién arrancado, raro sería) deberías de pensar en utilizar LUbuntu.