:::: MENU ::::

Snowflake – Un nuevo juego en el blog

Hola a todos,
Debido a un alto aburrimiento, así como a las ganas de poseer un cubo de VeryPuzzle llamado Snow Mystery (sí, con dos ‘y’es, no lo he escrito mal), decidí ponerme a programar en un ratillo libre que tenía, y acabé por hacer el cubo de forma un tanto peculiar.

Para todos los que no lo sepáis, tengo una gran afición por los cubos de Rubik, y de hecho estoy pensando en abrir otro canal de YouTube (otro más para la colección) de cubos, puesto que es algo de lo que me gusta hablar, y creo que tengo una colección suficiente para ello.

El juego no usa la tecnología de canvas de HTML5, pues simplemente me aburría y quería hacerlo a lo rápido, no a lo “pro”. Por ende, son simples divs a las cuales les cambio el color de fondo cambiándoles la clase en un simple script que intercambia colores y posiciones tanto al pulsar las flechitas, al pulsar los propios copos o al pulsar el botón de Shuffle, o mezcla, en sí.

Así que bueno, ya que jugar es gratis, aquí tenéis el link:

¡Entra al juego!


Ensaïmada numérica, el bot que las resuelve

Pues sí queridos amigos,
Un año y medio después he vuelto y os traigo el post que tanto prometí.
En este caso se trata de un pequeño proyecto de PHP que resuelve las ensaïmadas numéricas (sí, con diéresis, que por algo estamos en Mallorca).
Una ensaïmada numérica es un circuito Hamiltoniano, matemáticamente hablando. En este caso es una tabla de 10×10 en cuyas celdas encontramos todos los valores del 1 al 100 ordenados de una forma específica.
Para empezar, colocamos el valor ‘1’ en cualquiera de las celdas que tiene la tabla, sin importar ningún factor, puro azar. A posteriori, tenemos que proseguir rellenando la tabla incrementando de uno en uno el valor que tenemos, y podemos ir distribuyéndolo de forma diagonal, horizontal y vertical, es decir, podemos ir rellenando hacia arriba, abajo, los lados y diagonal, pero siempre dejando un espacio en diagonal y dos en horizontal o vertical, de forma que sería: 1xx2 (siendo x espacios libres), o en diagonal solo uno. No vale “rebotar” o “atravesar” las paredes, y si deja de haber posiciones libres, no se puede continuar, simplemente hay que empzar con una tabla nueva (o volver atrás en la actual).

Para resolver este problema he optado por fuerza bruta y puro azar en vez de recursividad por pura pereza, pero es posible hacerlo con recursividad, y de hecho no sería demasiado difícil (así que… probablemente tendréis el proyecto modificado en un futuro).

Este programa ha sido realizado en PHP, y se recomienda abrir tantas instancias de este como núcleos/hilos tenga el procesador, para acelerar el proceso. En un futuro os lo traeré en C# y/o Java y con multithreading, de forma que podréis ahorraros el trabajo de abrir múltiples instancias.

Para que funcione, debéis crear una carpeta llamada ‘soluciones’ en la raíz del programa y dentro crear un archivo llamado ‘ultima.txt’. En dicha carpeta se guardarán las soluciones en formato HTML con tablas.

Aquí tenéis un ejemplo de ensaïmada numérica generada por el programa:

Resultado al azar del programa

Resultado al azar del programa

He aquí el código: (pastebin también disponible)

<?php
/* Hecho por Martín Durán – www.maduranma.com */

