API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Feb 27th, 2017
73
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C# 12.31 KB | None | 0 0
raw download clone embed print report
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Web;
  5. using System.Web.UI;
  6. using System.Web.UI.WebControls;
  7. using System.IO;
  8.  
  9. public partial class LAB1_SUDOKU : System.Web.UI.Page
  10. {
  11.     protected void Page_Load(object sender, EventArgs e)
  12.     {
  13.        
  14.     }
  15.     protected void Button1_Click(object sender, EventArgs e)
  16.     {
  17.         Sudoku sudoku = new Sudoku();
  18.         int[] x = new int[36]; // eilutės koordinatė
  19.         int[] y = new int[36]; // stulpelio koordinatė            
  20.         int kiekt = 0; // kiek yra tuščių langelių
  21.         Skaitymas(sudoku);
  22.         VietuRadimas(sudoku, x, y, ref kiekt);      
  23.         PildytiLangelius(sudoku, x, y, ref kiekt);
  24.         for (int i = 0; i < 6; i++)
  25.         {
  26.             TableRow Row = new TableRow();
  27.             for (int j = 0; j < 6; j++)
  28.             {
  29.                 TableCell Cell = new TableCell();
  30.                 Cell.Text = Convert.ToString(sudoku.Langelis[i, j]);
  31.                 Row.Cells.Add(Cell);
  32.             }
  33.             Table1.Rows.Add(Row);
  34.  
  35.         }
  36.     }  
  37.  
  38.         // Duomenų nuskaitymo metodas
  39.         static void Skaitymas(Sudoku sudoku)
  40.         {
  41.             using (StreamReader input = new StreamReader(HttpContext.Current.Server.MapPath("/App_Data/U3.txt")))
  42.             {
  43.                 for (int i = 0; i < 6; i++)
  44.                 {
  45.                     var reiksmes = (input.ReadLine().Split(' '));
  46.                     for (int j = 0; j < 6; j++)
  47.                     {
  48.                         sudoku.Langelis[i, j] = int.Parse(reiksmes[j]);
  49.                     }
  50.                 }
  51.             }
  52.         }
  53.  
  54.         static void Isvedimas(Sudoku sudoku)
  55.         {
  56.             int[] x = new int[36]; // eilutės koordinatė
  57.             int[] y = new int[36]; // stulpelio koordinatė            
  58.             int kiekt = 0; // kiek yra tuščių langelių
  59.             for (int i = 0; i < 6; i++)
  60.             {
  61.                 for (int j = 0; j < 6; j++)
  62.                     Console.Write(sudoku.Langelis[i, j] + " ");
  63.                 Console.WriteLine();
  64.             }
  65.             Console.WriteLine("------------------------------");
  66.             PildytiLangelius(sudoku, x, y, ref kiekt);
  67.             for (int i = 0; i < 6; i++)
  68.             {
  69.                 for (int j = 0; j < 6; j++)
  70.                     Console.Write(sudoku.Langelis[i, j] + " ");
  71.                 Console.WriteLine();
  72.             }
  73.         }
  74.  
  75.         // Metodas, randantis, kuriose x ir y ašyse yra tušti langeliai
  76.         static void VietuRadimas(Sudoku sudoku, int[] x, int[] y, ref int kiekt)
  77.         {
  78.             for (int i = 0; i < 6; i++)
  79.             {
  80.                 for (int j = 0; j < 6; j++)
  81.                 {
  82.                     if (sudoku.Langelis[i, j] == 0)
  83.                     {
  84.                         x[kiekt] = i;
  85.                         y[kiekt] = j;
  86.                         kiekt++;
  87.                     }
  88.                 }
  89.             }
  90.         }
  91.  
  92.         // Tuščių langelių pildymo metodas
  93.         static void PildytiLangelius(Sudoku sudoku, int[] x, int[] y, ref int kiekt)
  94.         {
  95.             if (kiekt != 0)
  96.             {
  97.                 for (int i = 0; i < 6; i++)
  98.                 {
  99.                     for (int j = 0; j < 6; j++)
  100.                     {
  101.                         if (sudoku.Langelis[i, j] == 0)
  102.                         {
  103.                             int indeksas = 0;
  104.                             if (TikrintiStulpeli(sudoku, j) == 1)
  105.                             {
  106.                                 int skaicius = 0;
  107.                                 for (int sk = 1; sk <= 6; sk++)
  108.                                     if (skaicius == 0)
  109.                                     {
  110.                                         int k;
  111.                                         for (k = 0; k < 6; k++)
  112.                                             if (sudoku.Langelis[k, j] == sk)
  113.                                                 break;
  114.                                         if (k == 6)
  115.                                         {
  116.                                             skaicius = sk;
  117.                                             break;
  118.                                         }
  119.                                     }
  120.                                 sudoku.Langelis[i, j] = skaicius;
  121.                                 kiekt--;
  122.                             }
  123.                             else if (TikrintiEilute(sudoku, i) == 1)
  124.                             {
  125.                                 int skaicius = 0;
  126.                                 for (int sk = 1; sk < 7; sk++)
  127.                                     if (skaicius == 0)
  128.                                     {
  129.                                         int k;
  130.                                         for (k = 0; k < 6; k++)
  131.                                             if (sudoku.Langelis[i, k] == sk)
  132.                                                 break;
  133.                                         if (k == 6)
  134.                                         {
  135.                                             skaicius = sk;
  136.                                             break;
  137.                                         }
  138.                                     }
  139.                                 sudoku.Langelis[i, j] = skaicius;
  140.                                 kiekt--;
  141.                             }
  142.                             else if (BlokoNumerioPaieska(sudoku, i, j, ref indeksas) == 1)
  143.                             {
  144.                                 sudoku.Langelis[i, j] = RastiBlokoSkaiciu(sudoku, indeksas);
  145.                                 kiekt--;
  146.                             }
  147.                         }
  148.                     }
  149.                 }
  150.                 PildytiLangelius(sudoku, x, y, ref kiekt);
  151.             }
  152.         }
  153.  
  154.         // Stulpelio tuščių vietų patikrinimo metodas
  155.         static int TikrintiStulpeli(Sudoku sudoku, int k)
  156.         {
  157.             int kiek = 0;
  158.             for (int i = 0; i < 6; i++)
  159.             {
  160.                 if (sudoku.Langelis[i, k] == 0)
  161.                 {
  162.                     kiek++;
  163.                 }
  164.             }
  165.             return kiek;
  166.         }
  167.  
  168.         // Eilutės tuščių vietų patikrinimo metodas
  169.         static int TikrintiEilute(Sudoku sudoku, int k)
  170.         {
  171.             int kiek = 0;
  172.             for (int i = 0; i < 6; i++)
  173.             {
  174.                 if (sudoku.Langelis[k, i] == 0)
  175.                 {
  176.                     kiek++;
  177.                 }
  178.             }
  179.             return kiek;
  180.         }
  181.  
  182.         // Metodas, randantis bloką, kuriame yra tuščias langelis
  183.         static int BlokoNumerioPaieska(Sudoku sudoku, int x, int y, ref int indeksas)
  184.         {
  185.             int[,] blokas0 = { { 0, 0 }, { 0, 1 }, { 0, 2 }, { 1, 0 }, { 1, 1 }, { 1, 2 } };
  186.             int[,] blokas1 = { { 0, 3 }, { 0, 4 }, { 0, 5 }, { 1, 3 }, { 1, 4 }, { 1, 5 } };
  187.             int[,] blokas2 = { { 2, 0 }, { 2, 1 }, { 2, 2 }, { 3, 0 }, { 3, 1 }, { 3, 2 } };
  188.             int[,] blokas3 = { { 2, 3 }, { 2, 4 }, { 2, 5 }, { 3, 3 }, { 3, 4 }, { 3, 5 } };
  189.             int[,] blokas4 = { { 4, 0 }, { 4, 1 }, { 4, 2 }, { 5, 0 }, { 5, 1 }, { 5, 2 } };
  190.             int[,] blokas5 = { { 4, 3 }, { 4, 4 }, { 4, 5 }, { 5, 3 }, { 5, 4 }, { 5, 5 } };
  191.  
  192.             // Randa, kuriam bloke randasi reiksmė
  193.             for (int i = 0; i < 6; i++)
  194.             {
  195.                 if (BlokoPaieska(sudoku, x, y, blokas0))
  196.                     indeksas = 0;
  197.                 else if (BlokoPaieska(sudoku, x, y, blokas1))
  198.                     indeksas = 1;
  199.                 else if (BlokoPaieska(sudoku, x, y, blokas2))
  200.                     indeksas = 2;
  201.                 else if (BlokoPaieska(sudoku, x, y, blokas3))
  202.                     indeksas = 3;
  203.                 else if (BlokoPaieska(sudoku, x, y, blokas4))
  204.                     indeksas = 4;
  205.                 else
  206.                     indeksas = 5;
  207.             }
  208.  
  209.             if (indeksas == 0)
  210.                 return BlokoNuliuTikrinimas(sudoku, blokas0);
  211.             else if (indeksas == 1)
  212.                 return BlokoNuliuTikrinimas(sudoku, blokas1);
  213.             else if (indeksas == 2)
  214.                 return BlokoNuliuTikrinimas(sudoku, blokas2);
  215.             else if (indeksas == 3)
  216.                 return BlokoNuliuTikrinimas(sudoku, blokas3);
  217.             else if (indeksas == 4)
  218.                 return BlokoNuliuTikrinimas(sudoku, blokas4);
  219.             else
  220.                 return BlokoNuliuTikrinimas(sudoku, blokas5);
  221.         }
  222.  
  223.         // Metodas, identifikuojantis tuščią langelį bloke
  224.         static bool BlokoPaieska(Sudoku sudoku, int x, int y, int[,] blokas)
  225.         {
  226.             for (int i = 0; i < 6; i++)
  227.                 if (x == blokas[i, 0] && y == blokas[i, 1])
  228.                     return true;
  229.             return false;
  230.         }
  231.  
  232.         static int BlokoNuliuTikrinimas(Sudoku sudoku, int[,] blokas)
  233.         {
  234.             int kiekis = 0;
  235.             for (int i = 0; i < 6; i++)
  236.                 if (sudoku.Langelis[blokas[i, 0], blokas[i, 1]] == 0)
  237.                     kiekis++;
  238.             return kiekis;
  239.         }
  240.  
  241.         // Metodas, randantis, kokios reikšmės trūksta bloke
  242.         static int RastiBlokoSkaiciu(Sudoku sudoku, int indeksas)
  243.         {
  244.             // skirstymas į 6 blokus, priskiriamos atitinkamos koordinatės
  245.             int[,] blokas0 = { { 0, 0 }, { 0, 1 }, { 0, 2 }, { 1, 0 }, { 1, 1 }, { 1, 2 } };
  246.             int[,] blokas1 = { { 0, 3 }, { 0, 4 }, { 0, 5 }, { 1, 3 }, { 1, 4 }, { 1, 5 } };
  247.             int[,] blokas2 = { { 2, 0 }, { 2, 1 }, { 2, 2 }, { 3, 0 }, { 3, 1 }, { 3, 2 } };
  248.             int[,] blokas3 = { { 2, 3 }, { 2, 4 }, { 2, 5 }, { 3, 3 }, { 3, 4 }, { 3, 5 } };
  249.             int[,] blokas4 = { { 4, 0 }, { 4, 1 }, { 4, 2 }, { 5, 0 }, { 5, 1 }, { 5, 2 } };
  250.             int[,] blokas5 = { { 4, 3 }, { 4, 4 }, { 4, 5 }, { 5, 3 }, { 5, 4 }, { 5, 5 } };
  251.  
  252.             if (indeksas == 0)
  253.             {
  254.                 for (int sk = 1; sk < 7; sk++)
  255.                 {
  256.                     int k;
  257.                     for (k = 0; k < 6; k++)
  258.                         if (sudoku.Langelis[blokas0[k, 0], blokas0[k, 1]] == sk)
  259.                             break;
  260.                     if (k == 6)
  261.                         return sk;
  262.                 }
  263.             }
  264.             else if (indeksas == 1)
  265.             {
  266.                 for (int sk = 1; sk < 7; sk++)
  267.                 {
  268.                     int k;
  269.                     for (k = 0; k < 6; k++)
  270.                         if (sudoku.Langelis[blokas1[k, 0], blokas1[k, 1]] == sk)
  271.                             break;
  272.                     if (k == 6)
  273.                         return sk;
  274.                 }
  275.             }
  276.             else if (indeksas == 2)
  277.             {
  278.                 for (int sk = 1; sk < 7; sk++)
  279.                 {
  280.                     int k;
  281.                     for (k = 0; k < 6; k++)
  282.                         if (sudoku.Langelis[blokas2[k, 0], blokas2[k, 1]] == sk)
  283.                             break;
  284.                     if (k == 6)
  285.                         return sk;
  286.                 }
  287.             }
  288.             else if (indeksas == 3)
  289.             {
  290.                 for (int sk = 1; sk < 7; sk++)
  291.                 {
  292.                     int k;
  293.                     for (k = 0; k < 6; k++)
  294.                         if (sudoku.Langelis[blokas3[k, 0], blokas3[k, 1]] == sk)
  295.                             break;
  296.                     if (k == 6)
  297.                         return sk;
  298.                 }
  299.             }
  300.             else if (indeksas == 4)
  301.             {
  302.                 for (int sk = 1; sk < 7; sk++)
  303.                 {
  304.                     int k;
  305.                     for (k = 0; k < 6; k++)
  306.                         if (sudoku.Langelis[blokas4[k, 0], blokas4[k, 1]] == sk)
  307.                             break;
  308.                     if (k == 6)
  309.                         return sk;
  310.                 }
  311.             }
  312.             else
  313.             {
  314.                 for (int sk = 1; sk < 7; sk++)
  315.                 {
  316.                     int k;
  317.                     for (k = 0; k < 6; k++)
  318.                         if (sudoku.Langelis[blokas5[k, 0], blokas5[k, 1]] == sk)
  319.                             break;
  320.                     if (k == 6)
  321.                         return sk;
  322.                 }
  323.             }
  324.             return 0;
  325.         }
  326.  
  327.            
  328.     }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!