Por ahora va viento en popa y a toda vela, aunque por problemas familiares no tengo mucho tiempo (también he dejado de traducir pygame, de momento), pero siguiendo el consejo de Hugo en un post de hoy mismo a un compañero del foro voy a plantear aquí lo que estoy haciendo para que entre todos los que quieran colaborar el proyecto crezca, quien sabe si conseguiremos una versión decente que le pueda interesar a la gente.
En principio parece algo bastante sencillo. Opino que sólo hay que plantearlo bien, por eso he intentado concretar al máximo para tener las ideas bien claras. Lo que sigue es lo que he hecho hasta ahora, aunque algunas partes me dan errores, podeis probarlas y comentar lo que os parezca. Las reglas para hacer las reducciones las he extraído de la web de jagar donde explica un poco la teoría de las reducciones en la quiniela.
- Código: Seleccionar todo
#! usr/bin/env python
# -*- coding: utf-8 -*-
"""
Programa para crear las reducciones con cualquier cantidad de multiples (dobles y triples).
Por ejemplo; reducciones de 4 dobles y 4 triples a 100 apuestas asegurando el premio de 2ª categoría.
Puede recibir;
- numero de dobles y/o triples a reducir,
- apuesta sencilla,
- ruta y nombre de archivo.
Deberia hacer;
- una lista con tuplas del tipo [(1,1),(1,x),(x,1),(x,x)] con todas las apuestas metodo directo - agrupar las apuestas del metodo directo segun las reglas de reducción,
- guardar las apuestas y los grupos en un archivo (txt, html, pdf, etc) que sera formateado segun la lista mostrada en ej anterior, para posterior lectura y ahorro de memoria,
- leer las apuestas y los grupos desde archivos,
- extraer el grupo de reduccion en la que esta incluida una apuesta sencilla e imprimirlo por pantalla o en un archivo.
Debe funcionar con cualquier cantidad de apuestas, una apuesta es una lista del tipo [1,1,1], segun dobles y triples hayan esta tendrá más elementos, sabiendo el numero total de apuestas que recibimos en la lista (len(columnas) podemos hacer unos calculos para saber;
- la cantidad de dobles y de triples,
- el numero de grupos,
- la cantidad de apuestas que habra en cada grupo, etc.(http://club.telepolis.com/jagar1/Reducciones3.htm)
Devuelve el grupo de reduccion que incluye la apuesta sencilla por pantalla o en un archivo (html, txt, pdf, etc).
"""
__author__ = "Dokan"
__version__ = "$Revision: 0.0.2 $"
__date__ = "$Date: 2007/12/06 13:39:19 $"
__copyright__ = "Copyright (c) 2007 Dokan"
__license__ = "GPLv2"
import sys, os
def compara( x, y ): # x e y son listas que se han de comparar 1ro con 1ro, 2do con 2do, etc...
"""Compara dos listas, 1º elemento con 1º elemento, 2º con 2º, etc.
Devuelve el numero de diferencias encontradas entre ambas, 0 si no las hay."""
diferencias=0
for i in range(len(x)):
if x[i] != y[i]:
diferencias += 1
return diferencias
def formatea(ruta): #ruta incluye nombre de archivo: "/home/kike/python/quiniela/4d.txt"
"""Recibe una ruta con el nombre del archivo a tratar incluido(ej. "/home/kike/python/quiniela/4d.txt"), en principio solo txt, más adelante tal vez también otros formatos. El archivo debe incluir las apuestas del método directo, que son devueltas como una lista de tuplas (de momento solo lo he probado con el formato que copio&pego desde un html a un txt para luego procesarlo con esta funcion).
"""
columnas=file(txt).read() #asigna el contenido del archivo a una variable.
columnas = [tuple(elem.split()) for elem in columnas.split("\n")] #le damos el formato necesario
if columnas[-1]==(): columnas.pop() #elimina la ultima lista de columnas si es una lista vacia, esto ocurre cuando el txt termina con salto de linea.
return columnas
def multiples(apuestas): #recibe entero de len(apuestasMetDirecto())
"""Recibe un entero, el numero total de apuestas por el metodo directo (columnas de la lista).
Calcula el numero de multiples, separando dobles y triples, que se han combinado para obtener el numero de apuestas.
Devuelve dos enteros, el primero son los dobles y el segundo los triples.
apuestas = (2**dobles) * (3**triples)
"""
def multiples(apuestas):
dobles, triples = 0,0
while apuestas!=1:
while apuestas%2!=0:
apuestas/=2
dobles +=1
apuestas/=3
triples+=1
return dobles, triples
def apuestasMetDirecto(dobles, triples): #recibe dos enteros devueltos por multiples()
"""Recibe dos enteros, cantidad de dobles y triples en apuestas multiples.
Combina todas las apuestas del metodo directo.
Devuelve una lista de tuplas con todas las combinaciones del metodo directo.
Ap. Método Directo = (2**Dobles) * (3**Triples)
"""
apDobles = 2**dobles
apTriples = 3**triples
def premios(dobles, triples): #recibe dos enteros devueltos por multiples()
"""Recibe dos enteros, cantidad de dobles y triples en apuestas multiples.
Devuelve un entero, que es el numero de columnas con premios de 1ª y 2ª categoria que se obtendrian por el metodo directo y que determina el numero de grupos de reduccion.
premios = 1+dobles +(2*triples)
"""
premios = 1 + dobles + (2 * triples)
return premios
def limite(total, premios): #recibe dos enteros, len(apuestasMetDirecto()) y premios()
"""Recibe dos enteros, numero total de apuestas del metodo directo y numero de columnas con premios de 1ª y 2ª.
Es el numero de columnas minimo que garantizan un premio de 2ª categoria, por tanto es el numero de columnas que tendra cada grupo de reduccion. Si el resultado es entero (sin decimales) la reduccion se denomina perfecta, pero si no lo es (reduccion imperfecta) la reduccion tendra que tener mas columnas, para lo que se redondea el limite hacia arriba.
Devuelve un entero.
limite = Ap. Método Directo / Nº Premios
"""
if total%premios > 0: limite = total/premios + 1
else: limite = total/premios
return limite
def gruposReduccion(premios, limite, columnas):# premios(), limite(), apMetDirecto()
"""Recibe dos enteros y una lista de tuplas, premios será el num. de grupos de reduccion y limite será el num. de columnas de cada grupo de reduccion, columnas será el total de apuestas del metodo directo.
Distribuye cada apuesta del metodo directo en grupos de reduccion segun un criterio dado.
Grupo de reduccion es el grupo de columnas minimo para garantizar el premio de 2ª categoria, de la union de todos los grupos de reduccion resulta el total de apuestas del metodo directo.
Las condiciones que ha de cumplir son:
- Todas las columnas de un grupo se diferencian entre si en al menos 3 signos.
- Todas las columnas que no pertenecen a un grupo coinciden en 2 signos con al menos una de las columnas de ese grupo.
- Todos los grupos de reduccion forman el total de las apuestas por el metodo directo.
No Devuelve nada, los grupos se guardan en globals().
"""
def agrupa(premios): #premios()
"""Recibe numero de grupos de reduccion y los agrupa en una unica tupla. Estos grupos estan en globals().
Devuelve todos los grupos de reducción en una unica tupla (((1,1),(x,x)),((1,x),(x,1))).
"""
if __name__ == '__main__':
# Import Psyco if available
try:
import psyco
psyco.full()
except ImportError:
pass
__main__ # ...your code here...
Ya sabeis que espero vuestras críticas, constructivas a ser posible
Felices fiestas.
mmm un viejo forero, que nostalgia.