echo “Buscando soluciones…\n”;
$intentos = 0;
while(true)
{
// Todos los números a 0 (para tener algo, si no ya se borrará)
for($d = 1; $d <= 100; $d++)
$r[$d] = 0;

// ¿Dónde ponemos el 1?
$intentos++;
$rs = rand(1,100);
$r[$rs] = 1;
$l = $rs; // Definimos que la última posición es dónde está el uno, hasta un futuro muy cercano

$can = true; // Para que el while continue

while($can)
{
// Obtenemos el número de posición horizontal
if(strlen($l) > 1)
$h = (substr($l, -1) == 0) ? 10 : substr($l, -1);
else
$h = $l;

// Obtenemos el número según el vertical
if(strlen($l) > 1)
if($l == 100)
$v = 10;
else
$v = ($h == 10) ? substr($l, 0, 1) : substr($l, 0, 1) + 1;
else
$v = 1;

// Ponemos que todos los valores del array $m sean true, para comprobarlos luego
for($c = 1; $c <= 8; $c++)
$m[$c] = 1;

// — Movimientos horizontales —
if($h == 8 || $h == 9 || $h == 10 || (($l + 3 > 100) ? true : (($r[$l + 3] != 0) ? true : false)))
$m[1] = 0;

if($h == 1 || $h == 2 || $h == 3 || (($l – 3 < 1) ? true : (($r[$l – 3] != 0) ? true : false)))
$m[5] = 0;

// — Movimientos verticales —
if($v == 8 || $v == 9 || $v == 10 || (($l + 30 > 100) ? true : (($r[$l + 30] != 0) ? true : false)))
$m[3] = 0;

if($v == 1 || $v == 2 || $v == 3 || (($l – 30 < 1) ? true : (($r[$l – 30] != 0) ? true : false)))
$m[7] = 0;

// — Movimiento arriba derecha —
if($h == 9 || $h == 10 || $v == 1 || $v == 2 || (($l – 18 < 1) ? true : (($r[$l – 18] != 0) ? true : false)))
$m[8] = 0;

// — Movimiento arriba izquierda —
if($h == 1 || $h == 2 || $v == 1 || $v == 2 || (($l – 22 < 1) ? true : (($r[$l – 22] != 0) ? true : false)))
$m[6] = 0;

// — Movimiento abajo derecha —
if($h == 9 || $h == 10 || $v == 9 || $v == 10 || (($l + 22 > 100) ? true : (($r[$l + 22] != 0) ? true : false)))
$m[2] = 0;

// — Movimiento abajo izquierda —
if($h == 1 || $h == 2 || $v == 9 || $v == 10 || (($l + 18 > 100) ? true : (($r[$l + 18] != 0) ? true : false)))
$m[4] = 0;

$cm = null;
$cm = array();
foreach($m as $ia => $ib)
if($ib == 1)
$cm = array_merge($cm, array($ia));

// Comprobamos que han salido movimientos
if(($cm != null) ? count($cm) >= 1 : false)
$fm = array_rand($cm); // Movimiento elegido
else
$can = false; // Aquí paramos

if($can)
foreach($cm as $ba => $bb)
if($ba == $fm)
$fm = $bb;

// Nos movemos (si podemos)
if($can)
switch($fm)
{
case 1:
$nl = ($l) + 3;
$r[$nl] = $r[$l] + 1;
$l = $nl;
break;

case 2:
$nl = ($l) + 22;
$r[$nl] = $r[$l] + 1;
$l = $nl;
break;

case 3:
$nl = ($l) + 30;
$r[$nl] = $r[$l] + 1;
$l = $nl;
break;

case 4:
$nl = ($l) + 18;
$r[$nl] = $r[$l] + 1;
$l = $nl;
break;

case 5:
$nl = ($l) – 3;
$r[$nl] = $r[$l] + 1;
$l = $nl;
break;

case 6:
$nl = ($l) – 22;
$r[$nl] = $r[$l] + 1;
$l = $nl;
break;

case 7:
$nl = ($l) – 30;
$r[$nl] = $r[$l] + 1;
$l = $nl;
break;

case 8:
$nl = ($l) – 18;
$r[$nl] = $r[$l] + 1;
$l = $nl;
break;

default:
echo ‘<script>alert(\’error\’);</script>’;
$can = false;
break;
}
}

if($r[$l]  == 100)
{
$nombre_fichero = ‘soluciones/ultima.txt’;
$gestor = fopen($nombre_fichero, ‘r’);
$contenido = fread($gestor, 11);
fclose($gestor);
$contenido = $contenido + 1;
$fp = fopen(‘soluciones/ultima.txt’, ‘w’);
fwrite($fp, $contenido);
fclose($fp);

$d = ”;
$d .= ‘<!DOCTYPE html>
<head>
<title>Soluci&oacute;n ‘ . $contenido . ‘ del circuito Hamiltoniano – Ensaimada num&eacute;rica</title>
</head>
<body style=”margin:3 0;”>
<center>
<table border=”1″ style=”font-size: 57pt;text-align: center; border: 2px solid black;” cellpadding=”2″ cellspacing=”0″>’;
for($a = 1; $a <= 10; $a++)
{
$d .= “\n\t\t\t\t<tr>”;
for($b = 1; $b <= 10; $b++)
{
$d .= “\n\t\t\t\t\t<td width=\”90\” height=\”75\” style=\”height: 89px; text-align: center; border: 2px solid black;\” >”;
$d .= ($r[(($a-1)*10)+$b] == 0) ? “\n\t\t\t\t\t\t&nbsp;” : (“\n\t\t\t\t\t\t” . $r[(($a-1)*10)+$b]);
$d .= “\n\t\t\t\t\t</td>”;
}
$d .= “\n\t\t\t\t</tr>”;
}
$d .= “\n\t\t\t</table>”;
echo “Sol. $contenido encontrada y guardada. Intentos: $intentos”;
$intentos = 0;
echo “\nBuscando soluciones…\n”;
$fp = fopen(‘soluciones/’ . $contenido . ‘.html’, ‘w’);
fwrite($fp, $d);
fclose($fp);
}
}
?>

