Sudoku

Omdat het niet altijd over mountainbike hoeft te gaan...... Zet een boompje op over alles wat NIET met mountainbike te maken heeft maar hou het wel deftig.
User avatar
Puzzle
Mountainbiker
Posts: 178
Joined: Sat 19 Aug 2006 11:15
Location: MBK Super Sprint

Post by Puzzle »

Code: Select all

// File: MuisComponent.java
// Date: 30 September 2006.
//
// Copyright (c) 2006 Cliff Huylebroeck. All Rights Reserved.
//
// Permission to use, copy, modify, and distribute this software
// and its documentation for NON-COMMERCIAL purposes and without
// fee is hereby granted provided that this copyright notice
// appears in all copies.
//
// Cliff Huylebroeck MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE
// SUITABILITY OF THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT
// NOT LIMITED TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR
// A PARTICULAR PURPOSE, OR NON-INFRINGEMENT. Cliff Huylebroeck SHALL NOT
// BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING,
// MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
 
import java.awt.Component;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.Point;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
 
public class MuisComponent extends Component implements MouseListener, MouseMotionListener
{
    private boolean isMuisInInhoud=false;
    private boolean isMuisNeer=false;
 
    public MuisComponent()
    {
        addMouseListener(this);
        addMouseMotionListener(this);
    }
 
    public void update(final Graphics g)
    {
        paint(g);
    }
 
    public void mouseClicked(final MouseEvent event)
    {
        event.consume();
        // opm: zeker niets mee doen.
        // Dit gebeurt alleen als er niet wordt bewogen.
    }
 
    public void mouseEntered(final MouseEvent event)
    {
        final Point p=event.getPoint();
        isMuisInInhoud=IsPuntInInhoud(p);
        if (isMuisNeer)
            {
            event.consume();
            repaint();
            }
    }
 
    public void mouseExited(final MouseEvent event)
    {
        event.consume();
        // opm: zeker niets mee doen.
        // Dit gebeurt:
        // 1. als we buiten gaan zonder te klikken.
        // 2. als we loslaten na buiten te gaan (is te laat).
    }
 
    public void mousePressed(final MouseEvent event)
    {
        event.consume();
        // opm: als we in de kader maar buiten de inhoud klikken dan beschouwen
        // we dat als buiten de kader klikken.
        final Point p=event.getPoint();
        isMuisNeer=BlijftPuntInInhoud(p);
        repaint();
    }
 
    public void mouseReleased(final MouseEvent event)
    {
        event.consume();
        if (!isMuisNeer)
            {
            // opm: de muis wordt over deze component losgelaten zonder dat er
            // in geklikt was.
            return;
            }
        if (isMuisInInhoud)
            {
            ReageerOpKlik();
            }
        isMuisNeer=false;
        repaint();
    }
 
    public void mouseDragged(final MouseEvent event)
    {
        if (!isMuisNeer)
            {
            // opm: de muis wordt over deze component gesleept zonder dat er
            // in geklikt was.
            return;
            }
        event.consume();
        final Point p=event.getPoint();
        isMuisInInhoud=IsPuntInInhoud(p);
        repaint();
    }
 
    public void mouseMoved(final MouseEvent event)
    {
        event.consume();
        // opm: zeker niets mee doen.
        // Als er niet geklikt is dan is dit niet relevant.
    }
 
    public boolean IsIngedrukt()
    {
        if (!isMuisInInhoud)
            {
            return false;
            }
        if (!isMuisNeer)
            {
            return false;
            }
        return true;
    }
 
    public boolean IsPuntInInhoud(final Point p)
    {
        final Dimension afmeting=getSize();
        if (p.x>afmeting.width)
            {
            return false;
            }
        if (p.y>afmeting.height)
            {
            return false;
            }
        return true;
    }
 
    public boolean BlijftPuntInInhoud(final Point p)
    {
        final Dimension afmeting=getSize();
        if (p.x<0)
            {
            return false;
            }
        if (p.x>afmeting.width)
            {
            return false;
            }
        if (p.y<0)
            {
            return false;
            }
        if (p.y>afmeting.height)
            {
            return false;
            }
        return true;
    }
 
    public void ReageerOpKlik()
    {
    }
}
User avatar
Puzzle
Mountainbiker
Posts: 178
Joined: Sat 19 Aug 2006 11:15
Location: MBK Super Sprint

Post by Puzzle »

Code: Select all

// File: RondeKnop.java
// Date: 30 September 2006.
//
// Copyright (c) 2006 Cliff Huylebroeck. All Rights Reserved.
//
// Permission to use, copy, modify, and distribute this software
// and its documentation for NON-COMMERCIAL purposes and without
// fee is hereby granted provided that this copyright notice
// appears in all copies.
//
// Cliff Huylebroeck MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE
// SUITABILITY OF THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT
// NOT LIMITED TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR
// A PARTICULAR PURPOSE, OR NON-INFRINGEMENT. Cliff Huylebroeck SHALL NOT
// BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING,
// MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
 
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.Point;
import java.awt.Rectangle;
 
public class RondeKnop extends MuisComponent
{
    private Image gewoon=null;
    private Image ingedrukt=null;
 
    public RondeKnop(final Image gewoon,
                     final Image ingedrukt)
    {
        this.gewoon=gewoon;
        this.ingedrukt=ingedrukt;
    }
 
    public void paint(final Graphics g)
    {
        if (!isShowing())
            {
            return;
            }
        final Rectangle kader=getBounds();
        final Rectangle clip=g.getClipRect();
        final Rectangle doorsnede=kader.intersection(clip);
        if (doorsnede.isEmpty())
            {
            return;
            }
        g.setClip(doorsnede);
        if (IsIngedrukt())
            {
            g.drawImage(ingedrukt,
                        kader.x,
                        kader.y,
                        this);
            }
        else
            {
            g.drawImage(gewoon,
                        kader.x,
                        kader.y,
                        this);
            }
        g.setClip(clip);
    }
 
    public boolean IsPuntInInhoud(final Point p)
    {
        final Rectangle kader=getBounds();
        final int b=kader.width-2*p.x;
        final int h=kader.height-2*p.y;
        // opm: nu liever geen vierkantswortel.
        final double kwadraatVanDeAfstand=b*b+h*h;
        return kwadraatVanDeAfstand<=kader.width*kader.width;
    }
}
User avatar
Puzzle
Mountainbiker
Posts: 178
Joined: Sat 19 Aug 2006 11:15
Location: MBK Super Sprint

Post by Puzzle »

Code: Select all

// File:      StaticLayout.java
// Copyright: © 1997, MetroWerks. All rights reserved.
 
package com.mw.pj;
 
import java.awt.Component;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.LayoutManager;
import java.lang.String;
 
public class StaticLayout implements LayoutManager
{
 
    public void addLayoutComponent(String name, 
                                   Component comp)
    {
    }
 
    public void removeLayoutComponent(Component comp)
    {
    }
 
    public Dimension preferredLayoutSize(Container parent)
    {
        return minimumLayoutSize(parent);
    }
 
    public Dimension minimumLayoutSize(Container parent)
    {
        return parent.size();
    }
 
    public void layoutContainer(Container parent)
    {
    }
}
User avatar
Puzzle
Mountainbiker
Posts: 178
Joined: Sat 19 Aug 2006 11:15
Location: MBK Super Sprint

