user: lo que se te cante el huevo

Si a alguien le da curiosidad como funciona eso, lo puedo explicar :)

Los primeros términos de la sucesión son:

## Sucesion 'look and say'

#

# 1:  1

# 2:  11

# 3:  21

# 4:  1211

# 5:  111221

# 6:  312211

# 7:  13112221

# 8:  1113213211

# 9:  31131211131221

# 10: 13211311123113112211

#

##########################

Hay acciones de diferentes empresas, y cada día que pasa esas acciones van cambiando de valor al azar (tampoco TAN al azar, estaría bueno plantear algún modelo para eso). Las acciones se pueden ir comprando y vendiendo.

El objetivo del juego realmente no sabría decirles cual es, jajaj, obviamente que uno va a apuntar a quedarse con todas las acciones, y ahí esta la competencia y el uso de la inteligencia para predecir el comportamiento de la bolsa (que en este caso seria más cuestión de suerte, por el hecho que los nuevos valores se generarían al azar).

Viéndonos limitado por esto, podríamos usar las acciones de alguna bolsa real y importarlas cada día en el sitio. Y ahí competir usando datos reales (eso lo haría bastante más emocionante).

No lo veo para nada complejo y sobre todo, estaría bueno que lo orientemos a que sea un proyecto del foro. Total con un svn y un poco de planificación y diseño lo levantamos en 2 patadas.

¿Quién se prende? 

Ejemplo: 0.5 => 1/2

              0.33333333 => 1/3

              7.85106383 => 369/47

Sin complicarmela tanto se me ocurrió este algoritmo:

Yo tengo un numero decimal X, y quiero expresarlo de la forma N/D donde N es e el númerador y D el denominador. Lo que quedaría:

N/D = X

Despejando N, nos quedaria:

N = X*D

El número que busco tiene que ser la mínima expresión fraccionaria (como 1/2 = 2/4 = 3/6 = ... me quedo con 1/2). Entonces lo único que tengo que hacer es ir dándole valores a D (a partir de 2, o 1 en el caso que el número que se ingresa ya sea entero) hasta que N sea entero.

Una simple implementación en Python:

def toFraction(x): 
    d = 1 
    while not float(x*d).is_integer():
        d += 1 
    return str(int(x*d)) + "/" + str(int(d))

¿A alguien se le ocurre un método mejor?

Las acciones posibles serian:

Atacar: un golpe que causa un daño entre un rango pequeño.

Defender: una probabilidad de esquivar el ataque y contra-atacar (con un daño menor al de Atacar).

Curar: te recarga un poco de vida. (usa mana) 

Rayo: es un golpe que causa un daño entre un rango grande, mayor al de atacar. (usa mana) (no se puede esquivar)

Las características de los luchadores (para todos iguales):

Vida: 500 puntos de vida.

Mana: 10 puntos de mana (cada conjuro gasta 1 punto).

Rango ataque: 5 - 25

Rango contra-ataque: 1 - 10

Rango Rayo: 10 - 50

Rango curar: 1 - 100

Obviamente todos estos valores son arbitrarios, habría que buscar algunos para que las luchas sean balanceadas. Aunque pensándolo bien, le eficiencia de los algoritmos se basaría en descubrir por donde se puede sacar más ventaja a partir de las características de los luchadores (lo que es un buen ejemplo de programación lineal y optimización de la producción ;) ).

Bien, bien, bien. Hasta ahora todo bonito. Lo complicado es: no todos programamos en los mismos lenguajes. ¿Entonces como hacemos? Bueno, yo hago un servidor que se encargue de gestionar las peleas, y ustedes programan sus algoritmos en lo que se les cante, siempre y cuando se pueda conectar al servidor.

Si les interesa podemos ir especificando el protocolo del juego. También más adelante podríamos ir variando las características de los luchadores, hasta lograr algoritmos totalmente genéricos que basen sus estrategias puramente en estas.

Las luchas serian turno por turno.

La de un luchador B podría ser:

si ronda es 1: movimiento de ataque al azar (Ataque o Rayo).

si vida propia es baja: Si hay mana: curar; Sino Atacar.

si vida contrincante es baja: Si hay mana: Rayo; Sino Atacar.

si enemigo Ataco en ronda anterior: Defender.

Espero que se entienda. A mayor complejidad de algoritmo, mejores resultados (o no...). Hasta algunos podrían hacer una red neuronal que vaya aprendiendo a mejorar su estrategia a medida que pelea, y así, después de muchas peleas poder vencer a todos. Todo eso queda a criterio del concursante. Que cada uno haga lo que quiera con su algoritmo, solamente debe respetar el protocolo y enviar una acción cada vez que se pase a la siguiente ronda. Hasta que se ocurrio un algoritmo que me hacke la PC y busque los fuentes de los demas algoritmos para poder espiar sus estrategias (pero eso ya seria de limado :P ).

Bueno espero respuestas y si les copa nos ponemos manos a la obra total no es difícil.

para jugar de a 2 personas

Y digo prototipo porque todavía no está terminado, falta mucho por hacer (este proyecto lo dejé hace tiempo atrás porque tenía que ocuparme en otras cosas, pienso retomarlo). Es un proyecto experimental y bastante jodido, escribo todo esto para descargar un poco la tensión (estoy enloqueciendo mas de lo normal). xD