P.D: He dejado un problema de optimización en los IFs para ver si alguien es capaz de encontrarlo, es simplemente que hay algo que no hace falta que esté. Quien lo encuentre se lleva una camiseta gratis :P


Cómo crear una Base de Datos de Hashes

¡Muy buenas amantes de la informática!
Bueno, la verdad es que ya hace siglos hice un generador de Hashes que generaba hashes en MD5 siguiendo un orden específico, el orden en cuestión era como el Excel (A, B… AZ, BA… ZZ, AAA..) pero incluyendo números y caracteres que se ponen comunmente en las contraseñas: ªº\|[email protected]”#~$%&/()=’?

Ese generador iba metiendo todas las contraseñas en una base de datos con su respectivo hash MD5, de forma que si buscaba el hash en cuestión en la base de datos me lo devolvía desencriptado (por decirlo de alguna forma, puesto que realmente no se puede hacer eso, pero si conseguir una coincidencia a fuerza bruta, que además son infinitamente múltiples en todos los casos posibles).

El código es sencillo y os lo dejo a todos para que lo aprovechéis. En un principio hice una versión para MySQL y luego una versión Flat File. Ambos son de uso recomendado en SSDs o dispositivos de almacenamiento flash por que en discos duros es muuuuy lento y tedioso.

Código Flat File (Pastebin para mejor formato)

$c = ‘ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789ªº\\|[email protected]”#~$%&/()=\’?’;
$k = strlen($c);
function c($n)
{
global $k, $c;
$s = ”;
$r = 1;
$b = $n;
while($b > pow($k, $r))
$b -= pow($k, $r++);
for($i = 0; $r > $i; $i++)
$s = substr($c, ($n/pow($k,$i)-1)%$k, 1) . $s;
return $s;
}

$x = scandir(‘C:\\txt’);
if($x[count($x)-1] == ‘..’)
$i = 0;
else
$i = count($x)-2;
echo number_format($i, 0, ‘.’, ‘.’);
while(true)
{
$i++;
$m = c($i);
$alg = hash_algos();
$sb = ”;
$sa = ”;
foreach(hash_algos() as $b => $al)
$sa .= hash($al, $m) . ((count(hash_algos()) > ($b + 1)) ? ‘ ‘ : ”);
file_put_contents(‘C:\\txt\\’ . $i, $m . ‘ ‘ . $sa);
if($i%1000 == 0)
echo “\n” . number_format($i, 0, ‘.’, ‘.’);
}

Código para MySQL (Pastebin para mejor formato)