Post by Puzzle »

Code: Select all

// File: LeegKnop.java
// Date: 30 September 2006.
//
// Copyright (c) 2006 Cliff Huylebroeck. All Rights Reserved.
//
// Permission to use, copy, modify, and distribute this software
// and its documentation for NON-COMMERCIAL purposes and without
// fee is hereby granted provided that this copyright notice
// appears in all copies.
//
// Cliff Huylebroeck MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE
// SUITABILITY OF THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT
// NOT LIMITED TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR
// A PARTICULAR PURPOSE, OR NON-INFRINGEMENT. Cliff Huylebroeck SHALL NOT
// BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING,
// MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
 
import java.awt.Image;
 
public class LeegKnop extends RondeKnop
{
    private SudokuApplet sudokuApplet=null;
 
    public LeegKnop(final SudokuApplet sudokuApplet,
                    final Image gewoon,
                    final Image ingedrukt)
    {
        super(gewoon,
              ingedrukt);
        this.sudokuApplet=sudokuApplet;
    }
 
    public void ReageerOpKlik()
    {
        sudokuApplet.Herbegin();
    }
}
User avatar
Puzzle
Mountainbiker
Posts: 178
Joined: Sat 19 Aug 2006 11:15
Location: MBK Super Sprint

Post by Puzzle »

Code: Select all

// File: OplosKnop.java
// Date: 30 September 2006.
//
// Copyright (c) 2006 Cliff Huylebroeck. All Rights Reserved.
//
// Permission to use, copy, modify, and distribute this software
// and its documentation for NON-COMMERCIAL purposes and without
// fee is hereby granted provided that this copyright notice
// appears in all copies.
//
// Cliff Huylebroeck MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE
// SUITABILITY OF THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT
// NOT LIMITED TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR
// A PARTICULAR PURPOSE, OR NON-INFRINGEMENT. Cliff Huylebroeck SHALL NOT
// BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING,
// MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
 
import java.awt.Image;
 
public class OplosKnop extends RondeKnop
{
    private SudokuApplet sudokuApplet=null;
 
    public OplosKnop(final SudokuApplet sudokuApplet,
                     final Image gewoon,
                     final Image ingedrukt)
    {
        super(gewoon,
              ingedrukt);
        this.sudokuApplet=sudokuApplet;
    }
 
    public void ReageerOpKlik()
    {
        sudokuApplet.LosOp();
    }
}
User avatar
Puzzle
Mountainbiker
Posts: 178
Joined: Sat 19 Aug 2006 11:15
Location: MBK Super Sprint

Post by Puzzle »

Code: Select all

// File: Vak.java
// Date: 30 September 2006.
//
// Copyright (c) 2006 Cliff Huylebroeck. All Rights Reserved.
//
// Permission to use, copy, modify, and distribute this software
// and its documentation for NON-COMMERCIAL purposes and without
// fee is hereby granted provided that this copyright notice
// appears in all copies.
//
// Cliff Huylebroeck MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE
// SUITABILITY OF THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT
// NOT LIMITED TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR
// A PARTICULAR PURPOSE, OR NON-INFRINGEMENT. Cliff Huylebroeck SHALL NOT
// BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING,
// MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
 
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.Rectangle;
 
public class Vak extends MuisComponent
{
    private static final Font cijferType=new Font("Helvetica",
                                                  Font.PLAIN,
                                                  9);
    static private final Color cijferKleur=Color.black;
    static private final Color achtergrondKleur=Color.white;
    static private final Color geselecteerdKleur=Color.black;
    static private final Color geprobeerdKleur=Color.red;
    static private final Color foutKleur=Color.red;
    Rooster rooster=null;
    private int rij;
    private int kolom;
    private boolean isGeselecteerd=false;
    private boolean isIngevuld=false;
    private boolean isGetypt=false;
    private boolean isFout=false;
    private int cijfer;
    private MogelijkeCijfers mogelijkeCijfers=new MogelijkeCijfers();
 
    public Vak(final Rooster rooster,
               final int rij,
               final int kolom,
               final int x,
               final int y,
               final int vakGrootte)
    {
        this.rooster=rooster;
        this.rij=rij;
        this.kolom=kolom;
        setBounds(x,
                  y,
                  vakGrootte,
                  vakGrootte);
        show(true);
        enable(true);
    }
 
    public void paint(final Graphics g)
    {
        if (!isShowing())
            {
            return;
            }
        final Rectangle kader=getBounds();
        final Rectangle clip=g.getClipRect();
        final Rectangle doorsnede=kader.intersection(clip);
        if (doorsnede.isEmpty())
            {
            return;
            }
        g.setClip(doorsnede);
        if (isFout)
            {
            g.setColor(foutKleur);
            g.drawRect(kader.x,
                       kader.y,
                       kader.width-1,
                       kader.height-1);
            }
        g.setColor(achtergrondKleur);
        Rectangle vulkader=new Rectangle(kader);
        vulkader.grow(-1,
                      -1);
        g.fillRect(vulkader.x,
                   vulkader.y,
                   vulkader.width,
                   vulkader.height);
        if (isGeselecteerd)
            {
            g.setColor(geselecteerdKleur);
            g.drawRect(vulkader.x,
                       vulkader.y,
                       vulkader.width-1,
                       vulkader.height-1);
            vulkader.grow(-1,
                          -1);
            g.drawRect(vulkader.x,
                       vulkader.y,
                       vulkader.width-1,
                       vulkader.height-1);
            }
        else if (IsIngedrukt())
            {
            g.setColor(geprobeerdKleur);
            g.drawRect(vulkader.x,
                       vulkader.y,
                       vulkader.width-1,
                       vulkader.height-1);
            }
        if (isIngevuld)
            {
            g.setFont(cijferType);
            g.setColor(cijferKleur);
            final String s=String.valueOf(cijfer);
            g.drawString(s,
                         kader.x+6,
                         kader.y+11);
            }
        g.setClip(clip);
    }
 
    public void ReageerOpKlik()
    {
        if (!isGeselecteerd)
            {
            rooster.ReageerOpSelectie(rij,
                                      kolom);
            }
    }
 
    public void MaakLeeg(final boolean ok)
    {
        if (isIngevuld)
            {
            if (!isGetypt)
                {
                isIngevuld=false;
                }
            else if (ok)
                {
                isIngevuld=false;
                }
            }
        isFout=!ok;
        mogelijkeCijfers.MaakLeeg();
        invalidate();
    }
 
    public void MaakOK()
    {
        isFout=false;
    }
 
    public boolean IsLeeg()
    {
        return !isIngevuld;
    }
 
    public int GeefCijfer()
    {
        return cijfer;
    }
 
    public void Selecteer()
    {
        isGeselecteerd=true;
        repaint();
    }
 
    public void Deselecteer()
    {
        isGeselecteerd=false;
        repaint();
    }
 
    public void MaakSelectieLeeg()
    {
        isIngevuld=false;
        repaint();
    }
 
    public void VulIn(final int cijfer)
    {
        isIngevuld=true;
        isGetypt=true;
        this.cijfer=cijfer;
        repaint();
    }
 
    public void Test(final int cijfer)
    {
        isIngevuld=true;
        isGetypt=true;
        this.cijfer=cijfer;
    }
 
