API tools faq
paste
Advertisement
Dar954826

Sudoku[ENG].java

Dar954826
Apr 6th, 2015
188
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 16.23 KB | None | 0 0
raw download clone embed print report
  1. import java.util.ArrayList;
  2. import java.util.Scanner;
  3. import java.util.concurrent.ThreadLocalRandom;
  4.  
  5. public class Sudoku {
  6.     public static ArrayList<Integer> create() {
  7.         int rand = 0;
  8.         ArrayList<Integer> list = new ArrayList<Integer>();
  9.         ArrayList<Integer> line1 = new ArrayList<Integer>();
  10.         ArrayList<Integer> line2 = new ArrayList<Integer>();
  11.         ArrayList<Integer> line3 = new ArrayList<Integer>();
  12.         ArrayList<Integer> line4 = new ArrayList<Integer>();
  13.         ArrayList<Integer> line5 = new ArrayList<Integer>();
  14.         ArrayList<Integer> line6 = new ArrayList<Integer>();
  15.         ArrayList<Integer> line7 = new ArrayList<Integer>();
  16.         ArrayList<Integer> line8 = new ArrayList<Integer>();
  17.         ArrayList<Integer> line9 = new ArrayList<Integer>();
  18.  
  19.         ArrayList<Integer> row1 = new ArrayList<Integer>();
  20.         ArrayList<Integer> row2 = new ArrayList<Integer>();
  21.         ArrayList<Integer> row3 = new ArrayList<Integer>();
  22.         ArrayList<Integer> row4 = new ArrayList<Integer>();
  23.         ArrayList<Integer> row5 = new ArrayList<Integer>();
  24.         ArrayList<Integer> row6 = new ArrayList<Integer>();
  25.         ArrayList<Integer> row7 = new ArrayList<Integer>();
  26.         ArrayList<Integer> row8 = new ArrayList<Integer>();
  27.         ArrayList<Integer> row9 = new ArrayList<Integer>();
  28.         line1.add(0);
  29.         line1.add(1);
  30.         line1.add(2);
  31.         line1.add(9);
  32.         line1.add(10);
  33.         line1.add(11);
  34.         line1.add(18);
  35.         line1.add(19);
  36.         line1.add(20);
  37.         line2.add(3);
  38.         line2.add(4);
  39.         line2.add(5);
  40.         line2.add(12);
  41.         line2.add(13);
  42.         line2.add(14);
  43.         line2.add(21);
  44.         line2.add(22);
  45.         line2.add(23);
  46.         line3.add(6);
  47.         line3.add(7);
  48.         line3.add(8);
  49.         line3.add(15);
  50.         line3.add(16);
  51.         line3.add(17);
  52.         line3.add(24);
  53.         line3.add(25);
  54.         line3.add(26);
  55.         line4.add(27);
  56.         line4.add(28);
  57.         line4.add(29);
  58.         line4.add(36);
  59.         line4.add(37);
  60.         line4.add(38);
  61.         line4.add(45);
  62.         line4.add(46);
  63.         line4.add(47);
  64.         line5.add(30);
  65.         line5.add(31);
  66.         line5.add(32);
  67.         line5.add(39);
  68.         line5.add(40);
  69.         line5.add(41);
  70.         line5.add(48);
  71.         line5.add(49);
  72.         line5.add(50);
  73.         line6.add(33);
  74.         line6.add(34);
  75.         line6.add(35);
  76.         line6.add(42);
  77.         line6.add(43);
  78.         line6.add(44);
  79.         line6.add(51);
  80.         line6.add(52);
  81.         line6.add(53);
  82.         line7.add(54);
  83.         line7.add(55);
  84.         line7.add(56);
  85.         line7.add(63);
  86.         line7.add(64);
  87.         line7.add(65);
  88.         line7.add(72);
  89.         line7.add(73);
  90.         line7.add(74);
  91.         line8.add(57);
  92.         line8.add(58);
  93.         line8.add(59);
  94.         line8.add(66);
  95.         line8.add(67);
  96.         line8.add(68);
  97.         line8.add(75);
  98.         line8.add(76);
  99.         line8.add(77);
  100.         line9.add(60);
  101.         line9.add(61);
  102.         line9.add(62);
  103.         line9.add(69);
  104.         line9.add(70);
  105.         line9.add(71);
  106.         line9.add(78);
  107.         line9.add(79);
  108.         line9.add(80);
  109.  
  110.         row1.add(0);
  111.         row1.add(3);
  112.         row1.add(6);
  113.         row1.add(27);
  114.         row1.add(30);
  115.         row1.add(33);
  116.         row1.add(54);
  117.         row1.add(57);
  118.         row1.add(60);
  119.         row2.add(1);
  120.         row2.add(4);
  121.         row2.add(7);
  122.         row2.add(28);
  123.         row2.add(31);
  124.         row2.add(34);
  125.         row2.add(55);
  126.         row2.add(58);
  127.         row2.add(61);
  128.         row3.add(2);
  129.         row3.add(5);
  130.         row3.add(8);
  131.         row3.add(29);
  132.         row3.add(32);
  133.         row3.add(35);
  134.         row3.add(56);
  135.         row3.add(59);
  136.         row3.add(32);
  137.         row4.add(9);
  138.         row4.add(12);
  139.         row4.add(15);
  140.         row4.add(36);
  141.         row4.add(39);
  142.         row4.add(42);
  143.         row4.add(63);
  144.         row4.add(66);
  145.         row4.add(69);
  146.         row5.add(10);
  147.         row5.add(13);
  148.         row5.add(16);
  149.         row5.add(37);
  150.         row5.add(40);
  151.         row5.add(43);
  152.         row5.add(64);
  153.         row5.add(67);
  154.         row5.add(70);
  155.         row6.add(11);
  156.         row6.add(14);
  157.         row6.add(17);
  158.         row6.add(38);
  159.         row6.add(41);
  160.         row6.add(44);
  161.         row6.add(65);
  162.         row6.add(68);
  163.         row6.add(71);
  164.         row7.add(18);
  165.         row7.add(21);
  166.         row7.add(24);
  167.         row7.add(45);
  168.         row7.add(48);
  169.         row7.add(51);
  170.         row7.add(72);
  171.         row7.add(75);
  172.         row7.add(78);
  173.         row8.add(19);
  174.         row8.add(22);
  175.         row8.add(25);
  176.         row8.add(46);
  177.         row8.add(49);
  178.         row8.add(52);
  179.         row8.add(73);
  180.         row8.add(76);
  181.         row8.add(79);
  182.         row9.add(20);
  183.         row9.add(23);
  184.         row9.add(26);
  185.         row9.add(47);
  186.         row9.add(50);
  187.         row9.add(53);
  188.         row9.add(74);
  189.         row9.add(77);
  190.         row9.add(80);
  191.         ArrayList<Integer> generable = new ArrayList<Integer>();
  192.         boolean next = false;
  193.  
  194.         int n = 0;
  195.         ArrayList<Integer> used = new ArrayList<Integer>();
  196.         while (true) {
  197.             n = 0;
  198.             list.clear();
  199.             for (int o = 0; o < 81; o++) {
  200.                 list.add(0);
  201.             }
  202.             try {
  203.                 for (int j = 0; j < 9; j++) {
  204.                     generable.clear();
  205.                     for (int ak = 0; ak < 81; ak++) {
  206.                         if (list.get(ak) == 0) {
  207.                             generable.add(ak);
  208.                         }
  209.                     }
  210.                     // System.out.println("ok2");
  211.                     used.clear();
  212.  
  213.                     n++;
  214.                     for (int g = 0; g < 9; g++) {
  215.  
  216.                         for (int jj = 0; jj < 100; jj++) {
  217.  
  218.                             rand = ThreadLocalRandom.current().nextInt(0,
  219.                                     generable.size());
  220.                             rand = generable.get(rand);
  221.  
  222.                             if (list.get(rand) == 0 && !used.contains(rand)) {
  223.                                 list.set(rand, n);
  224.                                 generable.remove(generable.indexOf(rand));
  225.                                 break;
  226.                             }
  227.                         }
  228.                         if (line1.contains(rand)) {
  229.                             int op = 0;
  230.                             try {
  231.                                 while (true) {
  232.                                     used.add(line1.get(op));
  233.                                     if (generable.contains(line1.get(op))) {
  234.                                         generable.remove(generable
  235.                                                 .indexOf(line1.get(op)));
  236.                                     }
  237.                                     op++;
  238.                                 }
  239.                             } catch (Exception e) {
  240.                             }
  241.  
  242.                         }
  243.                         if (line2.contains(rand)) {
  244.                             int op = 0;
  245.                             try {
  246.                                 while (true) {
  247.                                     used.add(line2.get(op));
  248.                                     if (generable.contains(line2.get(op))) {
  249.                                         generable.remove(generable
  250.                                                 .indexOf(line2.get(op)));
  251.                                     }
  252.                                     op++;
  253.                                 }
  254.                             } catch (Exception e) {
  255.                             }
  256.                         }
  257.                         if (line3.contains(rand)) {
  258.                             int op = 0;
  259.                             try {
  260.                                 while (true) {
  261.                                     used.add(line3.get(op));
  262.                                     if (generable.contains(line3.get(op))) {
  263.                                         generable.remove(generable
  264.                                                 .indexOf(line3.get(op)));
  265.                                     }
  266.                                     op++;
  267.                                 }
  268.                             } catch (Exception e) {
  269.                             }
  270.                         }
  271.                         if (line4.contains(rand)) {
  272.                             int op = 0;
  273.                             try {
  274.                                 while (true) {
  275.                                     used.add(line4.get(op));
  276.                                     if (generable.contains(line4.get(op))) {
  277.                                         generable.remove(generable
  278.                                                 .indexOf(line4.get(op)));
  279.                                     }
  280.                                     op++;
  281.                                 }
  282.                             } catch (Exception e) {
  283.                             }
  284.                         }
  285.                         if (line5.contains(rand)) {
  286.                             int op = 0;
  287.                             try {
  288.                                 while (true) {
  289.                                     used.add(line5.get(op));
  290.                                     if (generable.contains(line5.get(op))) {
  291.                                         generable.remove(generable
  292.                                                 .indexOf(line5.get(op)));
  293.                                     }
  294.                                     op++;
  295.                                 }
  296.                             } catch (Exception e) {
  297.                             }
  298.                         }
  299.                         if (line6.contains(rand)) {
  300.                             int op = 0;
  301.                             try {
  302.                                 while (true) {
  303.                                     used.add(line6.get(op));
  304.                                     if (generable.contains(line6.get(op))) {
  305.                                         generable.remove(generable
  306.                                                 .indexOf(line6.get(op)));
  307.                                     }
  308.                                     op++;
  309.                                 }
  310.                             } catch (Exception e) {
  311.                             }
  312.                         }
  313.                         if (line7.contains(rand)) {
  314.                             int op = 0;
  315.                             try {
  316.                                 while (true) {
  317.                                     used.add(line7.get(op));
  318.                                     if (generable.contains(line7.get(op))) {
  319.                                         generable.remove(generable
  320.                                                 .indexOf(line7.get(op)));
  321.                                     }
  322.                                     op++;
  323.                                 }
  324.                             } catch (Exception e) {
  325.                             }
  326.                         }
  327.                         if (line8.contains(rand)) {
  328.                             int op = 0;
  329.                             try {
  330.                                 while (true) {
  331.                                     used.add(line8.get(op));
  332.                                     if (generable.contains(line8.get(op))) {
  333.                                         generable.remove(generable
  334.                                                 .indexOf(line8.get(op)));
  335.                                     }
  336.                                     op++;
  337.                                 }
  338.                             } catch (Exception e) {
  339.                             }
  340.                         }
  341.                         if (line9.contains(rand)) {
  342.                             int op = 0;
  343.                             try {
  344.                                 while (true) {
  345.                                     used.add(line9.get(op));
  346.                                     if (generable.contains(line9.get(op))) {
  347.                                         generable.remove(generable
  348.                                                 .indexOf(line9.get(op)));
  349.                                     }
  350.                                     op++;
  351.                                 }
  352.                             } catch (Exception e) {
  353.                             }
  354.                         }
  355.                         if (row1.contains(rand)) {
  356.                             int op = 0;
  357.                             try {
  358.                                 while (true) {
  359.                                     used.add(row1.get(op));
  360.                                     if (generable.contains(row1.get(op))) {
  361.                                         generable.remove(generable.indexOf(row1
  362.                                                 .get(op)));
  363.                                     }
  364.                                     op++;
  365.                                 }
  366.                             } catch (Exception e) {
  367.                             }
  368.                         }
  369.                         if (row2.contains(rand)) {
  370.                             int op = 0;
  371.                             try {
  372.                                 while (true) {
  373.                                     used.add(row2.get(op));
  374.                                     if (generable.contains(row2.get(op))) {
  375.                                         generable.remove(generable.indexOf(row2
  376.                                                 .get(op)));
  377.                                     }
  378.                                     op++;
  379.                                 }
  380.                             } catch (Exception e) {
  381.                             }
  382.                         }
  383.                         if (row3.contains(rand)) {
  384.                             int op = 0;
  385.                             try {
  386.                                 while (true) {
  387.                                     used.add(row3.get(op));
  388.                                     if (generable.contains(row3.get(op))) {
  389.                                         generable.remove(generable.indexOf(row3
  390.                                                 .get(op)));
  391.                                     }
  392.                                     op++;
  393.                                 }
  394.                             } catch (Exception e) {
  395.                             }
  396.                         }
  397.                         if (row4.contains(rand)) {
  398.                             int op = 0;
  399.                             try {
  400.                                 while (true) {
  401.                                     used.add(row4.get(op));
  402.                                     if (generable.contains(row4.get(op))) {
  403.                                         generable.remove(generable.indexOf(row4
  404.                                                 .get(op)));
  405.                                     }
  406.                                     op++;
  407.                                 }
  408.                             } catch (Exception e) {
  409.                             }
  410.                         }
  411.                         if (row5.contains(rand)) {
  412.                             int op = 0;
  413.                             try {
  414.                                 while (true) {
  415.                                     used.add(row5.get(op));
  416.                                     if (generable.contains(row5.get(op))) {
  417.                                         generable.remove(generable.indexOf(row5
  418.                                                 .get(op)));
  419.                                     }
  420.                                     op++;
  421.                                 }
  422.                             } catch (Exception e) {
  423.                             }
  424.                         }
  425.                         if (row6.contains(rand)) {
  426.                             int op = 0;
  427.                             try {
  428.                                 while (true) {
  429.                                     used.add(row6.get(op));
  430.                                     if (generable.contains(row6.get(op))) {
  431.                                         generable.remove(generable.indexOf(row6
  432.                                                 .get(op)));
  433.                                     }
  434.                                     op++;
  435.                                 }
  436.                             } catch (Exception e) {
  437.                             }
  438.                         }
  439.                         if (row7.contains(rand)) {
  440.                             int op = 0;
  441.                             try {
  442.                                 while (true) {
  443.                                     used.add(row7.get(op));
  444.                                     if (generable.contains(row7.get(op))) {
  445.                                         generable.remove(generable.indexOf(row7
  446.                                                 .get(op)));
  447.                                     }
  448.                                     op++;
  449.                                 }
  450.                             } catch (Exception e) {
  451.                             }
  452.                         }
  453.                         if (row8.contains(rand)) {
  454.                             int op = 0;
  455.                             try {
  456.                                 while (true) {
  457.                                     used.add(row8.get(op));
  458.                                     if (generable.contains(row8.get(op))) {
  459.                                         generable.remove(generable.indexOf(row8
  460.                                                 .get(op)));
  461.                                     }
  462.                                     op++;
  463.                                 }
  464.                             } catch (Exception e) {
  465.                             }
  466.                         }
  467.                         if (row9.contains(rand)) {
  468.                             int op = 0;
  469.                             try {
  470.                                 while (true) {
  471.                                     used.add(row9.get(op));
  472.                                     if (generable.contains(row9.get(op))) {
  473.                                         generable.remove(generable.indexOf(row9
  474.                                                 .get(op)));
  475.                                     }
  476.                                     op++;
  477.                                 }
  478.                             } catch (Exception e) {
  479.                             }
  480.                         }
  481.                         if (rand >= 0 && rand <= 8) {
  482.                             for (int a = 0; a <= 8; a++) {
  483.                                 used.add(a);
  484.                             }
  485.                         }
  486.                         if (rand >= 9 && rand <= 17) {
  487.                             for (int a = 9; a <= 17; a++) {
  488.                                 used.add(a);
  489.                             }
  490.                         }
  491.                         if (rand >= 18 && rand <= 26) {
  492.                             for (int a = 18; a <= 26; a++) {
  493.                                 used.add(a);
  494.                             }
  495.                         }
  496.                         if (rand >= 27 && rand <= 35) {
  497.                             for (int a = 27; a <= 35; a++) {
  498.                                 used.add(a);
  499.                             }
  500.                         }
  501.                         if (rand >= 36 && rand <= 44) {
  502.                             for (int a = 36; a <= 44; a++) {
  503.                                 used.add(a);
  504.                             }
  505.                         }
  506.                         if (rand >= 45 && rand <= 53) {
  507.                             for (int a = 45; a <= 53; a++) {
  508.                                 used.add(a);
  509.                             }
  510.                         }
  511.                         if (rand >= 54 && rand <= 62) {
  512.                             for (int a = 54; a <= 62; a++) {
  513.                                 used.add(a);
  514.                             }
  515.                         }
  516.                         if (rand >= 63 && rand <= 71) {
  517.                             for (int a = 63; a <= 71; a++) {
  518.                                 used.add(a);
  519.                             }
  520.                         }
  521.                         if (rand >= 72 && rand <= 80) {
  522.                             for (int a = 72; a <= 80; a++) {
  523.                                 used.add(a);
  524.                             }
  525.                         }
  526.  
  527.                     }
  528.                 }
  529.                 if (!list.contains(0)) {
  530.                     next = true;
  531.                 }
  532.             } catch (Exception e) {
  533.             }
  534.             if (next) {
  535.                 break;
  536.             }
  537.         }
  538.  
  539.         return list;
  540.     }
  541.  
  542.     public static void scheme(ArrayList<Integer> user) {
  543.         System.out.println(user.get(0) + " " + user.get(1) + " " + user.get(2)
  544.                 + "   " + user.get(9) + " " + user.get(10) + " " + user.get(11)
  545.                 + "   " + user.get(18) + " " + user.get(19) + " "
  546.                 + user.get(20) + "        00 01 02    09 10 11    18 19 20\n"
  547.                 + user.get(3) + " " + user.get(4) + " " + user.get(5) + "   "
  548.                 + user.get(12) + " " + user.get(13) + " " + user.get(14)
  549.                 + "   " + user.get(21) + " " + user.get(22) + " "
  550.                 + user.get(23) + "        03 04 05    12 13 14    21 22 23 \n"
  551.                 + user.get(6) + " " + user.get(7) + " " + user.get(8) + "   "
  552.                 + user.get(15) + " " + user.get(16) + " " + user.get(17)
  553.                 + "   " + user.get(24) + " " + user.get(25) + " "
  554.                 + user.get(26) + "        06 07 08    15 16 17    24 25 26 \n"
  555.                 + "\n" + user.get(27) + " " + user.get(28) + " " + user.get(29)
  556.                 + "   " + user.get(36) + " " + user.get(37) + " "
  557.                 + user.get(38) + "   " + user.get(45) + " " + user.get(46)
  558.                 + " " + user.get(47)
  559.                 + "        27 28 29    36 37 38    45 46 47\n" + user.get(30)
  560.                 + " " + user.get(31) + " " + user.get(32) + "   "
  561.                 + user.get(39) + " " + user.get(40) + " " + user.get(41)
  562.                 + "   " + user.get(48) + " " + user.get(49) + " "
  563.                 + user.get(50) + "        30 31 32    39 40 41    48 49 50\n"
  564.                 + user.get(33) + " " + user.get(34) + " " + user.get(35)
  565.                 + "   " + user.get(42) + " " + user.get(43) + " "
  566.                 + user.get(44) + "   " + user.get(51) + " " + user.get(52)
  567.                 + " " + user.get(53)
  568.                 + "        33 34 35    42 43 44    51 52 53 \n" + "\n"
  569.                 + user.get(54) + " " + user.get(55) + " " + user.get(56)
  570.                 + "   " + user.get(63) + " " + user.get(64) + " "
  571.                 + user.get(65) + "   " + user.get(72) + " " + user.get(73)
  572.                 + " " + user.get(74)
  573.                 + "        54 55 56    63 64 65    72 73 74\n" + user.get(57)
  574.                 + " " + user.get(58) + " " + user.get(59) + "   "
  575.                 + user.get(66) + " " + user.get(67) + " " + user.get(68)
  576.                 + "   " + user.get(75) + " " + user.get(76) + " "
  577.                 + user.get(77) + "        57 58 59    66 67 68    75 76 77 \n"
  578.                 + user.get(60) + " " + user.get(61) + " " + user.get(62)
  579.                 + "   " + user.get(69) + " " + user.get(70) + " "
  580.                 + user.get(71) + "   " + user.get(78) + " " + user.get(79)
  581.                 + " " + user.get(80)
  582.                 + "        60 61 62    69 70 71    78 79 80 \n");
  583.     }
  584.  
  585.     public static void sudoku(String[] args) {
  586.         dd = new Scanner(System.in);
  587.  
  588.         int aop, moves = 0;
  589.         while (true) {
  590.             try {
  591.                 System.out.print("Insert how many boxes show[10-70]: ");
  592.                 aop = dd.nextInt();
  593.                 if (aop > 9 && aop < 71) {
  594.                     break;
  595.                 }
  596.             } catch (Exception e) {
  597.             }
  598.         }
  599.         System.out.println("Generating scheme...");
  600.         ArrayList<Integer> truth = new ArrayList<Integer>();
  601.         truth = create();
  602.         ArrayList<Integer> user = new ArrayList<Integer>();
  603.         for (int a = 0; a < 81; a++) {
  604.             user.add(0);
  605.         }
  606.         ArrayList<Integer> modifiable = new ArrayList<Integer>();
  607.         for (int a = 0; a < 81; a++) {
  608.             modifiable.add(a);
  609.         }
  610.         for (int i = 0; i <= aop; i++) {
  611.             int rand = ThreadLocalRandom.current()
  612.                     .nextInt(0, modifiable.size());
  613.             user.set(modifiable.get(rand), truth.get(modifiable.get(rand)));
  614.             modifiable.remove(rand);
  615.         }
  616.  
  617.         scheme(user);
  618.         while (!user.equals(truth)) {
  619.             while (true) {
  620.                 try {
  621.                     System.out.print("\nInsert where change: ");
  622.                     int a=dd.nextInt();
  623.                     if (a >= 0 && a < 81) {
  624.                         if (modifiable.contains(a)) {
  625.                             System.out
  626.                                     .print("Insert with what number change: ");
  627.                             int b = dd.nextInt();
  628.                             if (b >= 0 && b < 10) {
  629.                                 user.set(a, b);
  630.                                 break;
  631.                             }
  632.                         } else {
  633.                             System.out
  634.                                     .println("Number automatically generated.");
  635.                         }
  636.                     }
  637.                 } catch (Exception e) {
  638.                 }
  639.             }
  640.             scheme(user);
  641.             moves++;
  642.         }
  643.         System.out.println("You won in " + moves + " moves!");
  644.         System.out.print("ENTER to restart.");
  645.         dd.nextLine();
  646.         dd.nextLine();
  647.  
  648.     }
  649.  
  650.     private static Scanner dd;
  651.  
  652.     public static void main(String[] args) {
  653.  
  654.         while (true) {
  655.             sudoku(args);
  656.             for (int a = 0; a < 1000; a++) {
  657.                 System.out.println();
  658.             }
  659.         }
  660.  
  661.     }
  662.  
  663. }
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!