Sudoku

hvboede

Mitglied
habe mich möglicherweise verfranst (bin mir unsicher, da ich seit gestern netbeans benutze und es auch daran liegen könnte das ich das nicht bedienen könnte)
Java:
* To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package sudoku;



import java.io.*;
public class Sudoku5 {
    
 static int i = 0;
 static int spalten = 0;
 static int zeilen = 0;
 static int[] vorgaenger = new int[70];
 static  int n = 0;  
 static     int a[][] = {{0,7,0,5,9,0,2,6,0},
                        {0,0,2,0,1,0,0,7,0},
                         {8,9,0,0,0,7,4,0,0},
                          {0,6,0,8,0,3,0,1,0},
                          {0,3,0,0,6,0,5,0,7},
                        {5,2,0,0,0,1,0,4,0},
                         {3,4,0,2,8,0,1,9,0},
                          {0,0,0,0,4,0,3,5,0},
                         {9,8,0,0,0,6,0,0,0}};
 
    /**
     * @param args the command line arguments
     * 
     * 
     */
 
   public static boolean spaltenregel(int zahl, int spalte) {
       boolean passt = true;
       
       for(int t=0; t<9 && passt; t++) {
           if(a[t][spalte]== zahl) passt = false;}
           if(passt) return true; else return false; }
       
   
 
   public static boolean zeilenregel(int zahl, int zeile) {
       boolean passt = true;
       
       for(int t=0; t<9 && passt; t++ ) 
           if(a[zeile][t]== zahl) passt = false;
       if(passt) return true; else return false;   
       } 
   
   public static boolean unterquadratregel(int zahl, int zeile, int spalte) {
       
       boolean passt = true;
       for(int w= zeile;w<zeile+2; w++){
           for(int z=spalte; z<spalte+2; z++) {
               if(a[w][z]== zahl) passt = false;}}
        if (passt) return true; else return false;
           }
   
  
 
    public static boolean feldfuellen(int ab) {
        
    boolean gefuellt = false;
        for(int x= ab; x<= 9 && gefuellt == false; x++) {
            if(unterquadratregel(x,zeilen,spalten) && zeilenregel(x, zeilen) && spaltenregel(x, spalten)) { a[zeilen][spalten] = x; gefuellt = true;
        }}
        if (gefuellt) return true; else return false;
            
    }
    
    public static boolean Matrixfuellen(int startzeile, int startspalte) {
     boolean boolvar1 = true; boolean boolvar2 = true;
     int y= startzeile; int g= startspalte;
        while(y!= a.length && g!=a[1].length) {
            
            while(a[y][g]!= 0) { if(y< a.length) g++; else {y++; g= 0;}
            
            
           boolvar1 = feldfuellen((a[y][g])+1);
            
            if(boolvar1) {
                        boolvar2 = Matrixfuellen(y,g);
                                while(boolvar2 == false)
                                   feldfuellen((a[y][g])+1);  
                                           Matrixfuellen(y,g); }
            if(boolvar1 ==false) return false;
            
     
                
                
                    
            }         
            
            }
    
    if(y == a.length && g==a[1].length) return true;
            else return false;  
    }
    
            
       // }
 
 
 
 
    public static void main(String[] args) {
       
      
   //   BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
      
   /*   try{
          System.out.println("Bitte Anzahl der Dimensionen eingeben");
          n = Integer.parseInt(br.readLine());
          a = new  int[n][n];
          for(int i=0; i<n; i++){
              for(int j=0; j<n; j++){
          
          System.out.println("Bitte Zahl fuer Zeile" + i + "Spalte" + j+"eingeben:");
          a[i][j] = Integer.parseInt(br.readLine());
          
              
              
          }
              }
         
             
          
      }catch(IOException ioe) {
          ioe.printStackTrace();
      }catch(NumberFormatException nfe){
          nfe.printStackTrace();
      } */
      
     Matrixfuellen(0,0);
          
          
         for(int i=0; i<n; i++){
             for(int j=0; j<n; j++){
                if(j< a[1].length) System.out.print(a[i][j]); else System.out.println(); }
         }}}


Ich hoffe jemand kann mir da weiterhelfen


mfg
 

Fu3L