    public void KiesIngevuldCijfer(final GekozenVakken gekozenVakken)
    {
        gekozenVakken.VoegToe(this);
        rooster.TelGekozenEnIngevuld();
    }
 
    public void Kies(final int cijfer,
                     final GekozenVakken gekozenVakken)
    {
        isIngevuld=true;
        isGetypt=false;
        this.cijfer=cijfer;
        KiesIngevuldCijfer(gekozenVakken);
    }
 
    private boolean MogelijkeCijfersZijnGoedIngekort(final GekozenVakken gekozenVakken)
    {
        final int aantal=mogelijkeCijfers.GeefAantal();
        if (aantal==0)
            {
            return false;
            }
        if (aantal==1)
            {
            final int enige=mogelijkeCijfers.GeefEnige();
            Kies(enige,
                 gekozenVakken);
            }
        return true;
    }
 
    public boolean SchrapCijferInMogelijkeCijfers(final int cijfer,
                                                  final GekozenVakken gekozenVakken)
    {
        if (!mogelijkeCijfers.Bevat(cijfer))
            {
            return true;
            }
        mogelijkeCijfers.Schrap(cijfer);
        if (!MogelijkeCijfersZijnGoedIngekort(gekozenVakken))
            {
            return false;
            }
        rooster.MarkeerAlsGewijzigd(rij,
                                    kolom);
        return true;
    }
 
    public void Tel(final CijferFrequentie cijferFrequentie)
    {
        if (isIngevuld)
            {
            TelIngevuld(cijferFrequentie);
            }
        else
            {
            TelLeeg(cijferFrequentie);
            }
    }
 
    private void TelIngevuld(final CijferFrequentie cijferFrequentie)
    {
        cijferFrequentie.Tel(cijfer,
                             this);
    }
 
    private void TelLeeg(final CijferFrequentie cijferFrequentie)
    {
        cijferFrequentie.Tel(mogelijkeCijfers,
                             this);
    }
 
    public void KiesUniekCijferInMogelijkeCijfers(final int cijfer,
                                                  final GekozenVakken gekozenVakken)
    {
        Kies(cijfer,
             gekozenVakken);
    }
 
    public boolean SchrapGekozenCijferInZijnKruisEn3x3Rooster()
    {
        if (!rooster.SchrapGekozenCijferInZijnKruisEn3x3Rooster(rij,
                                                                kolom,
                                                                cijfer))
            {
            return false;
            }
        return true;
    }
 
    public int GeefKeuze()
    {
        final int aantal=mogelijkeCijfers.GeefAantal();
        return aantal;
    }
 
    public void KiesWillekeurigCijfer(final GekozenVakken gekozenVakken)
    {
        final int willekeurig=mogelijkeCijfers.GeefWillekeurig();
        Kies(willekeurig,
             gekozenVakken);
    }
 
    public String Dump1()
    {
        // opm: dit is om te debuggen.
        if (isIngevuld)
            {
            return "["+cijfer+"] ";
            }
        return VoegToe(1)+VoegToe(2)+VoegToe(3)+" ";
    }
 
    public String Dump2()
    {
        // opm: dit is om te debuggen.
        if (isIngevuld)
            {
            return "    ";
            }
        return VoegToe(4)+VoegToe(5)+VoegToe(6)+" ";
    }
 
    public String Dump3()
    {
        // opm: dit is om te debuggen.
        if (isIngevuld)
            {
            return "    ";
            }
        return VoegToe(7)+VoegToe(8)+VoegToe(9)+" ";
    }
 
    private String VoegToe(final int i)
    {
        // opm: dit is om te debuggen.
        if (mogelijkeCijfers.Bevat(i))
            {
            return Integer.toString(i);
            }
        return " ";
    }
}
User avatar
Puzzle
Mountainbiker
Posts: 178
Joined: Sat 19 Aug 2006 11:15
Location: MBK Super Sprint

Post by Puzzle »

Code: Select all

// File: Rooster.java
// Date: 30 September 2006.
//
// Copyright (c) 2006 Cliff Huylebroeck. All Rights Reserved.
//
// Permission to use, copy, modify, and distribute this software
// and its documentation for NON-COMMERCIAL purposes and without
// fee is hereby granted provided that this copyright notice
// appears in all copies.
//
// Cliff Huylebroeck MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE
// SUITABILITY OF THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT
// NOT LIMITED TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR
// A PARTICULAR PURPOSE, OR NON-INFRINGEMENT. Cliff Huylebroeck SHALL NOT
// BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING,
// MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
 
import java.awt.Color;
import java.awt.Container;
import java.awt.Graphics;
import java.awt.Rectangle;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import com.mw.pj.StaticLayout;
 
public class Rooster implements KeyListener
{
    private SudokuApplet sudokuApplet=null;
    private Rectangle kader=null;
    private boolean erIsEenselectie=false;
    private int selectieRij=0;
    private int selectieKolom=0;
    private Vak vakken[][]=null;    
    private GekozenVakken gekozenVakken=null;
    private int aGekozenEnIngevuld;
    private CijferFrequentie cijferFrequentie=null;
    private boolean rijIsGewijzigd[]=null;
    private boolean kolomIsGewijzigd[]=null;
    private boolean rooster3x3IsGewijzigd[][]=null;
 
    public Rooster(final SudokuApplet sudokuApplet,
                   final int offsetX,
                   final int offsetY,
                   final int roosterGrootte,
                   final int rooster3x3Grootte,
                   final int vakGrootte)
    {
        this.sudokuApplet=sudokuApplet;
        kader=new Rectangle(offsetX,
                            offsetY,
                            roosterGrootte,
                            roosterGrootte);
        vakken=new Vak[9][];
        for (int rij=0;rij<9;rij++)
            {
            vakken[rij]=new Vak[9];
            for (int kolom=0;kolom<9;kolom++)
                {
                vakken[rij][kolom]=null;
                }
            }
        for (int rij3=0;rij3<3;rij3++)
            {
            final int offsetR=rij3*3;
            final int y3=1+offsetY+rij3*(rooster3x3Grootte+1);
            for (int kolom3=0;kolom3<3;kolom3++)
                {
                final int offsetK=kolom3*3;
                final int x3=1+offsetX+kolom3*(rooster3x3Grootte+1);
                for (int r=0;r<3;r++)
                    {
                    final int rij=offsetR+r;
                    final int y=1+y3+r*(vakGrootte+1);
                    for (int k=0;k<3;k++)
                        {
                        final int kolom=offsetK+k;
                        final int x=1+x3+k*(vakGrootte+1);
                        final Vak nieuwVak=new Vak(this,
                                                   rij,
                                                   kolom,
                                                   x,
                                                   y,
                                                   vakGrootte);
                        vakken[rij][kolom]=nieuwVak;
                        sudokuApplet.add(nieuwVak);
                        }
                    }
                }
            }
        gekozenVakken=new GekozenVakken();
        cijferFrequentie=new CijferFrequentie();
        rijIsGewijzigd=new boolean[9];
        kolomIsGewijzigd=new boolean[9];
        rooster3x3IsGewijzigd=new boolean[3][];
        for (int rij3=0;rij3<3;rij3++)
            {
            rooster3x3IsGewijzigd[rij3]=new boolean[3];
            }
    }
 
