Modèle Observateur Appliqués: La Résolution De Sudoku, Plus Facile

[Contactez-nous au 06.16.19.45.84]

Total distance 0 km
Total time 0 h 0 m
Choose a vehicle

    Extra options

    • Child Seat $5.00 Baby car seat for children aged 0-36 months
    • Bouquet of Flowers $75.00 A bouquet of seasonal flowers prepared by a local florist
    • Vodka Bottle $39.00 Absolut Vodka 0.7l Bottle
    • French Champagne $110.70 French Champagne Brut 0.75l Bottle
    • Alcohol Package $145.90 1 x 0.7l Jack Daniel's Whiskey, 2 x 0.7l Vodka, 2 x 0.75l Sparkling Wine, 2l Orange Juice, 2l Coca-Cola, 2l Sprite, Ice, Glasses, Cups
    • Airport Assistance and Hostess Service $170.00 One of our hostesses will accompany you throughout your stay at the airport until the departure of your aircraft
    • Bodyguard Service $750.00 Skilled, professional bodyguard for private and executive VIP protection will accompany you throughout the trip and stops
    Choose ride details Enter contact details

    Choose payment method

    Choose a vehicle Booking summary
    Enter contact details Book now

    Thank you for your order

    Back to home

    You will be redirected to the payment page within 5 second.

    Pay via Stripe

    Pay for order


    – Nous résoudre Sudoku en suivant certaines routines dans notre esprit. Nous ne pouvons donc appliquer poignée de modèles pour résoudre chacun de ces routines. Je prends juste un de ces modèles assez bon pour résoudre les plus faciles et se plonger dans le détail. Nous le savons tous, nous sera donné un Sudoku 9×9 tableau avec quelques cellules remplies avec les valeurs de 1 à 9. Le placement et les valeurs de nombres garantit une solution unique. Le puzzle est résolu en plaçant les valeurs appropriées dans les autres cellules telles que les numéros ne sont pas répétée verticalement, horizontalement ou dans les 9 mineur 3×3 tableaux.

    La Routine de suivi

    Pour commencer, chaque cellule peut avoir n’importe quelle valeur entre 1 et 9 inclus, avec une probabilité égale. Lors de chacun des nombres donnés est placé dans la cellule, les cellules adjacentes (horizontalement, verticalement et dans le mineur de la matrice de) perdre l’opportunité d’avoir ce numéro. C’est le noeud du problème que nous sommes en train de discuter. Laissez'mettre en œuvre une classe pour définir une cellule qui détient toutes les entrées possibles.


    public class Cell {

    private List values ​​= new ArrayList ();

    private int row;

    private int col;

    // Add all possible entries (1 to 9) in each cell

    public Cell (int row, int col) {

    this.row = row;

    this.col = col;

    for (int n = 1; n <= 9; n ++) {

    values.add (new Integer (n));

    }

    }
    ...
    }

    En plaçant un nombre dans une cellule, réduit la liste de tableau juste que le nombre et supprimer l’entrée correspondante dans les cellules adjacentes (8 verticalement, 8 horizontalement et 4 cellules restantes dans le petit tableau). Comme nous le lieu de plusieurs numéros de la taille de la matrice de la liste dans chacune des cellules est réduite.

    Motif appliqué

    Après avoir dit la routine que nous voulons suivre afin de réduire les possibilités; Comment peut-on déclencher les cellules adjacentes, telles qu’elles répondent à la passation d’un nombre dans une cellule en particulier? La réponse est d’appliquer le pattern observer. Ici le investig sont les cellules adjacentes. Voir ci-dessous le code qui a les critères pour identifier les cellules adjacentes:


    for (int i = 0; i <9; i ++) {

    for (int j = 0; j <9; j ++) {

    boolean isSame = (i == row) && (j == col);

    boolean isSameLine = (i == row) || (j == col);

    boolean isMinor = (i / 3 == row / 3) && (j / 3 == col / 3);

    if (! isSame && (isSameLine || isMinor)) {

    // logic to add read goes here
    ...

    }

    }

    }

    Nous avons besoin de re-regarder la définition d’une cellule comme chaque cellule est observable pour les cellules adjacentes et dans le même temps, un observateur de la cellule adjacente. Reportez-vous ci-dessous redéfini les classes de la cellule. La super-classe, observable, a la mise en œuvre pour informer les cibles (ici, il fait référence à des cellules adjacentes). Méthode de mise à jour est la mise en œuvre de l’Observateur de l’interface qui est appelé à placer une valeur dans une cellule. Ici, nous voulons supprimer une entrée de la liste de tableau.


    public class Cell extends Observable implements Observer {
    ...

    // add the known value ... and notify refund

    public void setValue (int value) {
    ...

    super.notifyObservers (new Integer (value));

    }

    // Observe and remove the entry set in the observable

    public void update (Observable o, Object arg) {

    values.remove (arg)
    ...

    }
    }

    Définitions de classe

    Laissez-nous mettre en place la définition de la classe de cellules ci-dessous:

    package de mon.des apps.sudoku;

    importer java.util.Observables;

    importer java.util.Observateur;

    importer java.util.ArrayList;

    importer java.util.Liste;

    public class Cellule s’étend Observables implémente Observateur {

    privé des valeurs de la Liste = new ArrayList ();

    private boolean isSolved = false;

    private int ligne;

    private int col;

    // Ajouter toutes les entrées possibles (1 à 9) dans chaque cellule

    public de la Cellule (int row, int col) {

    c’.ligne = ligne;

    c’.col = col;

    for (int n = 1; n <= 9; n ++) {

    des valeurs.add (new Integer (n));

    }

    }

    // ajouter les cellules qui sont dans la même ligne ou la même case qu’étudier

    public synchronized void addObserver (Cellulaire [] [] les cellules) {

    for (int i = 0; i <9; i ++) {

    for (int j = 0; j <9; j ++) {

    boolean isSame = (i == ligne) && (j == col);

    boolean isSameLine = (i == ligne) || (j == col);

    boolean isSecondary = (i / 3 == row / 3) && (j / 3 == col / 3);

    if (! isSame && (isSameLine || isSecondary)) {

    super.addObserver (cellules [i] [j]);

    }

    }

    }

    }

    // ajouter de la valeur connue après la compensation et le notifier à interpréter

    public void setValue (int valeur) {

    des valeurs.clear ();

    des valeurs.add (new Integer (valeur));

    isSolved = true;

    super.setChanged ();

    super.notifyObservers (new Integer (valeur));

    }

    // Observer et de supprimer l’entrée de la valeur de l’observable

    public void update (Observable o, Object arg) {

    des valeurs.supprimer (arg);

    if (! isSolved && valeurs.size () == 1) {

    Valeur d’entier = (Integer) les valeurs.get (0);

    setValue (de la valeur.intValue ());

    }

    }

    // Une cellule est résolu si l’on n’a qu’une valeur

    public int getValue () {

    si (les valeurs.size () == 1) {

    return ((Entier) de valeurs.get (0)). intValue ();

    }

    return 0;

    }

    }

    Ci-dessous est le code pour la création d’une collection de cellule et mise en place des valeurs. Il montre également auprès d’un échantillon:


    package my.apps.sudoku;

    import java.util.Observable;
    import java.util.Observer;
    import java.util.ArrayList;
    import java.util.List;

    public class Sudoku {

    private Cell [] [] cells = new Cell [9] [9];

    public Sudoku () {

    // initialize the cell

    for (int i = 0; i <9; i ++) {

    for (int j = 0; j <9; j ++) {

    cells [i] [j] = new Cell (i, j);

    }

    }

    // add assess

    for (int i = 0; i <9; i ++) {

    for (int j = 0; j <9; j ++) {

    cells [i] [j] .addObserver (cells);

    }

    }

    }

    // set known values

    public void setup (int [] [] puzzle) {

    for (int i = 0; i <9; i ++) {

    for (int j = 0; j <9; j ++) {

    if (puzzle [i] [j]! = 0) {

    cells [i] [j] .setValue (puzzle [i] [j]);

    }

    }

    }

    }

    public int getCellValue (int i, int j) {

    return cells [i] [j] .getValue ();

    }

    public static void main (String [] args) {

    int [] [] puzzle = {

    {0, 6, 2, 3, 0, 0, 9, 0, 0},

    {0, 0, 0, 0, 8, 0, 0, 0, 7},

    {8, 0, 0, 0, 0, 5, 0, 0, 4},

    {0, 0, 5, 0, 2, 0, 0, 0, 6},

    {0, 3, 0, 9, 4, 6, 0, 5, 0},

    {4, 0, 0, 0, 5, 0, 7, 0, 0},

    {7, 0, 0, 6, 0, 0, 0, 0, 3},

    {5, 0, 0, 0, 3, 0, 0, 0, 0},

    {0, 0, 3, 0, 0, 7, 8, 9, 0}

    };

    Sudoku sudoku = new Sudoku ();

    sudoku.setup (puzzle);

    for (int i = 0; i <9; i ++) {

    for (int j = 0; j <9; j ++) {

    System.out.print (sudoku.getCellValue (i, j) + "|");

    }

    System.out.println ();

    }

    }

    Conclusion

    Nous avons discuté de la façon dont le modèle observateur distribue la logique de l’objectif plutôt que d’encombrer le code en un seul endroit. De même, vous trouverez d’autres modèles de programmation à venir à portée de main. Apprendre par l’application aux problèmes du monde réel!