Top Contributor
Dir ist schon klar, dass du nur einen dummen Post wie diesen erwarten kannst, wenn du nicht mal schreibst, was dein Problem ist, oder?
Des Weiteren ist der Code schlecht (ekelig?) formatiert. Wenn man seine Freizeit damit verbringt Code von Fremden zu lesen, erwartet man wenigstens, dass sich an die Standards gehalten wird. (Insbesondere im Spielebereich hier, da man als Fragensteller dann ja eigentlich kein blutiger Anfänger mehr ist.)
 

hvboede

Mitglied
Java:
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package sudoku;

import java.io.*;

public class Sudoku4 {

    static int i = 0;
    static int spalten = 0;
    static int zeilen = 0;
    static int[] vorgaenger = new int[70];
    static int n = 0;
    static int a[][] = {{0, 7, 0, 5, 9, 0, 2, 6, 0},
        {0, 0, 2, 0, 1, 0, 0, 7, 0},
        {8, 9, 0, 0, 0, 7, 4, 0, 0},
        {0, 6, 0, 8, 0, 3, 0, 1, 0},
        {0, 3, 0, 0, 6, 0, 5, 0, 7},
        {5, 2, 0, 0, 0, 1, 0, 4, 0},
        {3, 4, 0, 2, 8, 0, 1, 9, 0},
        {0, 0, 0, 0, 4, 0, 3, 5, 0},
        {9, 8, 0, 0, 0, 6, 0, 0, 0}};

    /**
     * @param args the command line arguments
     *
     *
     */
    public static boolean spaltenregel(int zahl, int spalte) {
        boolean passt = true;

        for (int t = 0; t < 9 && passt; t++) {
            if (a[t][spalte] == zahl) {
                passt = false;
            }
        }
        if (passt) {
            return true;
        } else {
            return false;
        }
    }

    public static boolean zeilenregel(int zahl, int zeile) {
        boolean passt = true;

        for (int t = 0; t < 9 && passt; t++) {
            if (a[zeile][t] == zahl) {
                passt = false;
            }
        }
        if (passt) {
            return true;
        } else {
            return false;
        }
    }

    public static boolean unterquadratregel(int zahl, int zeile, int spalte) {

        boolean passt = true;
        for (int w = zeile; w < zeile + 2; w++) {
            for (int z = spalte; z < spalte + 2; z++) {
                if (a[w][z] == zahl) {
                    passt = false;
                }
            }
        }
        if (passt) {
            return true;
        } else {
            return false;
        }
    }

    public static boolean feldfuellen(int ab) {

        boolean gefuellt = false;
        for (int x = ab; x <= 9 && gefuellt == false; x++) {
            if (unterquadratregel(x, zeilen, spalten) && zeilenregel(x, zeilen) && spaltenregel(x, spalten)) {
                a[zeilen][spalten] = x;
                gefuellt = true;
            }
        }
        if (gefuellt) {
            return true;
        } else {
            return false;
        }

    }

    public static boolean Matrixfuellen(int startzeile, int startspalte) {
        boolean boolvar1 = true;
        boolean boolvar2 = true;
        int y = startzeile;
        int g = startspalte;
        while (y != a.length && g != a[1].length) {

            while (a[y][g] != 0) {
                if (y < a.length) {
                    g++;
                } else {
                    y++;
                    g = 0;
                }


                boolvar1 = feldfuellen((a[y][g]) + 1);

                if (boolvar1) {
                    boolvar2 = Matrixfuellen(y, g);
                    while (boolvar2 == false) {
                        feldfuellen((a[y][g]) + 1);
                    }
                    Matrixfuellen(y, g);
                }
                if (boolvar1 == false) {
                    return false;
                }





            }

        }

        if (y == a.length && g == a[1].length) {
            return true;
        } else {
            return false;
        }
    }