    public void keyTyped(final KeyEvent event)
    {
        // opm: gedrukt en losgelaten.
        event.consume();
        if (!erIsEenselectie)
            {
            return;
            }
        final int keyChar=event.getKeyChar();
        if ((keyChar<KeyEvent.VK_0)
            || (keyChar>KeyEvent.VK_9))
            {
            return;
            }
        switch (keyChar)
            {
            case KeyEvent.VK_0:
                {
                MaakSelectieLeeg();
                break;
                }
            case KeyEvent.VK_1:
                {
                VulSelectieIn(1);
                break;
                }
            case KeyEvent.VK_2:
                {
                VulSelectieIn(2);
                break;
                }
            case KeyEvent.VK_3:
                {
                VulSelectieIn(3);
                break;
                }
            case KeyEvent.VK_4:
                {
                VulSelectieIn(4);
                break;
                }
            case KeyEvent.VK_5:
                {
                VulSelectieIn(5);
                break;
                }
            case KeyEvent.VK_6:
                {
                VulSelectieIn(6);
                break;
                }
            case KeyEvent.VK_7:
                {
                VulSelectieIn(7);
                break;
                }
            case KeyEvent.VK_8:
                {
                VulSelectieIn(8);
                break;
                }
            case KeyEvent.VK_9:
                {
                VulSelectieIn(9);
                break;
                }
            }
    }
 
    public void keyPressed(final KeyEvent event)
    {
        event.consume();
        // opm: zeker niets mee doen.
    }
 
    public void keyReleased(final KeyEvent event)
    {
        event.consume();
        // opm: zeker niets mee doen.
    }
 
    public void Teken(final Graphics g)
    {
        final Rectangle clip=g.getClipRect();
        final Rectangle doorsnede=kader.intersection(clip);
        if (doorsnede.isEmpty())
            {
            return;
            }
        g.setClip(doorsnede);
        for (int rij=0;rij<9;rij++)
            {
            for (int kolom=0;kolom<9;kolom++)
                {
                final Vak vak=vakken[rij][kolom];
                vak.paint(g);
                }
            }
        g.setClip(clip);
    }
 
    public void MaakLeeg(final boolean ookGetypte)
    {
        for (int rij=0;rij<9;rij++)
            {
            for (int kolom=0;kolom<9;kolom++)
                {
                final Vak vak=vakken[rij][kolom];
                vak.MaakLeeg(ookGetypte);
                }
            }
        gekozenVakken.MaakLeeg();
        aGekozenEnIngevuld=0;
        // opm: geen cijferFrequentie.
    }
 
    public void MaakOK()
    {
        for (int rij=0;rij<9;rij++)
            {
            for (int kolom=0;kolom<9;kolom++)
                {
                final Vak vak=vakken[rij][kolom];
                vak.MaakOK();
                }
            }
    }
 
    public void Selecteer(final int rij,
                          final int kolom)
    {
        final Vak vak=vakken[rij][kolom];
        vak.Selecteer();
    }
 
    public void Deselecteer(final int rij,
                            final int kolom)
    {
        final Vak vak=vakken[rij][kolom];
        vak.Deselecteer();
    }
 
    public void ReageerOpSelectie(final int rij,
                                  final int kolom)
    {
        if (!erIsEenselectie)
            {
            selectieRij=rij;
            selectieKolom=kolom;
            Selecteer(selectieRij,
                      selectieKolom);
            erIsEenselectie=true;
            }
        else if ((rij!=selectieRij) || (kolom!=selectieKolom))
            {
            Deselecteer(selectieRij,
                        selectieKolom);
            selectieRij=rij;
            selectieKolom=kolom;
            Selecteer(selectieRij,
                      selectieKolom);
            }
    }
 
    private void MaakSelectieLeeg()
    {
        final Vak vak=vakken[selectieRij][selectieKolom];
        vak.MaakSelectieLeeg();
    }
 
    private void HertekenSelectie()
    {
        final Vak vak=vakken[selectieRij][selectieKolom];
        vak.MaakSelectieLeeg();
    }
 
    private void VulSelectieIn(final int cijfer)
    {
        final Vak vak=vakken[selectieRij][selectieKolom];
        vak.VulIn(cijfer);
    }
 
    private boolean ZijnErGekozenVakken()
    {
        return !gekozenVakken.IsLeeg();
    }
 
    private void MarkeerAllesAlsNietGewijzigd()
    {
        for (int rij3=0;rij3<3;rij3++)
            {
            for (int kolom3=0;kolom3<3;kolom3++)
                {
                rooster3x3IsGewijzigd[rij3][kolom3]=false;
                }
            }
        for (int i=0;i<9;i++)
            {
            rijIsGewijzigd[i]=false;
            }
        for (int j=0;j<9;j++)
            {
            kolomIsGewijzigd[j]=false;
            }
    }
 
    public void MarkeerAlsGewijzigd(final int rij,
                                    final int kolom)
    {
        final int rij3=rij/3;
        final int kolom3=kolom/3;
        rooster3x3IsGewijzigd[rij3][kolom3]=true;
        rijIsGewijzigd[rij]=true;
        kolomIsGewijzigd[kolom]=true;
    }
 
    public void Test(final int rij3,
                     final int kolom3,
                     final int rij,
                     final int kolom,
                     final int cijfer)
    {
        final Vak vak=vakken[rij3*3+rij][kolom3*3+kolom];
        vak.Test(cijfer);
    }
 
    public boolean LosOp()
    {
        KiesIngevuldeCijfers();
        if (!VerwerkGekozenVakken())
            {
            return false;
            }
        while (!IsVolledigIngevuld())
            {
            if (!KiesEenWillekeurigCijfer())
                {
                return false;
                }
            if (!VerwerkGekozenVakken())
                {
                return false;
                }
            }
        return true;
    }
 
    private void KiesIngevuldeCijfers()
    {
        for (int rij=0;rij<9;rij++)
            {
            for (int kolom=0;kolom<9;kolom++)
                {
                final Vak vak=vakken[rij][kolom];
                if (!vak.IsLeeg())
                    {
                    vak.KiesIngevuldCijfer(gekozenVakken);
                    }
                }
            }
    }
 
    private boolean VerwerkGekozenVakken()
    {
        while (ZijnErGekozenVakken())
            {
            MarkeerAllesAlsNietGewijzigd();
            if (!SchrapGekozenVakkenInHunKruisEn3x3Rooster())
                {
                return false;
                }
            if (!KiesUniekeCijfersInKruisenEn3x3Roosters())
                {
                return false;
                }
            }
        return true;
    }
 
    private boolean SchrapGekozenVakkenInHunKruisEn3x3Rooster()
    {
        while (!gekozenVakken.IsLeeg())
            {
            final Vak vak=gekozenVakken.Geef();
            // opm: gaat doorsturen naar volgende functie.
            if (!vak.SchrapGekozenCijferInZijnKruisEn3x3Rooster())
                {
                return false;
                }
            }
        return true;
    }
 
    public boolean SchrapGekozenCijferInZijnKruisEn3x3Rooster(final int rij,
                                                              final int kolom,
                                                              final int cijfer)
    {
        if (!SchrapGekozenCijferInZijnRij(rij,
                                          cijfer))
            {
            return false;
            }
        if (!SchrapGekozenCijferInZijnKolom(kolom,
                                            cijfer))
            {
            return false;
            }
        final int rij3=rij/3;
        final int kolom3=kolom/3;
        if (!SchrapGekozenCijferInZijn3x3Rooster(rij3,
                                                 kolom3,
                                                 cijfer))
            {
            return false;
            }
        return true;
    }
 