$x = mysqli_connect(‘127.0.0.1’, ‘root’, ‘contraseña’, ‘db’);
$c = ‘ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789ªº\\|[email protected]”#~$%&/()=\’?’;
$k = strlen($c);
function c($n)
{
global $k, $c;
$s = ”;
$r = 1;
$b = $n;
while($b > pow($k, $r))
$b -= pow($k, $r++);
for($i = 0; $r > $i; $i++)
$s = substr($c, ($n/pow($k,$i)-1)%$k, 1) . $s;
return $s;
}
$q = mysqli_query($x, ‘SELECT id FROM hashes ORDER BY id DESC LIMIT 1’);
if(mysqli_num_rows($q) == 0)
$i = 0;
else
{
$p = mysqli_fetch_assoc($q);
$i = $p[‘id’];
}
echo number_format($i, 0, ‘.’, ‘.’);
while(true)
{
$i++;
$m = c($i);
$alg = hash_algos();
$sb = ”;
$sa = ”;
foreach(hash_algos() as $b => $al)
{
$sb .= ‘, `’ . $al . ‘`’;
$sa .= ‘\” . hash($al, $m) . ((count(hash_algos()) > ($b + 1)) ? ‘\’,’ : ‘\”);
}
mysqli_query($x, ‘INSERT INTO hashes (`value`’ . $sb . ‘) VALUES (\” . mysqli_real_escape_string($x, $m) . ‘\’, ‘ . $sa . ‘)’);
if($i%100 == 0)
echo “\n” . number_format($i, 0, ‘.’, ‘.’);
}

El SQL que debéis hacer para crear la tabla es tan fácil como ejecutar un script con un foreach en el cual por cada valor de hash_algos() (función que viene en PHP para obtener un array que nos indica todos los tipos de hashes disponibles) cree una fila varchar 255 y listo. En cualquier caso, aquí lo tenéis:

CREATE TABLE IF NOT EXISTS `hashes` (
`id` int(11) NOT NULL,
`value` varchar(255) NOT NULL,
`md2` varchar(255) NOT NULL,
`md4` varchar(255) NOT NULL,
`md5` varchar(255) NOT NULL,
`sha1` varchar(255) NOT NULL,
`sha224` varchar(255) NOT NULL,
`sha256` varchar(255) NOT NULL,
`sha384` varchar(255) NOT NULL,
`sha512` varchar(255) NOT NULL,
`ripemd128` varchar(255) NOT NULL,
`ripemd160` varchar(255) NOT NULL,
`ripemd256` varchar(255) NOT NULL,
`ripemd320` varchar(255) NOT NULL,
`whirlpool` varchar(255) NOT NULL,
`tiger128,3` varchar(255) NOT NULL,
`tiger160,3` varchar(255) NOT NULL,
`tiger192,3` varchar(255) NOT NULL,
`tiger128,4` varchar(255) NOT NULL,
`tiger160,4` varchar(255) NOT NULL,
`tiger192,4` varchar(255) NOT NULL,
`snefru` varchar(255) NOT NULL,
`snefru256` varchar(255) NOT NULL,
`gost` varchar(255) NOT NULL,
`gost-crypto` varchar(255) NOT NULL,
`adler32` varchar(255) NOT NULL,
`crc32` varchar(255) NOT NULL,
`crc32b` varchar(255) NOT NULL,
`fnv132` varchar(255) NOT NULL,
`fnv1a32` varchar(255) NOT NULL,
`fnv164` varchar(255) NOT NULL,
`fnv1a64` varchar(255) NOT NULL,
`joaat` varchar(255) NOT NULL,
`haval128,3` varchar(255) NOT NULL,
`haval160,3` varchar(255) NOT NULL,
`haval192,3` varchar(255) NOT NULL,
`haval224,3` varchar(255) NOT NULL,
`haval256,3` varchar(255) NOT NULL,
`haval128,4` varchar(255) NOT NULL,
`haval160,4` varchar(255) NOT NULL,
`haval192,4` varchar(255) NOT NULL,
`haval224,4` varchar(255) NOT NULL,
`haval256,4` varchar(255) NOT NULL,
`haval128,5` varchar(255) NOT NULL,
`haval160,5` varchar(255) NOT NULL,
`haval192,5` varchar(255) NOT NULL,
`haval224,5` varchar(255) NOT NULL,
`haval256,5` varchar(255) NOT NULL
) ENGINE=InnoDB AUTO_INCREMENT=486089 DEFAULT CHARSET=utf8;

