Posted by audun Wed 7th Mar 2007 20:06 - Syntax is JavaScript - 59 views
Download | New Post | Modify | Hide line numbers
  1. //
  2. //  Sudoku.java
  3. // 
  4. //
  5. //  Created by Audun Ask Blaker on 26.02.07.
  6. //  Copyright 2007 Audun Ask Blaker. All rights reserved.
  7. //
  8.  
  9. import easyIO.*;
  10. import java.util.*;
  11.  
  12. /********************************************
  13. *        ** Class Sudoku/ Main **           *
  14. ********************************************/
  15. public class Sudoku {
  16.     public static void main(String[] args) {
  17.        
  18.         System.out.println("**_* SuDoKu *_** \n");
  19.         String fnavn = "";
  20.        
  21.         // Sjekker om vi har fÂtt med et filnavn fra terminal/bruker / pr¯ver  sette fnavn lik dette.
  22.         try {
  23.                 fnavn = args[0];
  24.             }
  25.            
  26.             // Hvis vi fÂr en outofboundsexeption vil denne bli fanget opp og erstattet med en eminent Feilmelding.
  27.         catch (ArrayIndexOutOfBoundsException e) {
  28.             System.out.println("FEIL: Du m taste inn et filnavn. " + "f.eks: java Sudoku sudokuoppgave3.txt");
  29.         } // Slutt catch
  30.        
  31.         if (!fnavn.contains(".txt")) {
  32.           System.out.println("Nei nei nei... du m nok bruke en .txt fil gitt.");
  33.         } else {
  34.           Kontroll ktrl = new Kontroll();
  35.           ktrl.gogo(fnavn);
  36.         }
  37.        
  38.     } // Slutt main
  39. } // Slutt Sudoku
  40.  
  41. /*********************************************
  42. *            ** Utsyn/ View **               *
  43. **********************************************/
  44. class Utsyn {
  45.     Out skjerm;
  46.    
  47.     // Konstrukt¯r til Utsyn
  48.     Utsyn() {
  49.         skjerm = new Out();
  50.     } // Slutt utsyn
  51.    
  52.     // Utskriftsmetode
  53.     void skriv(String tilskjerm) {
  54.         System.out.print(tilskjerm);
  55.     } // Slutt skriv
  56.    
  57.     void skriv(int tall) {
  58.         System.out.print(tall);
  59.         System.out.print(" ");
  60.     }
  61.    
  62.     void skriv(char abc) {
  63.         System.out.print(abc);
  64.         System.out.print(" ");
  65.     }
  66. } // Slutt class Utsyn
  67.  
  68.  
  69.  
  70. /*********************************************
  71. *            ** Kontroll **                  *
  72. **********************************************/
  73. class Kontroll {
  74.     Utsyn utsynet;
  75.     In tast;
  76.     Brett brett;
  77.     int[][] ruter;
  78.    
  79.     Kontroll() {
  80.         utsynet = new Utsyn();
  81.         tast = new In();
  82.     } // Slutt Kontroll()
  83.    
  84.     // F¯rste skritt mot  l¯se oppgaven. Innlesning og klargj¯ring. Oppretter rutenettverket og lager et brett av det.
  85.     // for s  starte det rekursive kallet i den f¯rste ruta (rute).
  86.     void gogo(String fnavn) {
  87.         In innfil = new In(fnavn);
  88.        
  89.         int kvdr = innfil.inInt();
  90.         int boksRad = innfil.inInt();
  91.         int boksKol = innfil.inInt();
  92.         innfil.skipWhite();
  93.        
  94.         int[][] ruter = new int[kvdr][kvdr];
  95.        
  96.         String sjekk = "Filnavn: " + fnavn + "\nBrettst¯rrelse: " + kvdr +
  97.         "\nRader pr. boks: " + boksRad + "\nKolonner pr. boks: " + boksKol + "\n\nBrettet ser slik ut : \n";
  98.         utsynet.skriv(sjekk);
  99.        
  100.         for(int i = 0; i < kvdr; i++) {
  101.             for(int j = 0; j < kvdr; j++) {
  102.                
  103.                 char rute = innfil.inChar();
  104.                 int verdi = (int) rute;
  105.                 innfil.skipWhite();
  106.                
  107.                 if(verdi == 46) {                            // Hvis verdien er ./0
  108.                     ruter[i][j] = 0;
  109.                     utsynet.skriv(ruter[i][j]);
  110.                 } else if (verdi >= 49 && verdi <= 57) {    // Hvis verdien er 0-9
  111.                     ruter[i][j] = (verdi - 48);
  112.                     utsynet.skriv(ruter[i][j]);
  113.                 } else if (verdi >= 65 && verdi <= 91) {    // Hvis verdien er 10-36
  114.                     ruter[i][j] = (verdi - 55);
  115.                     utsynet.skriv(ruter[i][j]);
  116.                 }
  117.             } utsynet.skriv("\n"); // Linjeskift // Slutt f¯rste for
  118.         } utsynet.skriv("\n"); // Linjeskift // Slutt andre for
  119.        
  120.         // Etter  ha lest inn og satt riktige verdier opprettes ett brett med de innleste verdiene
  121.         brett = new Brett(kvdr, boksRad, boksKol, ruter);
  122.        
  123.         // SÂ settes den rekursive metoden i gang i rute (0,0) (¯verst til venstre)
  124.         Rute rut = brett.getRute(0,0);
  125.         rut.pr0vAlleSifferMegOgResten(0,0);
  126.        
  127.     } // Slutt gogo()
  128. } // Slutt
  129.  
  130. /********************************
  131. *           Brett               *
  132. * Skal holde p all informasjon *
  133. * om det innleste brettet       *
  134. ********************************/
  135. class Brett {
  136.     int kvdr; // St¯rrelsen p brettet
  137.     int boksRad; // Antall rader pr boks
  138.     int boksKol; // Antall kolonner pr boks
  139.     Rute[][] alleRuter; // 2d array som holder p alle rute-objektene i et Brett
  140.     SuperKlasse[] kolonner; //array som holder p alle kolonne-objektene
  141.     SuperKlasse[] rader; // array som holder p alle rad-objektene
  142.     SuperKlasse[] bokser; // array som holder p alle boks-objektene
  143.     Utsyn utsynet = new Utsyn();;
  144.     int antallL0sninger = 0;
  145.    
  146.     Brett(int kvdr, int boksRad, int boksKol, int[][] ruter) {
  147.         this.kvdr = kvdr;
  148.         this.boksRad = boksRad;
  149.         this.boksKol = boksKol;
  150.         alleRuter = new Rute[kvdr][kvdr];
  151.         kolonner = new Kolonne[kvdr];
  152.         rader = new Rad[kvdr];
  153.         bokser = new Boks[kvdr];
  154.        
  155.        
  156.         // Jobber seg gjennom brettet og lager arrayer for kolonner, rader og bokser
  157.         for(int i = 0; i < kvdr; i++) {
  158.             kolonner[i] = new Kolonne(i, kvdr);
  159.             rader[i] = new Rad(i, kvdr);
  160.             bokser[i] = new Boks(i, kvdr);
  161.         }
  162.        
  163.         int nr = 0;
  164.        
  165.         for(int i = 0; i < kvdr; i++) {
  166.             for(int j = 0; j < kvdr; j++) {
  167.                
  168.                 // Regnestykke som gj¯r at vi finner hvilken boks en rute ligger i, gitt
  169.                 // st¯rrelse p brettet, antall rader og kolonner og hvilket nummer ruten er i
  170.                 // rekkef¯lgen p brettet
  171.                 int a = ((nr/(boksRad * kvdr)) * boksRad);
  172.                 int c = (nr / kvdr);
  173.                 int d = (nr - (c * kvdr));
  174.                 int boks = (d / boksKol) + a;
  175.                
  176.                 alleRuter[i][j] = new Rute(ruter[i][j], i, j, boks, nr, kvdr);
  177.                
  178.                 kolonner[j].leggTilRute(alleRuter[i][j]);
  179.                 rader[i].leggTilRute(alleRuter[i][j]);
  180.                 bokser[boks].leggTilRute(alleRuter[i][j]);
  181.                
  182.                 nr++;
  183.             } // Slutt f¯rste for
  184.         } // Slutt andre for
  185.        
  186.         alleRuter[0][0].settBrett(this);
  187.        
  188.     } // Slutt konstrukt¯r
  189.    
  190.     Rute getRute(int rad, int kol) {
  191.         return alleRuter[rad][kol];
  192.     }
  193.    
  194.     void skrivBrett() {
  195.         antallL0sninger++;
  196.        
  197.         utsynet.skriv("L¯sning nr: " + antallL0sninger + "\n");
  198.        
  199.         for(int i = 0; i < kvdr; i++) {
  200.             for(int j = 0; j < kvdr; j++) {
  201.                 int tall = alleRuter[i][j].getVerdi();
  202.                
  203.                 if(tall < 10) {
  204.                     utsynet.skriv(tall);
  205.                 } else {
  206.                     tall = tall + 55;
  207.                     char abc = (char) tall;
  208.                     utsynet.skriv(abc);
  209.                 }
  210.             } utsynet.skriv("\n");
  211.         } utsynet.skriv("\n");
  212.     }
  213. }
  214.  
  215.  
  216.  
  217. /********************************
  218. *           RUTE                *
  219. * Skal holde p all informasjon *
  220. * for hver enkelt rute          *
  221. ********************************/
  222. class Rute {
  223.    
  224.     int verdi;
  225.     int rad;
  226.     int kol;
  227.     int nummer;
  228.     int boks;
  229.     int kvdr;
  230.    
  231.     static Brett brett;
  232.    
  233.     // Konstrukt¯r
  234.     Rute(int verdi, int rad, int kol, int boks, int nummer, int kvdr) {
  235.        
  236.         this.verdi = verdi;
  237.         this.rad = rad;
  238.         this.kol = kol;
  239.         this.nummer = nummer;
  240.         this.boks = boks;
  241.         this.kvdr = kvdr;
  242.     } // Slutt konstrukt¯r
  243.    
  244.     int getVerdi() {
  245.         return verdi;
  246.     }
  247.    
  248.     int getNummer() {
  249.         return nummer;
  250.     }
  251.    
  252.     void setVerdi(int n) {
  253.         verdi = n;
  254.     }
  255.    
  256.     // Mottar en peker til et brett-objekt, og setter pekeren brett til  peke p det. angir rutens tilh¯righet
  257.     void settBrett(Brett b) {
  258.         brett = b;
  259.     }
  260.    
  261.     void pr0vAlleSifferMegOgResten(int x, int y) {
  262.         boolean ferdig = false;
  263.         // GÂr ett skritt til h¯yre
  264.         y++;
  265.        
  266.         // Hvis vi har kommet til h¯yresiden av brettet
  267.         if(y == kvdr) {
  268.             y = 0; // S skal vi begynne p venstresiden igjen
  269.             x++; // men n skal vi ned en kolonne
  270.            
  271.             // Hvis vi er kommet til bunn av brettet
  272.             if (x == kvdr) {
  273.                 // Så er vi endelig ferdig :)
  274.                 ferdig = true;
  275.             }
  276.         }
  277.        
  278.         if(verdi == 0) { // I dette tilfellet har vi en tom rute, som da trenger en ny verdi.
  279.             for(int i = 1; i <= kvdr; i++) { // Vi pr¯ver da med verdier f.o.m 1 - t.o.m st¯rrelsen p brettet
  280.                
  281.                 if (!brett.bokser[boks].finnesFraF0r(i) && // Hvis verdien ikke finnes fra f¯r i den aktuelle boksen
  282.                     !brett.kolonner[kol].finnesFraF0r(i) && // - .. - kolonna
  283.                     !brett.rader[rad].finnesFraF0r(i)) { // -- .. -- raden
  284.                    
  285.                     setVerdi(i); // SÂ skal rutas verdi settes til den verdien vi snakker om (i for l¯kka)
  286.                    
  287.                     if(ferdig) {
  288.                         brett.skrivBrett();
  289.                         ferdig = false;
  290.                     } else {
  291.                         brett.getRute(x, y).pr0vAlleSifferMegOgResten(x, y);
  292.                     }
  293.                 }
  294.             }
  295.            
  296.             setVerdi(0); // For at den rekursive metoden skal virke, m vi sette verdien p ruta til null igjen
  297.                          // fordi at hvis "en vei" ikke gÂr greit, s m vi kunne endre verdien p ruta. Og det kan
  298.                          // vi bare hvis verdien er null. (if(verdi == 0)).
  299.            
  300.         } else {
  301.            
  302.             if(ferdig) {   
  303.                 brett.skrivBrett();
  304.                 ferdig = false;
  305.             } else {
  306.                 brett.getRute(x, y).pr0vAlleSifferMegOgResten(x, y);
  307.             }
  308.         }
  309.     }
  310. }
  311.  
  312.  
  313.  
  314. /*****************************
  315. *      SUPERKLASSEN          *
  316. * Inneholder alle variabler  *
  317. * de tre subklassene         *
  318. * Rad, Kolonne og Boks deler *
  319. *****************************/
  320.  
  321. class SuperKlasse {
  322.     int nr;
  323.     int str;
  324.     HashMap ruter;
  325.    
  326.     //Konstruktør
  327.     SuperKlasse(int nr, int str) {
  328.         this.nr = nr;
  329.         this.str = str;
  330.         ruter = new HashMap ();
  331.     } // Slutt konstruktør
  332.    
  333.     void leggTilRute(Rute r) {
  334.         String nummer = r.getNummer() + "";
  335.         ruter.put(nummer, r);
  336.     }
  337.    
  338.     boolean finnesFraF0r(int verdi) {
  339.         boolean finnes = false;
  340.        
  341.         for(Rute r: ruter.values()) {
  342.             if(r.getVerdi() == verdi) {
  343.                 finnes = true;
  344.             }
  345.         }
  346.         return finnes;
  347.     }
  348. } // end class Brett
  349.  
  350. //Klassen boks er bare en kopi av klassen SuperKlasse
  351. class Boks extends SuperKlasse {
  352.    
  353.     Boks(int nr, int kvdr) {
  354.         super(nr, kvdr);
  355.     }
  356. } // End class Boks
  357.  
  358. //Klassen Rad er bare en kopi av klassen Superklasse
  359. class Rad extends SuperKlasse {
  360.    
  361.     Rad(int nr, int kvdr) {
  362.         super(nr, kvdr);
  363.     }
  364. } // End class Rad
  365.  
  366. //Klassen Rad er bare en kopi av klassen SuperKlasse
  367. class Kolonne extends SuperKlasse {
  368.    
  369.     Kolonne(int nr, int kvdr) {
  370.         super(nr, kvdr);
  371.     }
  372. }
  373.  

PermaLink to this entry https://pastebin.co.uk/11534
Posted by audun Wed 7th Mar 2007 20:06 - Syntax is JavaScript - 59 views
Download | New Post | Modify | Hide line numbers

 

Comments: 0