Esto va a ser excesivamente largo, no es necesario que lo lean. (supongo que me sirve de guía, y ya que estoy lo postéo acá)

Introducción:

-------------

La compresión de datos tiene por objetivos usar menos espacio de memoria en el disco rígido a costa de modificar los datos en cuestión. Obviamente los datos comprimidos no pueden ejecutarse como un .exe, y como están alterados no sirven para nada hasta que se los descomprima.

Supongamos que tenemos una cadena de caracteres: $A.

$A podría ser, por ejemplo: [ A48^*S¨"=GKA?"¨RA::>¨!?·)VK"?DA ]

Pero podriamos guardar esa cadena en un archivo txt, y leer el archivo de forma binaria, obteniendo ceros y unos.

$A quedaría algo así:

[ 0110100101010010101010010101010001010100101010101001 ]

Mucho más larga por supuesto, ya que para cada caracter necesitamos más de un bit (dependiendo del tipo de codificación, pero no viene al caso, supongamos que necesitamos 8 bits).

Exceso de bits:

---------------

Si cada caracter toma información de 8 bits, a nosotros no nos interesa. Nosotros vamos a tomar de a 10 caracteres (1024 posibilidades)

Si la cadena binaria tiene, por ejemplo, 13 dígitos, entonces van a sobrar 3 dígitos (o a faltar 7 dígitos). Lo que se hace en ese caso es apartar esos 3 bits y registrarlos por ahi. La idea es que esos 3 bits no van a ser comprimidos.

Un archivo podría tener 450137463 bits, de modo que 3 bits definitivamente no hacen la diferencia.

Números decimales:

------------------

Para simplificar MUCHO la tarea de entender cómo funciona todo, vamos a representar las 1024 posibilidades de los 10 bits como números decimales. Siempre trabajaríamos con números binarios, pero los representamos en decimal.

Y los números que tienen ceros a la izquierda, se quedan tal y como están: con ceros a la izquierda.

Ejemplos:     0012     0003     0628     1024     0000     0391

Esto lo hacemos así porque en realidad estamos trabajando con cadenas, aunque se vea como números.

El 0082 podría estar representando la letra "R" por ejemplo. Noten que tomo siempre de a 4 caractéres.

Si tuvieramos una cadena de caractéres asi: "0371037510120092"

la dividiríamos así: 0371 0375 1012 0092

A cada grupo de 4 dígitos, llamemoslé código.

Ejemplo: n = 100

Es muy fácil extender esta formula para cual tipo de rango (que no empiece de 0 necesariamente)

Sumatoria de los números naturales de n a m:

Estructura del paquete login:

2: versión del cliente desde el cual nos conectamos

3: longitud de usuario

4: usuario

5: longitud de password

6: password

7: longitud de nombre del personaje

8: nombre del personaje

Cada uno de estos datos es separado por un "00" (en hexadecimal)

un ejemplo:

Ok, con eso ya nos podemos conectar al servidor. Ahora vamos al siguiente paso: dar un paso :P

Estructura del paquete para moverse:

1: codigo '01'

2: direccion (de 04 hasta 07)

Lo que nos quedaría (recordar que el '00' separa datos):

Con esto ya podemos conectarnos y caminar desde una consola sin necesidad de ningún cliente. Un poco más de investigación, nos permitiria lograr muchas cosas. Aunque hay un pequeño inconveniente que todavía no pude resolver y por eso perdí el interés de continuar, capas que a alguien le sirve.

Dejo un script hecho en python que utiliza todo lo descripto previamente:

En la muni necesitabamos una tabla con todas las localidades de Argentina, y encontramos que Correo Argentino la tiene, acá:

Así que armé un script PHP que recorre todas las provincias de esa lista y va copiandose a lo bruto las localidades con su código postal y provincia, y finalmente vuelca los datos en consultas SQL.

Para simplificar, paso los datos en un archivo .ODS por si alguna vez alguno necesita los datos para un proyecto o algo.

Por mi parte, acabo de implementar OpenGL en el (interminable) Pixel War, y por lo que veo, van a volver los muchachitos de negro con ametralladoras y mucha mucha sangre. También ando con ganas de meterme en alguna comunidad de desarrollo de algún RPG online, algo como Argentum o OpenTibia.

¿Qué hay de ustedes?

Primero: la carita - 10 pixels x 10 pixels - la linea roja marca el limite de la imagen original

Segundo: tomando pixel por pixel, lo movemos al doble de sus coordenadas (si mi pixel esta en [5, 5] ahora paso a [10, 10])

Atención: empezar siempre por abajo a la derecha yendo hacia la izquierda para arriba

Este proceso sirve tanto para duplicar, triplicar, cuadruplicar, hasta n-plicar una imagen, pero solo eso. Solo aumenta el tamaño en forma potencial y esa es la gran macana, por lo que no tiene ningún aplicación útil, je.

¿Qué opinan?

Web con retos de programación y matemáticas, parecida a Project Euler pero un poco más fáciles. Si alguno se copa podemos ir resolviéndolos cooperativamente 

return 0;

Link: http://franr.com.ar/kevin