Guest User

quiniela7Dobles

a guest
Mar 18th, 2011
1,884
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5.  
  6. namespace Quiniela
  7. {
  8.     class Program
  9.     {
  10.         //matriz multidimensional con la tabla de reduccion 7 dobles. Nos servirá para calcular las 16 quinielas simples
  11.         static string[,] reduccion7Dobles = new string[16, 7] {
  12.             { "1", "1", "1", "1", "1", "1", "1" },
  13.             { "1", "1", "1", "1", "x", "x", "x" },
  14.             { "x", "x", "x", "x", "1", "1", "1" },
  15.             { "x", "x", "x", "x", "x", "x", "x" },
  16.             { "x", "x", "1", "1", "x", "1", "1" },
  17.             { "x", "x", "1", "1", "1", "x", "x" },
  18.             { "1", "1", "x", "x", "x", "1", "1" },
  19.             { "1", "1", "x", "x", "1", "x", "x" },
  20.             { "x", "1", "x", "1", "1", "x", "1" },
  21.             { "x", "1", "x", "1", "x", "1", "x" },
  22.             { "1", "x", "1", "x", "1", "x", "1" },
  23.             { "1", "x", "1", "x", "x", "1", "x" },
  24.             { "x", "1", "1", "x", "1", "1", "x" },
  25.             { "x", "1", "1", "x", "x", "x", "1" },
  26.             { "1", "x", "x", "1", "1", "1", "x" },
  27.             { "1", "x", "x", "1", "x", "x", "1" }
  28.         };
  29.  
  30.         //matriz multidimensional, 16 filas y 15 columnas. De nuestra quiniela con 7 dobles, y la tabla de reduccion,
  31.         //obtendremos 16 quinielas simples, con 15 pronosticos.
  32.         static string[,] apuestas = new string[16, 15];
  33.  
  34.         //metodo para representar en pantalla todos los elementos de una matriz de cadenas de 2 dimensiones
  35.         static void PintaMatriz2Dimensiones(string[,] matrizmulti)
  36.         {
  37.             for (int i = 0; i < matrizmulti.GetLength(0); i++)
  38.             {
  39.                 for (int j = 0; j < matrizmulti.GetLength(1); j++)
  40.                 {
  41.                     Console.WriteLine(" " + matrizmulti[i, j] + " ");
  42.                 }
  43.             }
  44.  
  45.         }
  46.  
  47.         //metodo que representa en pantalla una matriz de numeros enteros
  48.         static void PintaMatriz(int[] matriz)
  49.         {
  50.             for (int contador = 0; contador < matriz.Length; contador++)
  51.             {
  52.                 Console.WriteLine("En la columna " + (contador + 1) + " : " + matriz[contador] + " aciertos.");
  53.             }
  54.         }
  55.  
  56.         //metodo con el cual comparamos las 16 quinielas simples, con el resultado final. Devuelve una cadena de enteros, donde guardamos
  57.         // los aciertos de cada quiniela simple.  
  58.         static int[] ComparaMatrices(string[,] apuestas, string[] resultadoQuiniela)
  59.         {
  60.             int[] aciertos = new int[16];
  61.             int numeroAciertos = 0;
  62.  
  63.             for (int i = 0; i < apuestas.GetLength(0); i++)
  64.             {
  65.                 for (int j = 0; j < apuestas.GetLength(1); j++)
  66.                 {
  67.                     if (apuestas[i, j] == resultadoQuiniela[j])
  68.                     {
  69.                         numeroAciertos++;
  70.  
  71.                     }
  72.                     if ((j == 13) && (numeroAciertos != 14)) //si en el pronostico 14 de una quiniela simple, tenemos menos de 14 aciertos, despreciamos el pronostico 15
  73.                     {
  74.                         j++;
  75.                     }
  76.                 }
  77.                 aciertos[i] = numeroAciertos;
  78.  
  79.  
  80.                 numeroAciertos = 0;
  81.             }
  82.  
  83.  
  84.             return aciertos;
  85.         }
  86.  
  87.         //Partiendo desde nuestra quiniela de 7 dobles, vamos insertando los valores correctos, en la matriz apuestas dependiendo
  88.         // de lo que pone en la tabla de reduccion de 7 dobles.
  89.         static string[,] Resolucion7Dobles(string[] miquiniela)
  90.         {
  91.             int numeroColumnaMatrizReduccion = 0;
  92.             for (int i = 0; i < apuestas.GetLength(0); i++)
  93.             {
  94.                 for (int j = 0; j < apuestas.GetLength(1); j++)
  95.                 {
  96.                     if ((miquiniela[j] == "1") || (miquiniela[j] == "x") || (miquiniela[j] == "2"))
  97.                     {
  98.                         apuestas[i, j] = miquiniela[j];
  99.                     }
  100.                     else
  101.                     {
  102.                         if ((miquiniela[j] == "1x") && (reduccion7Dobles[i, numeroColumnaMatrizReduccion] == "1"))
  103.                         {
  104.                             apuestas[i, j] = "1";
  105.                         }
  106.                         if ((miquiniela[j] == "1x") && (reduccion7Dobles[i, numeroColumnaMatrizReduccion] == "x"))
  107.                         {
  108.                             apuestas[i, j] = "x";
  109.                         }
  110.                         if ((miquiniela[j] == "12") && (reduccion7Dobles[i, numeroColumnaMatrizReduccion] == "1"))
  111.                         {
  112.                             apuestas[i, j] = "1";
  113.                         }
  114.                         if ((miquiniela[j] == "12") && (reduccion7Dobles[i, numeroColumnaMatrizReduccion] == "x"))
  115.                         {
  116.                             apuestas[i, j] = "2";
  117.                         }
  118.                         if ((miquiniela[j] == "x2") && (reduccion7Dobles[i, numeroColumnaMatrizReduccion] == "1"))
  119.                         {
  120.                             apuestas[i, j] = "x";
  121.                         }
  122.                         if ((miquiniela[j] == "x2") && (reduccion7Dobles[i, numeroColumnaMatrizReduccion] == "x"))
  123.                         {
  124.                             apuestas[i, j] = "2";
  125.                         }
  126.                         numeroColumnaMatrizReduccion++;
  127.                     }
  128.  
  129.                 }
  130.                 numeroColumnaMatrizReduccion = 0;
  131.             }
  132.             return apuestas;
  133.         }
  134.  
  135.         static void Main(string[] args)
  136.         {
  137.             int nElementos = 15;
  138.             string[] miQuiniela = new string[nElementos];
  139.             string[] resultadosQuiniela = new string[nElementos];
  140.             string entradaTeclado;
  141.             int[] misaciertos = new int[16];
  142.  
  143.  
  144.             //Todo el codigo comentado, sirve para meterle directamente una quiniela por defecto con los resultados finales, para comprobar que
  145.             //lo obtenido por los distintos metodos del programa sea correcto.
  146.  
  147.             //string[] miQuiniela = { "2", "x2", "x", "2", "2", "1", "12", "1x", "1x", "1", "1x", "12", "x", "1x", "2" };
  148.             //string[] resultadoFinalQuiniela = { "1", "x", "x", "x", "x", "1", "1", "1", "x", "1", "x", "x", "2", "1", "2" };
  149.             //string[] miQuiniela = { "1x", "1x", "1x", "1x", "1x", "1x", "1x", "1", "1", "1", "1", "1", "1", "1", "1" };
  150.             //string[] resultadoFinalQuiniela = { "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1" };
  151.             //Resolucion7Dobles(miQuiniela);
  152.             //misaciertos = ComparaMatrices(apuestas, resultadoFinalQuiniela);
  153.             //PintaMatriz(misaciertos);
  154.  
  155.  
  156.             Console.WriteLine("Introduzca su quiniela reducida de 7 dobles: ");
  157.             for (int contador = 0; contador < miQuiniela.Length; contador++)
  158.             {
  159.                 entradaTeclado = Console.ReadLine();
  160.                 miQuiniela[contador] = entradaTeclado;
  161.             }
  162.  
  163.             Console.Clear();
  164.  
  165.             Console.WriteLine("Introduca Los resultados de la Quiniela de la semana");
  166.  
  167.             for (int contador = 0; contador < resultadosQuiniela.Length; contador++)
  168.             {
  169.                 entradaTeclado = Console.ReadLine();
  170.                 resultadosQuiniela[contador] = entradaTeclado;
  171.             }
  172.             Console.Clear();
  173.             Resolucion7Dobles(miQuiniela);
  174.             misaciertos = ComparaMatrices(apuestas, resultadosQuiniela);
  175.             PintaMatriz(misaciertos);
  176.  
  177.             Console.Read();
  178.         }
  179.     }
  180. }
RAW Paste Data