Buenas
Para los que no lo sepan
La Quiniela es un juego de azar, un sistema de apuestas popular en España, basada en la liga española de fútbol y gestionado por
Loterías y Apuestas del Estado
(LAE)
Dicho juego consiste en una columna de catorce apuestas correspondiente a catorce partidos de fútbol, normalmente de primera y segunda división, pero a falta de ellos por calendario pueden usarse partidos de otros campeonatos importantes, incluso de selecciones. El objetivo es acertar [1] Gana el equipo que juega en casa, [X]Empate, [2] Gana el equipo que juega fuera de casa. Se añade ademas una quinceaba apuesta basada en el número de goles de un partido
0 1 2 M Donde M son más de 2 goles.
¿Qué tiene esto que ver con los números en base 3?A ver, esto no es algo que acabe de descubrir pero hace tiempo que no publico nada aquí y se me ha ocurrido que era una curiosidad interesante a publicar en este foro. De hecho es algo que usé en un trabajo de investigación del Bachillerato por el 2015 sobre juegos de azar. Pero lo sabía desde el 2004 más o menos, cuando investigué para realizar un programa de ordenador sobre este juego (sin Internet), matizo esto porque hoy en día se puede encontrar casi cualquier cosa sobre este juego en Internet. Sin embargo sobre esto no he encontrado nada de nada y ya es difícil. ¿Nadie ha visto la relación? Quizás no he buscado bien, en fin no sé, pero por esta razón he decidido publicar esto.
Pues bien, resulta que las variaciones que resultan de rellenar una columna de catorce apuestas de La Quiniela
pueden convertirse o interpretarse como números en base 3. Si escribimos una columna cualquiera linealmente nos sale algo así:
1X1212121111XXExiste una fórmula muy simple para saber el número de variaciones que se pueden realizar, llamadas Variaciones con repetición. Consiste en una potencia cuya base es el número de signos o elementos, [1X2] en este caso que serían tres y lo elevamos al número de elementos que combinamos que serían catorce. Finalmente obtenemos:
3^14= 4782969 variaciones.Luego podríamos pasarnos todo el día haciendo variaciones hasta que nos cansáramos. Pero, ¿Cómo puedo hacer variaciones en orden, desde 11111111111111, a 222222222222222 sin repetir una sola hasta obtener las 4782969 posibles?
Esta es la pregunta que me hice cuando quise realizar un programa que fuera capaz de realizar todas las variaciones en orden correlativo. Es más, poder obtener cual sería la variación 3512 por ejemplo o la número 3125245.
La solución que encontré fue convertirlos o interpretarlos como números en base 3.
Para ello basta con sustituir el 1 por 0, la X por 1, y el 2 lo dejamos como está. Por ejemplo, la variación que puse más arriba sería 01020202000011:
Variación de La Quiniela
1X1212121111XXMisma variación interpretada como número en Base 3
01020202000011¿Qué orden ocupa?Solo hay que pasarlo a un número decimal para obtener su lugar dentro de las 4782969 variaciones. Igualmente se puede hacer a la inversa. Pasar un número decimal a base tres y luego obtener la variación de la quiniela.
Para el proceso de conversión de cualquier base hay vídeos por ahí de binario a decimal pero usan tablas y lo ponen como más complicado de lo que és. El proceso es realmente muy simple, consiste en coger el primer dígito multiplicarlo por la base elevada a la posición que ocupa el dígito empezando por la derecha y desde 0.
2121110= 0·3^0 + 1·3^1 + 1·3^2 + 1·3^3 + 2·3^4 + 1·3^5 + 2·3^6 = 1902
Lo pondré entre corchetes para que se vea más claro donde b es igual a la base
2121110= [0 * b^0] + [1 * b^1] + [1 * b^2] + [1 * b^3] + [2 * b^4] + [1 * b^5] + [2 * b^6] = 1902
Así para saber que lugar ocupa cualquier variación que hagamos de La Quiniela tan solo hay que convertirlo en un número de base tres y luego realizar la operación de conversión a decimal y sumarle uno al resultado. Hacerlo manualmente o con calculadora resulta tedioso, sin embargo se puede hacer con un simple código.
El algoritmo para convertir un número en base 3 a decimal con C# es bien simple (por lo menos el que he hecho yo, es lo que creo):
string strNumB3 = "0"; //Numero en base 3
int RepLoop = strNumB3.Length; //segun el numero de digitos repeticiones para el bucle
int NumDec = 0;
for (int I = RepLoop - 1; I >= 0; I--)
{
NumDec += Convert.ToInt32(strNumB3.Substring(I, 1)) * (int)(Math.Pow(3, RepLoop - I - 1));
}
NumDec += 1;
Console.WriteLine(NumDec);
Console.ReadLine();
En este caso devuleve 1 porque he establecido a numB3 el valor 0. Como expliqué arriba el 1 equivale a 0
La primera variación es 11111111111111 = 00000000000000 = 0 = 0
La segunda variación es 111111111111X = 00000000000001 = 1 = 1
La tercera variación es 1111111111112= 00000000000002 = 2 = 2
La cuarta variación es 111111111111X1=00000000000010= 10 = 3
La quinta ariación es 111111111111XX=00000000000011= 11 = 4
La sexta ariación es 111111111111X2=00000000000012= 12 = 5
Si se observa bien he añadido un 1 al resultado del algoritmo en la línea 8:
Esto es porque el número cero en base tres es obviamente cero, y no tiene sentido decir la variación número cero, de modo que le sumo un uno para determinar el orden correcto ya que la primera 11111111111111 cuyo "equivalente" en base tres sería 0000000000000 sería 1 y finalmente 22222222222222 será 4782969, como puede comprobarse tras ejecutar el siguiente código:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
string Quiniela = "22222222222222".Replace("1", "0").Replace("X", "1").Replace("x", "1");
string strNumB3 = Quiniela; //Numero en base 3
int RepLoop = strNumB3.Length; //segun el numero de digitos repeticiones para el bucle
int NumDec = 0;
for (int I = RepLoop - 1; I >= 0; I--)
{
NumDec += Convert.ToInt32(strNumB3.Substring(I, 1)) * (int)(Math.Pow(3, RepLoop - I - 1));
}
NumDec += 1;
Console.WriteLine(string.Format("{0} es la variacion numero {1}",Quiniela , NumDec));
Console.ReadLine();
}
}
}
Esto lo tenía en
VB6 ya que cuando lo desarrollé usaba esa programación y lo he actualizado a C#. Menudo cambio ¿no?
'...
F = Mid(strA, 14, 1) + Mid(strA, 13, 1) * 3 + Mid(strA, 12, 1) * 3 ^ 2 + Mid(strA, 11, 1) * 3 ^ 3 + Mid(strA, 10, 1) * 3 ^ 4 + Mid
(strA, 9, 1) * 3 ^ 5 + Mid(strA, 8, 1) * 3 ^ 6 + Mid(strA, 7, 1) * 3 ^ 7 + Mid(strA, 6, 1) * 3 ^ 8 _
+ Mid(strA, 5, 1) * 3 ^ 9 + Mid(strA, 4, 1) * 3 ^ 10 + Mid(strA, 3, 1) * 3 ^ 11 + Mid(strA, 2, 1) * 3 ^ 12
'...
Quizás encontréis una forma más eficiente de calcularlo de la que yo he usado en C#.
El proceso inverso, es decir pasar de decimal a base 3 podría ser este:
int NumB10 = 1; //Numero basado en el total de variaciones (3^14) de La Quiniela
string numB3 = string.Empty; //Variable para el numero en Base 3
NumB10 -= 1; //Le resto 1 al numero en base 10
do
{
numB3 = NumB10 % 3 + numB3;
NumB10 = NumB10 / 3;
} while (NumB10 > 0);
Console.WriteLine(numB3);
Console.ReadLine();
Se basa en un algoritmo matemático bastante sencillo que se puede realizar en papel con bolígrafo en mano. Modificando un poco el código en C# que he puesto se puede hacer para cualquier tipo de conversión pero el que he puesto arriba es sólo de número en base 10 a base 3.
Nótese que inicialmente resto 1 al número en base 10, esto es porque como expliqué más arriba la primera variación equivale 0 en base 3; 11111111111111= 00000000000000= 0.
Volviendo al objetivo que era poder escribir las variaciones en orden correlativo aquí dejo un sencillo código en el que se puede realizar una serie de variaciones en orden correlativo desde A a B, (NOTA: La consola sólo puede mostrar un número total de 299 líneas, por lo que si se generan más de 299 variaciones solo se verán las 299 últimas).
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
int min = 1;
int max = 299;
for (int n = min - 1; n < max; n++)
{
string B3 = string.Format("{0:00000000000000}", Convert.ToInt64(ConvNumB3(n)));
string Variacion = B3.Replace("1", "X").Replace("0", "1");
Console.WriteLine(string.Format("{0}= {1}= {2}", n + 1, B3, Variacion));
}
Console.ReadLine();
}
static string ConvNumB3(int NumB10)
{
string numB3 = string.Empty;
do
{
numB3 = NumB10 % 3 + numB3;
NumB10 = NumB10 / 3;
} while (NumB10 > 0);
return numB3;
}
}
}
Quizás haya otra manera para poder crear las variaciones en orden ¿Quizás con LINQ? mmm se me escapa.
En cualquier caso la interpretación de números en base 3 y las variaciones de la quiniela existe, así como la forma de establecer una posición, un orden para cada variación.
Saludos.
Mostrar Temas
)?