    private boolean SchrapGekozenCijferInZijnRij(final int rij,
                                                 final int cijfer)
    {
        for (int j=0;j<9;j++)
            {
            final Vak rijvak_j=vakken[rij][j];
            if (rijvak_j.IsLeeg())
                {
                if (!rijvak_j.SchrapCijferInMogelijkeCijfers(cijfer,
                                                             gekozenVakken))
                    {
                    return false;
                    }
                }
            }
        return true;
    }
 
    private boolean SchrapGekozenCijferInZijnKolom(final int kolom,
                                                   final int cijfer)
    {
        for (int i=0;i<9;i++)
            {
            final Vak kolomvak_i=vakken[i][kolom];
            if (kolomvak_i.IsLeeg())
                {
                if (!kolomvak_i.SchrapCijferInMogelijkeCijfers(cijfer,
                                                               gekozenVakken))
                    {
                    return false;
                    }
                }
            }
        return true;
    }
 
    private boolean SchrapGekozenCijferInZijn3x3Rooster(final int rij3,
                                                        final int kolom3,
                                                        final int cijfer)
    {
        final int startRij=rij3*3;
        final int eindRij=startRij+3;
        final int startKolom=kolom3*3;
        final int eindKolom=startKolom+3;
        for (int i=startRij;i<eindRij;i++)
            {
            for (int j=startKolom;j<eindKolom;j++)
                {
                final Vak vak=vakken[i][j];
                if (vak.IsLeeg())
                    {
                    if (!vak.SchrapCijferInMogelijkeCijfers(cijfer,
                                                            gekozenVakken))
                        {
                        return false;
                        }
                    }
                }
            }
        return true;
    }
 
    private boolean KiesUniekeCijfersInKruisenEn3x3Roosters()
    {
        for (int rij=0;rij<9;rij++)
            {
            if (rijIsGewijzigd[rij])
                {
                if (!KiesUniekeCijfersInRij(rij))
                    {
                    return false;
                    }
                }
            }
        for (int kolom=0;kolom<9;kolom++)
            {
            if (kolomIsGewijzigd[kolom])
                {
                if (!KiesUniekeCijfersInKolom(kolom))
                    {
                    return false;
                    }
                }
            }
        for (int rij3=0;rij3<3;rij3++)
            {
            for (int kolom3=0;kolom3<3;kolom3++)
                {
                if (rooster3x3IsGewijzigd[rij3][kolom3])
                    {
                    if (!KiesUniekeCijfersIn3x3Rooster(rij3,
                                                       kolom3))
                        {
                        return false;
                        }
                    }
                }
            }
        return true;
    }
 
    private boolean KiesUniekeCijfersInRij(final int rij)
    {
        boolean erIsEenUniekCijfer;
        do
            {
            cijferFrequentie.MaakLeeg();
            for (int kolom=0;kolom<9;kolom++)
                {
                final Vak vak=vakken[rij][kolom];
                vak.Tel(cijferFrequentie);
                }
            if (ErKomtEenNietVoor())
                {
                return false;
                }
            erIsEenUniekCijfer=ErKomtEenEenKeerVoor();
            }
        while (erIsEenUniekCijfer);
        return true;
    }
 
    private boolean KiesUniekeCijfersInKolom(final int kolom)
    {
        boolean erIsEenUniekCijfer;
        do
            {
            cijferFrequentie.MaakLeeg();
            for (int rij=0;rij<9;rij++)
                {
                final Vak vak=vakken[rij][kolom];
                vak.Tel(cijferFrequentie);
                }
            if (ErKomtEenNietVoor())
                {
                return false;
                }
            erIsEenUniekCijfer=ErKomtEenEenKeerVoor();
            }
        while (erIsEenUniekCijfer);
        return true;
    }
 
    private boolean KiesUniekeCijfersIn3x3Rooster(final int rij3,
                                                  final int kolom3)
    {
        final int offsetR=rij3*3;
        final int offsetK=kolom3*3;
        boolean erIsEenUniekCijfer;
        do
            {
            cijferFrequentie.MaakLeeg();
            for (int r=0;r<3;r++)
                {
                final int rij=offsetR+r;
                for (int k=0;k<3;k++)
                    {
                    final int kolom=offsetK+k;
                    final Vak vak=vakken[rij][kolom];
                    vak.Tel(cijferFrequentie);
                    }
                }
            if (ErKomtEenNietVoor())
                {
                return false;
                }
            erIsEenUniekCijfer=ErKomtEenEenKeerVoor();
            }
        while (erIsEenUniekCijfer);
        return true;
    }
 
    private boolean ErKomtEenNietVoor()
    {
        for (int cijfer=1;cijfer<=9;cijfer++)
            {
            if (cijferFrequentie.KomtNietVoor(cijfer))
                {
                return true;
                }
            }
        return false;
    }
 
    private boolean ErKomtEenEenKeerVoor()
    {
        for (int cijfer=1;cijfer<=9;cijfer++)
            {
            if (cijferFrequentie.KomtEenKeerVoor(cijfer))
                {
                final Vak vak=cijferFrequentie.GeefVak(cijfer);
                if (vak.IsLeeg())
                    {
                    vak.KiesUniekCijferInMogelijkeCijfers(cijfer,
                                                          gekozenVakken);
                    return true;
                    }
                }
            }
        return false;
    }
 
    public void TelGekozenEnIngevuld()
    {
        aGekozenEnIngevuld++;
    }
 
    private boolean IsVolledigIngevuld()
    {
        return aGekozenEnIngevuld==81;
    }
 
    private boolean KiesEenWillekeurigCijfer()
    {
        final Vak vak=ZoekVakMetKleinsteKeuze();
        if (vak==null)
            {
            return false;
            }
        vak.KiesWillekeurigCijfer(gekozenVakken);
        return true;
    }
 
    private Vak ZoekVakMetKleinsteKeuze()
    {
        int kleinsteKeuze=10;
        Vak vakMetKleinsteKeuze=null;
        for (int rij=0;rij<9;rij++)
            {
            for (int kolom=0;kolom<9;kolom++)
                {
                final Vak vak=vakken[rij][kolom];
                if (vak.IsLeeg())
                    {
                    final int keuze=vak.GeefKeuze();
                    if (keuze<kleinsteKeuze)
                        {
                        kleinsteKeuze=keuze;
                        vakMetKleinsteKeuze=vak;
                        }
                    }
                }
            }
        return vakMetKleinsteKeuze;
    }
 
    private void Dump()
    {
        // opm: dit is om te debuggen.
        for (int rij=0;rij<9;rij++)
            {
            String lijn1=new String();
            String lijn2=new String();
            String lijn3=new String();
            for (int kolom=0;kolom<9;kolom++)
                {
                final Vak vak=vakken[rij][kolom];
                lijn1+=vak.Dump1();
                lijn2+=vak.Dump2();
                lijn3+=vak.Dump3();
                }
            System.out.println(lijn1);
            System.out.println(lijn2);
            System.out.println(lijn3);
            System.out.println("");
            }
    }
}
User avatar
Puzzle
Mountainbiker
Posts: 178
Joined: Sat 19 Aug 2006 11:15
Location: MBK Super Sprint