    // }
    public static void main(String[] args) {


        //   BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        /*
         * try{ System.out.println("Bitte Anzahl der Dimensionen eingeben"); n =
         * Integer.parseInt(br.readLine()); a = new int[n][n]; for(int i=0; i<n;
         * i++){ for(int j=0; j<n; j++){
         *
         * System.out.println("Bitte Zahl fuer Zeile" + i + "Spalte" +
         * j+"eingeben:"); a[i][j] = Integer.parseInt(br.readLine());
         *
         *
         *
         * }
         * }
         *
         *
         *
         * }catch(IOException ioe) { ioe.printStackTrace();
         * }catch(NumberFormatException nfe){ nfe.printStackTrace(); }
         */

        Matrixfuellen(0, 0);


        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (j < a[1].length) {
                    System.out.print(a[i][j]);
                } else {
                    System.out.println();
                }
            }
        }
    }
}

Zunächst ist mein Problem glaube ich das er irgenteine alte Version ausführt, zumindest macht er immer etwas was ich schon längst auskommentiert habe.
Danke schonmal für den Tipp mit dem formatieren!


mfg
 

hvboede

Mitglied
Problem: Sudoku-Feld mit schon festen vorgegebenen Zahlen mittels backtracking lösen.

Ansatz ein leeres Feld suchen mittels Zeilen, Spalten und Unterquadratregel, Zahl ermitteln die passt

rekursiver Aufruf mit Start-feld = gerade gefülltes Feld

Wenn Problem auftritt, das ich ein neues Feld mit keiner Zahl 1-9 lösen kann liefert die Methode ein false zurück und das alte Feld wird nochmal gefüllt mit einer höheren Zahl.

Dann wieder rekursiver Aufruf.


Meine Frage: Ist die Grundidee richtig? wenn ja, an welchem Programmiertechnischen Detail könnte es hängen?
 

VfL_Freak

Top Contributor
Moin,

Problem: Sudoku-Feld mit schon festen vorgegebenen Zahlen mittels backtracking lösen.

Ansatz ein leeres Feld suchen mittels Zeilen, Spalten und Unterquadratregel, Zahl ermitteln die passt

rekursiver Aufruf mit Start-feld = gerade gefülltes Feld

Wenn Problem auftritt, das ich ein neues Feld mit keiner Zahl 1-9 lösen kann liefert die Methode ein false zurück und das alte Feld wird nochmal gefüllt mit einer höheren Zahl.

Dann wieder rekursiver Aufruf.
Soweit zu Deinem geplanten Ablauf .....


Meine Frage: Ist die Grundidee richtig? wenn ja, an welchem Programmiertechnischen Detail könnte es hängen?
und was ist ES ???:L :eek:
Ist es wirklich so schwer, zu beschreiben, was falsch läuft resp. was Du an der Stelle erwartest ???:L

Gruß
Klaus
 

hvboede

Mitglied
aktuell passiert halt absolut nichts wenn ich es starten will.... aber ich bin gerade auch nicht zuhause und kann nicht in ruhe darüber nachdenken. Ich überlege dann später nochmal und versuche eine präzisere Frage zu stellen
 

BinaryLogic

Mitglied
aktuell passiert halt absolut nichts wenn ich es starten will.... aber ich bin gerade auch nicht zuhause und kann nicht in ruhe darüber nachdenken. Ich überlege dann später nochmal und versuche eine präzisere Frage zu stellen


*hust*
Sag mir mal bitte, was bei folgenden Schleifendurchläufen passiert, unter der Voraussetzung, dass n = 0:

Code:
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (j < a[1].length) {
                    System.out.print(a[i][j]);
                } else {
                    System.out.println();
                }
            }
        }

Eventuell hast du dein Problem damit gefunden.

Grüße
BL
 

VfL_Freak

Top Contributor
Moin,

richtig ...
unter der Voraussetzung, dass Dein Code von "Gestern, 13:59" noch aktuell ist, hast Du dort zu Beginn der main-Funktion das Setzen von 'n' auskommentiert :eek: !!

[EDIT]
BTW: Deine Funktion "Matrixfuellen" gibt Dir eine bool'schen Wert zurück, den Du vlt. auch mal auswerten solltest

Gruß
Klaus
 
Zuletzt bearbeitet:

hvboede

Mitglied
konnte das Problem für "normale" Sudokus mittlerweile lösen bei größeren Instanzen bin ich mir unsicher da, man das aufgrund der Laufzeit schlecht überprüfen kann.

danke an die Helfer !
 

Ähnliche Java Themen


Oben