ALTER TABLE `hashes`
ADD PRIMARY KEY (`id`), ADD UNIQUE KEY `value` (`value`), ADD KEY `md2` (`md2`), ADD KEY `md4` (`md4`), ADD KEY `md5` (`md5`), ADD KEY `sha1` (`sha1`), ADD KEY `sha224` (`sha224`), ADD KEY `sha256` (`sha256`), ADD KEY `sha384` (`sha384`), ADD KEY `sha512` (`sha512`), ADD KEY `ripemd128` (`ripemd128`), ADD KEY `ripemd160` (`ripemd160`), ADD KEY `ripemd256` (`ripemd256`), ADD KEY `ripemd320` (`ripemd320`), ADD KEY `whirlpool` (`whirlpool`), ADD KEY `tiger128,3` (`tiger128,3`), ADD KEY `tiger160,3` (`tiger160,3`), ADD KEY `tiger192,3` (`tiger192,3`), ADD KEY `tiger128,4` (`tiger128,4`), ADD KEY `tiger160,4` (`tiger160,4`), ADD KEY `tiger192,4` (`tiger192,4`), ADD KEY `snefru` (`snefru`), ADD KEY `snefru256` (`snefru256`), ADD KEY `gost` (`gost`), ADD KEY `gost-crypto` (`gost-crypto`), ADD KEY `adler32` (`adler32`), ADD KEY `crc32` (`crc32`), ADD KEY `crc32b` (`crc32b`), ADD KEY `fnv132` (`fnv132`), ADD KEY `fnv1a32` (`fnv1a32`), ADD KEY `fnv164` (`fnv164`), ADD KEY `fnv1a64` (`fnv1a64`), ADD KEY `joaat` (`joaat`), ADD KEY `haval128,3` (`haval128,3`), ADD KEY `haval160,3` (`haval160,3`), ADD KEY `haval192,3` (`haval192,3`), ADD KEY `haval224,3` (`haval224,3`), ADD KEY `haval256,3` (`haval256,3`), ADD KEY `haval128,4` (`haval128,4`), ADD KEY `haval160,4` (`haval160,4`), ADD KEY `haval192,4` (`haval192,4`), ADD KEY `haval224,4` (`haval224,4`), ADD KEY `haval256,4` (`haval256,4`), ADD KEY `haval128,5` (`haval128,5`), ADD KEY `haval160,5` (`haval160,5`), ADD KEY `haval192,5` (`haval192,5`), ADD KEY `haval224,5` (`haval224,5`), ADD KEY `haval256,5` (`haval256,5`);

Espero que os sirva de ayuda para vuestros proyectos,
Saludos :B


maduranma’s Stresser – Generador de estrés para el procesador

Hola lectores,
Estaba en clase y me plateé qué haría falta para petar la CPU del ordenador que teníamos, así que básicamente hice un programa en C# que calculaba los cosenos de 69 (por la naturaleza del número…) infinitamente (con un bucle while), y abriendo uno por núcleo de dicho procesador conseguías ponerlo al 100% (que además con la de años que tienen y contando que en su vida se han limpiado, se han puesto a 90-100 grados los jodios…).

Código del programa absurdo

Código del programa de clase (absurdamente fácil)

Después he decicido hacer algo útil, y puesto que ya he visto programas que hacen esto, de hecho hice un tutorial en mi canal de como hacer un test de estrés (que básicamente sirve para ver la temperatura cuando le estás metiendo caña al procesador), pero el programa que usé lo encontré por internet, y tenías que abrir un programa por núcleo, y eso nos lo podríamos ahorrar si simplemente lo hubieran hecho con varios threads en C# mismamente, así que, he decidido hacerlo yo en media horita o así y me ha quedado algo bastante cuqui, por ello he decidido publicar el resultado en este blog, por supuesto será Open Source, y si veo que tiene “éxito” supongo que lo actualizaré y una posible mejora en un futuro sería añadir abajo la temperatura de todos los cores (más o menos como SpeedFan, que es un buen complemento a usar con mi programa actualmente).

Speed Fan, para ver la temperatura de la CPU

Speed Fan, para ver la temperatura de la CPU

Aún teniendo propuestas las mejoras mencionadas anteriormente, el programa cumple perfectamente con su función, y solo requiere .NET Framework 3.5 (que viene instalado por defecto desde Windows 7, y sigue siendo compatible con Windows Vista con una simple actualización). Cabe mencionar que con cualquier versión posterior también sirve.

Mi programa (maduranma's Stresser)

Mi programa (maduranma’s Stresser)

Descargar_ICONODescargas

 Descargar versión 1.0.1Directa | Mediafire | Mega.co.nz