Post by Puzzle »

Code: Select all

// File: SudokuApplet.java
// Date: 30 September 2006.
//
// Copyright (c) 2006 Cliff Huylebroeck. All Rights Reserved.
//
// Permission to use, copy, modify, and distribute this software
// and its documentation for NON-COMMERCIAL purposes and without
// fee is hereby granted provided that this copyright notice
// appears in all copies.
//
// Cliff Huylebroeck MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE
// SUITABILITY OF THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT
// NOT LIMITED TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR
// A PARTICULAR PURPOSE, OR NON-INFRINGEMENT. Cliff Huylebroeck SHALL NOT
// BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING,
// MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
 
import java.applet.Applet;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.MediaTracker;
import java.awt.Rectangle;
import java.lang.String;
import java.net.MalformedURLException;
import java.net.URL;
import com.mw.pj.StaticLayout;
 
public class SudokuApplet extends Applet
{
    // Geheel.
    private final int rondeKnopGrootte=23;
    private final int vakGrootte=16;
    private final int marge=8;
    private final int rooster3x3Grootte=3*(vakGrootte+1)+1;
    private final int roosterGrootte=3*(rooster3x3Grootte+1)+1;
    private final int breedte=roosterGrootte+3*marge+rondeKnopGrootte;
    private final int hoogte=roosterGrootte+2*marge;
    private Image offscreen=null;
    private Image achtergrond=null;
 
    // Leegknop.
    private final int leegKnopX=breedte-marge-rondeKnopGrootte;
    private final int leegKnopY=hoogte-marge-rondeKnopGrootte;
    private Image gewoonLeeg=null;
    private Image ingedruktLeeg=null;
    private LeegKnop leegKnop=null;
 
    // Oplosknop.
    private final int oplosKnopX=breedte-marge-rondeKnopGrootte;
    private final int oplosKnopY=hoogte-2*(marge+rondeKnopGrootte);
    private Image gewoonOplos=null;
    private Image ingedruktOplos=null;
    private OplosKnop oplosKnop=null;
 
    // Net.
    private final int afbeeldingKlasse=1;
 
    // Data.
    private Rooster rooster=null;
 
    public String getAppletInfo()
    {
        return "SudokuApplet, ©1/10/2006 Huylebroeck Cliff";
    }
 
    public void init()
    {
        resize(breedte,
               hoogte);
        final StaticLayout layout=new StaticLayout();
        setLayout(layout);
        offscreen=createImage(breedte,
                              hoogte);
        show(true);
        repaint();
    }
 
    public void start()
    {
        LaadAfbeeldingen();
        showStatus("Images loaded.");
 
        MaakLeegKnop();
        showStatus("Empty button initialized.");
 
        MaakOplosKnop();
        showStatus("Solution button initialized.");
 
        MaakRooster();
        MaakRoosterLeeg(true);
        showStatus("Grid initialized.");
 
        Test();
        requestFocus();
    }
 
    public void stop()
    {
        leegKnop.enable(false);
        VerwijderRooster();
    }
 
    public void update(final Graphics g)
    {
        paint(g);
    }
 
    public void paint(final Graphics g)
    {
        if (!isShowing())
            {
            return;
            }
        if (offscreen==null)
            {
            return;
            }
        final Rectangle clip=g.getClipRect();
        final Graphics og=offscreen.getGraphics();
        og.setClip(clip);
        if (achtergrond!=null)
            {
            og.drawImage(achtergrond,
                         0,
                         0,
                         this);
            }
        if (leegKnop!=null)
            {
            leegKnop.paint(og);
            }
        if (oplosKnop!=null)
            {
            oplosKnop.paint(og);
            }
        if (rooster!=null)
            {
            rooster.Teken(og);
            }
        og.dispose();
        g.drawImage(offscreen,
                    0,
                    0,
                    null);
    }
 
    public void LaadAfbeeldingen()
    {
        final MediaTracker mediaTracker=new MediaTracker(this);
        final URL codeBase=getCodeBase();
        achtergrond=WachtOpImage(mediaTracker,
                                 codeBase,
                                 "jpgs",
                                 "bg.jpg");
        gewoonLeeg=WachtOpImage(mediaTracker,
                                codeBase,
                                "jpgs",
                                "gleeg.jpg");
        ingedruktLeeg=WachtOpImage(mediaTracker,
                                   codeBase,
                                   "jpgs",
                                   "ileeg.jpg");
        gewoonOplos=WachtOpImage(mediaTracker,
                                 codeBase,
                                 "jpgs",
                                 "goplos.jpg");
        ingedruktOplos=WachtOpImage(mediaTracker,
                                    codeBase,
                                    "jpgs",
                                    "ioplos.jpg");
    }
 
    private Image WachtOpImage(final MediaTracker mediaTracker,
                               final URL codeBase,
                               final String map,
                               final String naam)
    {
        String relatiefPad=map+"/"+naam;
        URL iURL;
        try
            {
            iURL=new URL(codeBase,
                         relatiefPad);
            }
        catch (MalformedURLException e)
            {
            final String url=codeBase.toString();
            final String uitleg="Wrong URL: "+url+relatiefPad+".";
            System.out.println(uitleg);
            return null;
            }
        Image afbeelding=getImage(iURL);
        mediaTracker.addImage(afbeelding,
                              afbeeldingKlasse);
        try
            {
            mediaTracker.waitForID(afbeeldingKlasse);
            }
        catch (InterruptedException ie)
            {
            final String url=codeBase.toString();
            final String uitleg="Loading of "+url+relatiefPad+" interrupted.";
            System.out.println(uitleg);
            return null;
            }
        if (afbeelding!=null)
            {
            repaint();
            }
        return afbeelding;
    }
 
    public void MaakLeegKnop()
    {
        final LeegKnop nieuw=new LeegKnop(this,
                                          gewoonLeeg,
                                          ingedruktLeeg);
        nieuw.setBounds(leegKnopX,
                        leegKnopY,
                        rondeKnopGrootte,
                        rondeKnopGrootte);
        nieuw.show(true);
        nieuw.enable(true);
        add(nieuw);
        leegKnop=nieuw;
    }
 
    public void MaakOplosKnop()
    {
        final OplosKnop nieuw=new OplosKnop(this,
                                            gewoonOplos,
                                            ingedruktOplos);
        nieuw.setBounds(oplosKnopX,
                        oplosKnopY,
                        rondeKnopGrootte,
                        rondeKnopGrootte);
        nieuw.show(true);
        nieuw.enable(true);
        add(nieuw);
        oplosKnop=nieuw;
    }
 
    public void MaakRooster()
    {
        rooster=new Rooster(this,
                            marge,
                            marge,
                            roosterGrootte,
                            rooster3x3Grootte,
                            vakGrootte);
        addKeyListener(rooster);
    }
 
    public void MaakRoosterLeeg(final boolean ookGetypte)
    {
        rooster.MaakLeeg(ookGetypte);
        repaint();
    }
 
    public void MaakRoosterOK()
    {
        rooster.MaakOK();
        repaint();
    }
 
    public void VerwijderRooster()
    {
        rooster=null;
    }
 
    public void Herbegin()
    {
        leegKnop.enable(false);
        oplosKnop.enable(false);
        MaakRoosterLeeg(true);
        leegKnop.enable(true);
        oplosKnop.enable(true);
        repaint();
    }
 
    public void Test()
    {
        rooster.Test(0,0,0,0,7);
        rooster.Test(0,0,1,0,2);
        rooster.Test(0,0,2,1,4);
        rooster.Test(0,0,2,2,3);
        rooster.Test(0,1,0,2,4);
        rooster.Test(0,1,1,2,3);
        rooster.Test(0,1,2,1,7);
        rooster.Test(0,1,2,2,1);
        rooster.Test(0,2,0,2,3);
        rooster.Test(0,2,1,0,4);
        rooster.Test(0,2,1,1,7);
        rooster.Test(0,2,1,2,8);
        rooster.Test(1,0,0,0,3);
        rooster.Test(1,0,0,1,2);
        rooster.Test(1,0,2,1,7);
        rooster.Test(1,0,2,2,6);
        rooster.Test(1,2,0,0,5);
        rooster.Test(1,2,0,1,4);
        rooster.Test(1,2,2,1,3);
        rooster.Test(1,2,2,2,1);
        rooster.Test(2,0,1,0,6);
        rooster.Test(2,0,1,1,5);
        rooster.Test(2,0,1,2,7);
        rooster.Test(2,0,2,0,4);
        rooster.Test(2,1,0,0,4);
        rooster.Test(2,1,0,1,8);
        rooster.Test(2,1,1,0,2);
        rooster.Test(2,1,2,0,3);
        rooster.Test(2,2,0,0,7);
        rooster.Test(2,2,0,1,1);
        rooster.Test(2,2,1,2,4);
        rooster.Test(2,2,2,2,2);
        repaint();
    }
 
    public void LosOp()
    {
        leegKnop.enable(false);
        oplosKnop.enable(false);
        final boolean isOpgelost=rooster.LosOp();
        leegKnop.enable(true);
        oplosKnop.enable(true);
        if (isOpgelost)
            {
            MaakRoosterOK();
            }
        else
            {
            MaakRoosterLeeg(false);
            }
        repaint();
    }
}
User avatar
Galibier2646
Mountainbiker
Posts: 149
Joined: Thu 14 Oct 2004 21:17
Location: 2015 - SJ Carbon 29er / Sram X9

Post by Galibier2646 »

1e mogelijkheid :

package src.avondschool.bme.groep04;


public class Main {


public static void main(String[] args) {

// int[][] board = {{0, 6, 0, 1, 0, 4, 0, 5, 0},
// {0, 0, 8, 3, 0, 5, 6, 0, 0},
// {2, 0, 0, 0, 0, 0, 0, 0, 1},
// {8, 0, 0, 4, 0, 7, 0, 0, 6},
// {0, 0, 6, 0, 0, 0, 3, 0, 0},
// {7, 0, 0, 9, 0, 1, 0, 0, 4},
// {5, 0, 0, 0, 0, 0, 0, 0, 2},
// {0, 0, 7, 2, 0, 6, 9, 0, 0},
// {0, 4, 0, 5, 0, 8, 0, 7, 0}};
//
// new SwingSudoKiller(new SwingSudokuBoard(board));
//
// }}


// int[][] testBord = {
// { 2, 0, 0, 9, 0, 6, 0, 0, 4},
// { 0, 0, 5, 0, 7, 0, 9, 0, 0},
// { 0, 3, 0, 0, 0, 0, 0, 8, 0},
// {0, 0, 3, 4, 0, 7, 8, 0, 0},
// {8, 9, 0, 2, 0, 5, 0, 6, 3},
// {0, 0, 7, 6, 0, 8, 2, 0, 0},
// {0, 7, 0, 0, 0, 0, 0, 2, 0},
// {0, 0, 8, 0, 6, 0, 1, 0, 0},
// {3, 0, 0, 7, 0, 1, 0, 0, 8}
// };
// new SwingSudoKiller(new SwingSudokuBoard(testBord));
// }}

int[][] testBord = {
{9,0,0,1,0,2,0,0,6},
{0,5,2,0,0,0,1,9,0},
{0,6,0,0,5,0,0,3,0},
{0,0,5,0,7,0,3,0,0},
{0,8,0,0,0,0,0,7,0},
{0,0,4,0,6,0,2,0,0},
{0,4,0,0,2,0,0,6,0},
{0,7,6,0,0,0,4,2,0},
{2,0,0,6,0,3,0,0,8}
};
new SwingSudoku(new SwingSudokuBord(testBord));
} }
// int[][] testBord = {
// {0,0,0,0,0,0,0,6,0},
// {0,0,7,3,0,0,9,0,0},
// {0,0,8,9,0,0,0,0,0},
// {0,7,1,0,0,0,0,0,0},
// {0,0,0,0,0,0,0,0,8},
// {8,0,0,0,5,0,6,0,4},
// {0,1,0,2,0,0,0,9,0},
// {2,0,0,0,0,4,0,0,0},
// {0,6,9,0,0,0,0,7,0}
// };
// new SwingSudoKiller(new SwingSudokuBoard(testBord));
// } }

// int[][] testBord = {
// {5,0,4,0,0,3,7,0,0},
// {0,0,1,0,0,9,0,2,5},
// {6,0,0,0,0,0,0,0,4},
// {0,0,0,0,8,0,9,0,0},
// {4,0,0,7,0,1,0,0,2},
// {0,0,6,0,2,0,0,0,0},
// {3,0,0,0,0,0,0,0,9},
// {7,1,0,2,0,0,8,0,0},
// {0,0,2,3,0,0,6,0,7}
// };
// new SwingSudoKiller(new SwingSudokuBoard(testBord));
// }
// }


package src.avondschool.bme.groep04;


abstract class Sudoku {
private SudokuBord sb;


public Sudoku(SudokuBord sb) {
this.sb = sb;
}

private boolean check(int num, int row, int col) {
int r = (row / sb.box_size) * sb.box_size;
int c = (col / sb.box_size) * sb.box_size;

for (int i = 0; i < sb.size; i++) {
if (sb.getCell(row, i) == num ||
sb.getCell(i, col) == num ||
sb.getCell(r + (i % sb.box_size), c + (i / sb.box_size)) == num) {
return false;
}
}
return true;
}

public boolean guess(int row, int col) {
int nextCol = (col + 1) % sb.size;
int nextRow = (nextCol == 0) ? row + 1 : row;

try {
if (sb.getCell(row, col) != sb.EMPTY)
return guess(nextRow, nextCol);
}
catch (ArrayIndexOutOfBoundsException e) {
return true;
}

for (int i = 1; i <= sb.size; i++) {
if (check(i, row, col)) {
sb.setCell(i, row, col);
if (guess(nextRow, nextCol)) {
return true;
}
}
}
sb.setCell(sb.EMPTY, row, col);
return false;
}
}
package src.avondschool.bme.groep04;


public class SudokuBord {
final int EMPTY = 0;
final int size;
final int box_size;

private int[][] board;


public SudokuBord(int size) {
board = new int[size][size];
this.size = size;
this.box_size = (int) Math.sqrt(size);
}


public SudokuBord(int[][] board) {
this(board.length);
this.board = board;
}


public void setCell(int num, int row, int col) {
board[row][col] = num;
}


public int getCell(int row, int col) {
return board[row][col];
}
}
package src.avondschool.bme.groep04;

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;


public class SwingSudoku extends Sudoku{


public SwingSudoku(SwingSudokuBord ssb) {
super(ssb);
final JPanel panel = ssb.getPanel();

Runnable runner = new Runnable() {
public void run() {
final JFrame frame = new JFrame("SudoKu");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

ActionListener al = new ActionListener() {
public void actionPerformed(ActionEvent ae) {
if (! guess(0, 0))
JOptionPane.showMessageDialog(frame, "Oplossing niet gevonden!");
}
};
frame.setLayout(new GridBagLayout());
addComponent(frame, panel, 0, 0, 1, 1);

JButton b = new JButton("Start!");
b.setMnemonic(KeyEvent.VK_S);
b.addActionListener(al);
addComponent(frame, b, 0, 1, 1, 1);

frame.setSize(240, 280);
frame.setVisible(true);
}
};
EventQueue.invokeLater(runner);
}


private static void addComponent(Container container, Component component,
int gridx, int gridy, int gridwidth, int gridheight) {
Insets insets = new Insets(0, 0, 0, 0);
GridBagConstraints gbc = new GridBagConstraints(gridx, gridy, gridwidth,
gridheight, 1, 1, GridBagConstraints.CENTER,
GridBagConstraints.BOTH, insets, 0, 0);
container.add(component, gbc);
}
}







package src.avondschool.bme.groep04;

import java.awt.*;
import javax.swing.*;


public class SwingSudokuBord extends SudokuBord {
private JTextField[][] cells;
private JPanel panel = new JPanel();


public SwingSudokuBord(int size) {
super(size);
cells = new JTextField[size][size];
panel.setLayout(new GridLayout(size, size));
for (int row = 0; row < size; row++) {
for (int col = 0; col < size; col++) {
cells[row][col] = new JTextField(1);
panel.add(cells[row][col]);
}
}
}


public SwingSudokuBord(int[][] board) {
this(board.length);
for (int row = 0; row < size; row++) {
for (int col = 0; col < size; col++) {
setCell(board[row][col], row, col);
}
}
}

public void setCell(int num, int row, int col) {
super.setCell(num, row, col);
String text = (num == EMPTY) ? "" : String.valueOf(num);
cells[row][col].setText(text);
}


public int getCell(int row, int col) {
int cell;

try {
cell = Integer.parseInt(cells[row][col].getText());
}
catch (NumberFormatException e) {
cell = EMPTY;
}
return cell;
}

public JPanel getPanel() {
return panel;
}
}
User avatar
Galibier2646
Mountainbiker
Posts: 149
Joined: Thu 14 Oct 2004 21:17
Location: 2015 - SJ Carbon 29er / Sram X9

Post by Galibier2646 »

2e mogelijkheid ( enkel algoritme )

package src.avondschool.bme.groep04.versie02;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;




public class Sudoku {
private Vierkant[][] inhoudVierkant;
private List overgeblevenVierkanten;
private int sortering;
public ArrayList Opl;
private int matrix[][];

/* Sorteren volgens mogelijkheden */
private class CellComparator implements Comparator {

public int compare(Object o1, Object o2) {
Vierkant v1 = (Vierkant)o1;
Vierkant v2 = (Vierkant)o2;
return v2.cijferNietMogelijkCount - v1.cijferNietMogelijkCount;

}
}
private CellComparator comp = new CellComparator();

/* Informatie over Vierkant */
public class Vierkant {
private int x;
private int y;
public int inVierkant;
public int[] cijferNietMogelijk;
public int cijferNietMogelijkCount;
public int waarde;

public Vierkant(int x, int y) {
this.x = x;
this.y = y;
this.inVierkant = 3 * (x / 3) + (y / 3);
this.cijferNietMogelijkCount = 9;
this.cijferNietMogelijk = new int[10];
this.waarde = 0;
}

/* Cijfer is niet mogelijk in vierkant */
private boolean CijferUit(int v, int lijn) {
if(waarde == 0 && cijferNietMogelijk[v] == 0) {
cijferNietMogelijk[v] = lijn;
if(--cijferNietMogelijkCount == 0) { return true; }
}
return false;
}

/* Cijfer is mogelijk. */
private void CijferIn(int v, int lijn) {
if(cijferNietMogelijk[v] == lijn) {
cijferNietMogelijk[v] = 0;
cijferNietMogelijkCount++;
}
}

/* Zet de waarde van een cel en verwijdert mogelijkheid uit andere*/
public boolean setWaarde(int value, int lijn) {
this.waarde = value;

for(int i = 0; i < 9; i++) {
if(bord[x].CijferUit(value, lijn)) return true;
if(bord[y].CijferUit(value, lijn)) return true;
if(inhoudVierkant[inVierkant].CijferUit(value, lijn)) return true;

}
// MaakOplossing(board[x],board[y],value);

return false;
}

/* Verwijder waarde uit cel en maak weer mogelijk voor andere */
public void eraseValue(int lijn) {
for(int i = 0; i < 9; i++) {
bord[x].CijferIn(waarde, lijn);
bord[y].CijferIn(waarde, lijn);
inhoudVierkant[inVierkant].CijferIn(waarde, lijn);
}
this.waarde = 0;
}
}

public Vierkant[][] bord;



public Sudoku(int[][] testBord) {
// TODO Auto-generated constructor stub
matrix=testBord;
}

/* Initialize the solver. */
public boolean solve(int[][] initBord) {
bord = new Vierkant[9][9];
overgeblevenVierkanten = new ArrayList();
inhoudVierkant = new Vierkant[9][9];
int[] VierkantCount = new int[9];

for(int x = 0; x < 9; x++) {
for(int y = 0; y < 9; y++) {
Vierkant c = new Vierkant(x,y);
bord[x][y] = c;
inhoudVierkant[c.inVierkant][VierkantCount[c.inVierkant]++] = bord[x][y];
}
}

for(int x = 0; x < 9; x++) {
for(int y = 0; y < 9; y++) {
if(initBord[x][y] > 0) {
bord[x][y].setWaarde(initBord[x][y], 100);
}
else {
overgeblevenVierkanten.add(bord[x][y]);
}
}
}
Collections.sort(overgeblevenVierkanten, comp);
return backtrack(1);
}

/* Backtracking. */
public boolean backtrack(int lijn) {
if(overgeblevenVierkanten.isEmpty()) { return true; }
if(lijn == sortering + 5 || lijn == sortering - 5) {
Collections.sort(overgeblevenVierkanten, comp);
sortering = lijn;
}
Vierkant huidige = (Vierkant)overgeblevenVierkanten.remove(overgeblevenVierkanten.size()-1);

for(int v = 1; v <= 9; v++) {
if(huidige.cijferNietMogelijk[v] != 0) continue;
if(huidige.setWaarde(v, lijn)) {
huidige.eraseValue(lijn);
}
else {
if(backtrack(lijn + 1)) return true;
huidige.eraseValue(lijn);
}
}

overgeblevenVierkanten.add(huidige);
return false;
}
public void laatMatrixZien() {
// TODO Auto-generated method stub
// maak een kopie van de matrix in console
System.out.print("---begin matrix---");
for (int rij=0 ; rij < 9 ; rij++)
{
System.out.println("");
for (int kol=0 ; kol < 9 ; kol++)
System.out.print(" " + matrix[rij][kol]);
}
System.out.println("\n---einde matrix---");
}
}
Post Reply