Compare commits
4 Commits
a060cde5b2
...
411e37951f
| Author | SHA1 | Date | |
|---|---|---|---|
| 411e37951f | |||
| 7968d5fede | |||
| 86fe45c358 | |||
| ea868017ee |
3
.gitignore
vendored
3
.gitignore
vendored
@@ -30,3 +30,6 @@ replay_pid*
|
||||
|
||||
# Ignore Gradle build output directory
|
||||
build
|
||||
|
||||
.idea
|
||||
.vscode
|
||||
|
||||
3
.idea/.gitignore
generated
vendored
3
.idea/.gitignore
generated
vendored
@@ -1,3 +0,0 @@
|
||||
# Default ignored files
|
||||
/shelf/
|
||||
/workspace.xml
|
||||
6
.idea/compiler.xml
generated
6
.idea/compiler.xml
generated
@@ -1,6 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<project version="4">
|
||||
<component name="CompilerConfiguration">
|
||||
<bytecodeTargetLevel target="1.8" />
|
||||
</component>
|
||||
</project>
|
||||
17
.idea/gradle.xml
generated
17
.idea/gradle.xml
generated
@@ -1,17 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<project version="4">
|
||||
<component name="GradleMigrationSettings" migrationVersion="1" />
|
||||
<component name="GradleSettings">
|
||||
<option name="linkedExternalProjectsSettings">
|
||||
<GradleProjectSettings>
|
||||
<option name="externalProjectPath" value="$PROJECT_DIR$" />
|
||||
<option name="modules">
|
||||
<set>
|
||||
<option value="$PROJECT_DIR$" />
|
||||
<option value="$PROJECT_DIR$/app" />
|
||||
</set>
|
||||
</option>
|
||||
</GradleProjectSettings>
|
||||
</option>
|
||||
</component>
|
||||
</project>
|
||||
20
.idea/jarRepositories.xml
generated
20
.idea/jarRepositories.xml
generated
@@ -1,20 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<project version="4">
|
||||
<component name="RemoteRepositoriesConfiguration">
|
||||
<remote-repository>
|
||||
<option name="id" value="central" />
|
||||
<option name="name" value="Maven Central repository" />
|
||||
<option name="url" value="https://repo1.maven.org/maven2" />
|
||||
</remote-repository>
|
||||
<remote-repository>
|
||||
<option name="id" value="jboss.community" />
|
||||
<option name="name" value="JBoss Community repository" />
|
||||
<option name="url" value="https://repository.jboss.org/nexus/content/repositories/public/" />
|
||||
</remote-repository>
|
||||
<remote-repository>
|
||||
<option name="id" value="MavenRepo" />
|
||||
<option name="name" value="MavenRepo" />
|
||||
<option name="url" value="https://repo.maven.apache.org/maven2/" />
|
||||
</remote-repository>
|
||||
</component>
|
||||
</project>
|
||||
5
.idea/misc.xml
generated
5
.idea/misc.xml
generated
@@ -1,5 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<project version="4">
|
||||
<component name="ExternalStorageConfigurationManager" enabled="true" />
|
||||
<component name="ProjectRootManager" version="2" languageLevel="JDK_1_8" default="true" project-jdk-name="1.8" project-jdk-type="JavaSDK" />
|
||||
</project>
|
||||
124
.idea/uiDesigner.xml
generated
124
.idea/uiDesigner.xml
generated
@@ -1,124 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<project version="4">
|
||||
<component name="Palette2">
|
||||
<group name="Swing">
|
||||
<item class="com.intellij.uiDesigner.HSpacer" tooltip-text="Horizontal Spacer" icon="/com/intellij/uiDesigner/icons/hspacer.svg" removable="false" auto-create-binding="false" can-attach-label="false">
|
||||
<default-constraints vsize-policy="1" hsize-policy="6" anchor="0" fill="1" />
|
||||
</item>
|
||||
<item class="com.intellij.uiDesigner.VSpacer" tooltip-text="Vertical Spacer" icon="/com/intellij/uiDesigner/icons/vspacer.svg" removable="false" auto-create-binding="false" can-attach-label="false">
|
||||
<default-constraints vsize-policy="6" hsize-policy="1" anchor="0" fill="2" />
|
||||
</item>
|
||||
<item class="javax.swing.JPanel" icon="/com/intellij/uiDesigner/icons/panel.svg" removable="false" auto-create-binding="false" can-attach-label="false">
|
||||
<default-constraints vsize-policy="3" hsize-policy="3" anchor="0" fill="3" />
|
||||
</item>
|
||||
<item class="javax.swing.JScrollPane" icon="/com/intellij/uiDesigner/icons/scrollPane.svg" removable="false" auto-create-binding="false" can-attach-label="true">
|
||||
<default-constraints vsize-policy="7" hsize-policy="7" anchor="0" fill="3" />
|
||||
</item>
|
||||
<item class="javax.swing.JButton" icon="/com/intellij/uiDesigner/icons/button.svg" removable="false" auto-create-binding="true" can-attach-label="false">
|
||||
<default-constraints vsize-policy="0" hsize-policy="3" anchor="0" fill="1" />
|
||||
<initial-values>
|
||||
<property name="text" value="Button" />
|
||||
</initial-values>
|
||||
</item>
|
||||
<item class="javax.swing.JRadioButton" icon="/com/intellij/uiDesigner/icons/radioButton.svg" removable="false" auto-create-binding="true" can-attach-label="false">
|
||||
<default-constraints vsize-policy="0" hsize-policy="3" anchor="8" fill="0" />
|
||||
<initial-values>
|
||||
<property name="text" value="RadioButton" />
|
||||
</initial-values>
|
||||
</item>
|
||||
<item class="javax.swing.JCheckBox" icon="/com/intellij/uiDesigner/icons/checkBox.svg" removable="false" auto-create-binding="true" can-attach-label="false">
|
||||
<default-constraints vsize-policy="0" hsize-policy="3" anchor="8" fill="0" />
|
||||
<initial-values>
|
||||
<property name="text" value="CheckBox" />
|
||||
</initial-values>
|
||||
</item>
|
||||
<item class="javax.swing.JLabel" icon="/com/intellij/uiDesigner/icons/label.svg" removable="false" auto-create-binding="false" can-attach-label="false">
|
||||
<default-constraints vsize-policy="0" hsize-policy="0" anchor="8" fill="0" />
|
||||
<initial-values>
|
||||
<property name="text" value="Label" />
|
||||
</initial-values>
|
||||
</item>
|
||||
<item class="javax.swing.JTextField" icon="/com/intellij/uiDesigner/icons/textField.svg" removable="false" auto-create-binding="true" can-attach-label="true">
|
||||
<default-constraints vsize-policy="0" hsize-policy="6" anchor="8" fill="1">
|
||||
<preferred-size width="150" height="-1" />
|
||||
</default-constraints>
|
||||
</item>
|
||||
<item class="javax.swing.JPasswordField" icon="/com/intellij/uiDesigner/icons/passwordField.svg" removable="false" auto-create-binding="true" can-attach-label="true">
|
||||
<default-constraints vsize-policy="0" hsize-policy="6" anchor="8" fill="1">
|
||||
<preferred-size width="150" height="-1" />
|
||||
</default-constraints>
|
||||
</item>
|
||||
<item class="javax.swing.JFormattedTextField" icon="/com/intellij/uiDesigner/icons/formattedTextField.svg" removable="false" auto-create-binding="true" can-attach-label="true">
|
||||
<default-constraints vsize-policy="0" hsize-policy="6" anchor="8" fill="1">
|
||||
<preferred-size width="150" height="-1" />
|
||||
</default-constraints>
|
||||
</item>
|
||||
<item class="javax.swing.JTextArea" icon="/com/intellij/uiDesigner/icons/textArea.svg" removable="false" auto-create-binding="true" can-attach-label="true">
|
||||
<default-constraints vsize-policy="6" hsize-policy="6" anchor="0" fill="3">
|
||||
<preferred-size width="150" height="50" />
|
||||
</default-constraints>
|
||||
</item>
|
||||
<item class="javax.swing.JTextPane" icon="/com/intellij/uiDesigner/icons/textPane.svg" removable="false" auto-create-binding="true" can-attach-label="true">
|
||||
<default-constraints vsize-policy="6" hsize-policy="6" anchor="0" fill="3">
|
||||
<preferred-size width="150" height="50" />
|
||||
</default-constraints>
|
||||
</item>
|
||||
<item class="javax.swing.JEditorPane" icon="/com/intellij/uiDesigner/icons/editorPane.svg" removable="false" auto-create-binding="true" can-attach-label="true">
|
||||
<default-constraints vsize-policy="6" hsize-policy="6" anchor="0" fill="3">
|
||||
<preferred-size width="150" height="50" />
|
||||
</default-constraints>
|
||||
</item>
|
||||
<item class="javax.swing.JComboBox" icon="/com/intellij/uiDesigner/icons/comboBox.svg" removable="false" auto-create-binding="true" can-attach-label="true">
|
||||
<default-constraints vsize-policy="0" hsize-policy="2" anchor="8" fill="1" />
|
||||
</item>
|
||||
<item class="javax.swing.JTable" icon="/com/intellij/uiDesigner/icons/table.svg" removable="false" auto-create-binding="true" can-attach-label="false">
|
||||
<default-constraints vsize-policy="6" hsize-policy="6" anchor="0" fill="3">
|
||||
<preferred-size width="150" height="50" />
|
||||
</default-constraints>
|
||||
</item>
|
||||
<item class="javax.swing.JList" icon="/com/intellij/uiDesigner/icons/list.svg" removable="false" auto-create-binding="true" can-attach-label="false">
|
||||
<default-constraints vsize-policy="6" hsize-policy="2" anchor="0" fill="3">
|
||||
<preferred-size width="150" height="50" />
|
||||
</default-constraints>
|
||||
</item>
|
||||
<item class="javax.swing.JTree" icon="/com/intellij/uiDesigner/icons/tree.svg" removable="false" auto-create-binding="true" can-attach-label="false">
|
||||
<default-constraints vsize-policy="6" hsize-policy="6" anchor="0" fill="3">
|
||||
<preferred-size width="150" height="50" />
|
||||
</default-constraints>
|
||||
</item>
|
||||
<item class="javax.swing.JTabbedPane" icon="/com/intellij/uiDesigner/icons/tabbedPane.svg" removable="false" auto-create-binding="true" can-attach-label="false">
|
||||
<default-constraints vsize-policy="3" hsize-policy="3" anchor="0" fill="3">
|
||||
<preferred-size width="200" height="200" />
|
||||
</default-constraints>
|
||||
</item>
|
||||
<item class="javax.swing.JSplitPane" icon="/com/intellij/uiDesigner/icons/splitPane.svg" removable="false" auto-create-binding="false" can-attach-label="false">
|
||||
<default-constraints vsize-policy="3" hsize-policy="3" anchor="0" fill="3">
|
||||
<preferred-size width="200" height="200" />
|
||||
</default-constraints>
|
||||
</item>
|
||||
<item class="javax.swing.JSpinner" icon="/com/intellij/uiDesigner/icons/spinner.svg" removable="false" auto-create-binding="true" can-attach-label="true">
|
||||
<default-constraints vsize-policy="0" hsize-policy="6" anchor="8" fill="1" />
|
||||
</item>
|
||||
<item class="javax.swing.JSlider" icon="/com/intellij/uiDesigner/icons/slider.svg" removable="false" auto-create-binding="true" can-attach-label="false">
|
||||
<default-constraints vsize-policy="0" hsize-policy="6" anchor="8" fill="1" />
|
||||
</item>
|
||||
<item class="javax.swing.JSeparator" icon="/com/intellij/uiDesigner/icons/separator.svg" removable="false" auto-create-binding="false" can-attach-label="false">
|
||||
<default-constraints vsize-policy="6" hsize-policy="6" anchor="0" fill="3" />
|
||||
</item>
|
||||
<item class="javax.swing.JProgressBar" icon="/com/intellij/uiDesigner/icons/progressbar.svg" removable="false" auto-create-binding="true" can-attach-label="false">
|
||||
<default-constraints vsize-policy="0" hsize-policy="6" anchor="0" fill="1" />
|
||||
</item>
|
||||
<item class="javax.swing.JToolBar" icon="/com/intellij/uiDesigner/icons/toolbar.svg" removable="false" auto-create-binding="false" can-attach-label="false">
|
||||
<default-constraints vsize-policy="0" hsize-policy="6" anchor="0" fill="1">
|
||||
<preferred-size width="-1" height="20" />
|
||||
</default-constraints>
|
||||
</item>
|
||||
<item class="javax.swing.JToolBar$Separator" icon="/com/intellij/uiDesigner/icons/toolbarSeparator.svg" removable="false" auto-create-binding="false" can-attach-label="false">
|
||||
<default-constraints vsize-policy="0" hsize-policy="0" anchor="0" fill="1" />
|
||||
</item>
|
||||
<item class="javax.swing.JScrollBar" icon="/com/intellij/uiDesigner/icons/scrollbar.svg" removable="false" auto-create-binding="true" can-attach-label="false">
|
||||
<default-constraints vsize-policy="6" hsize-policy="0" anchor="0" fill="2" />
|
||||
</item>
|
||||
</group>
|
||||
</component>
|
||||
</project>
|
||||
6
.idea/vcs.xml
generated
6
.idea/vcs.xml
generated
@@ -1,6 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<project version="4">
|
||||
<component name="VcsDirectoryMappings">
|
||||
<mapping directory="" vcs="Git" />
|
||||
</component>
|
||||
</project>
|
||||
88
.idea/workspace.xml
generated
88
.idea/workspace.xml
generated
@@ -1,88 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<project version="4">
|
||||
<component name="AutoImportSettings">
|
||||
<option name="autoReloadType" value="SELECTIVE" />
|
||||
</component>
|
||||
<component name="ChangeListManager">
|
||||
<list default="true" id="78fccc4f-112b-4fb4-8f59-c375aeac8595" name="Changes" comment="">
|
||||
<change beforePath="$PROJECT_DIR$/app/src/main/java/sudoku/Symbole.java" beforeDir="false" afterPath="$PROJECT_DIR$/app/src/main/java/sudoku/Symbole.java" afterDir="false" />
|
||||
</list>
|
||||
<option name="SHOW_DIALOG" value="false" />
|
||||
<option name="HIGHLIGHT_CONFLICTS" value="true" />
|
||||
<option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
|
||||
<option name="LAST_RESOLUTION" value="IGNORE" />
|
||||
</component>
|
||||
<component name="ExternalProjectsData">
|
||||
<projectState path="$PROJECT_DIR$">
|
||||
<ProjectState />
|
||||
</projectState>
|
||||
</component>
|
||||
<component name="Git.Settings">
|
||||
<option name="RECENT_GIT_ROOT_PATH" value="$PROJECT_DIR$" />
|
||||
</component>
|
||||
<component name="ProjectColorInfo"><![CDATA[{
|
||||
"associatedIndex": 6
|
||||
}]]></component>
|
||||
<component name="ProjectId" id="2rwHskpjH0QskAu0G8vmtPc1Ozz" />
|
||||
<component name="ProjectViewState">
|
||||
<option name="hideEmptyMiddlePackages" value="true" />
|
||||
<option name="showLibraryContents" value="true" />
|
||||
</component>
|
||||
<component name="PropertiesComponent"><![CDATA[{
|
||||
"keyToString": {
|
||||
"RunOnceActivity.ShowReadmeOnStart": "true",
|
||||
"RunOnceActivity.git.unshallow": "true",
|
||||
"git-widget-placeholder": "feature/solveur",
|
||||
"kotlin-language-version-configured": "true",
|
||||
"last_opened_file_path": "/usr/lib/jvm/java-21-openjdk",
|
||||
"node.js.detected.package.eslint": "true",
|
||||
"node.js.detected.package.tslint": "true",
|
||||
"node.js.selected.package.eslint": "(autodetect)",
|
||||
"node.js.selected.package.tslint": "(autodetect)",
|
||||
"nodejs_package_manager_path": "npm",
|
||||
"project.structure.last.edited": "Project",
|
||||
"project.structure.proportion": "0.0",
|
||||
"project.structure.side.proportion": "0.0",
|
||||
"settings.editor.selected.configurable": "reference.projectsettings.compiler.javacompiler",
|
||||
"vue.rearranger.settings.migration": "true"
|
||||
}
|
||||
}]]></component>
|
||||
<component name="RunManager">
|
||||
<configuration default="true" type="JetRunConfigurationType">
|
||||
<method v="2">
|
||||
<option name="Make" enabled="true" />
|
||||
</method>
|
||||
</configuration>
|
||||
<configuration default="true" type="KotlinStandaloneScriptRunConfigurationType">
|
||||
<option name="filePath" />
|
||||
<method v="2" />
|
||||
</configuration>
|
||||
</component>
|
||||
<component name="SharedIndexes">
|
||||
<attachedChunks>
|
||||
<set>
|
||||
<option value="bundled-jdk-9823dce3aa75-125ca727e0f0-intellij.indexing.shared.core-IU-243.23654.117" />
|
||||
<option value="bundled-js-predefined-d6986cc7102b-822845ee3bb5-JavaScript-IU-243.23654.117" />
|
||||
</set>
|
||||
</attachedChunks>
|
||||
</component>
|
||||
<component name="SpellCheckerSettings" RuntimeDictionaries="0" Folders="0" CustomDictionaries="0" DefaultDictionary="application-level" UseSingleDictionary="true" transferred="true" />
|
||||
<component name="TaskManager">
|
||||
<task active="true" id="Default" summary="Default task">
|
||||
<changelist id="78fccc4f-112b-4fb4-8f59-c375aeac8595" name="Changes" comment="" />
|
||||
<created>1737463425999</created>
|
||||
<option name="number" value="Default" />
|
||||
<option name="presentableId" value="Default" />
|
||||
<updated>1737463425999</updated>
|
||||
<workItem from="1737463427147" duration="1086000" />
|
||||
</task>
|
||||
<servers />
|
||||
</component>
|
||||
<component name="TypeScriptGeneratedFilesManager">
|
||||
<option name="version" value="3" />
|
||||
</component>
|
||||
<component name="XSLT-Support.FileAssociations.UIState">
|
||||
<expand />
|
||||
<select />
|
||||
</component>
|
||||
</project>
|
||||
3
.vscode/settings.json
vendored
3
.vscode/settings.json
vendored
@@ -1,3 +0,0 @@
|
||||
{
|
||||
"java.configuration.updateBuildConfiguration": "automatic"
|
||||
}
|
||||
@@ -1,18 +1,31 @@
|
||||
package sudoku;
|
||||
|
||||
import java.util.logging.Level;
|
||||
import java.util.logging.Logger;
|
||||
|
||||
/**
|
||||
* Classe principale de l'application sudoku.
|
||||
*/
|
||||
public class App {
|
||||
public String getGreeting() {
|
||||
return "Hello World!";
|
||||
private static final Logger logger = Logger.getLogger(App.class.getName());
|
||||
|
||||
/**
|
||||
* Constructeur privé pour empêcher l'instanciation de la classe App.
|
||||
*/
|
||||
private App() {
|
||||
}
|
||||
|
||||
/**
|
||||
* Méthode main permettant de lancer l'application sudoku et d'afficher les
|
||||
* erreurs s'il y en a.
|
||||
*
|
||||
* @param args : arguments passés en paramètre
|
||||
*/
|
||||
public static void main(String[] args) {
|
||||
System.out.println(new App().getGreeting());
|
||||
|
||||
try{
|
||||
try {
|
||||
Sudoku.menu();
|
||||
} catch (Exception e){
|
||||
System.err.println("Une erreur fatale est survenue : " + e.getMessage());
|
||||
e.printStackTrace();
|
||||
} catch (Exception e) {
|
||||
logger.log(Level.SEVERE, "Une erreur fatale est survenue : " + e.getMessage(), e);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -3,29 +3,58 @@ package sudoku;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Classe permettant de créer un bloc de couleur.
|
||||
*/
|
||||
public class Bloc {
|
||||
private final List<Case> cases;
|
||||
private final String couleur;
|
||||
private final int couleurIndex;
|
||||
|
||||
/**
|
||||
* Constructeur permettant de créer un bloc de couleur
|
||||
*
|
||||
* @param couleur : couleur du bloc
|
||||
* @param couleurIndex : index de la couleur
|
||||
*/
|
||||
public Bloc(String couleur, int couleurIndex) {
|
||||
this.cases = new ArrayList<>();
|
||||
this.couleur = couleur;
|
||||
this.couleurIndex = couleurIndex;
|
||||
}
|
||||
|
||||
/**
|
||||
* Méthode permettant d'ajouter une case à un bloc
|
||||
*
|
||||
* @param c : case à ajouter
|
||||
*/
|
||||
public void ajouterCase(Case c) {
|
||||
cases.add(c);
|
||||
}
|
||||
|
||||
/**
|
||||
* Méthode permettant de renvoyer la couleur d'un bloc
|
||||
*
|
||||
* @return couleur du bloc
|
||||
*/
|
||||
public String getCouleur() {
|
||||
return couleur;
|
||||
}
|
||||
|
||||
/**
|
||||
* Méthode permettant de renvoyer une liste de cases associée à un bloc
|
||||
*
|
||||
* @return liste de cases
|
||||
*/
|
||||
public List<Case> getCases() {
|
||||
return cases;
|
||||
}
|
||||
|
||||
/**
|
||||
* Méthode permettant d'afficher un bloc complet avec les cases qui le composent
|
||||
*
|
||||
* @return bloc complet avec les cases, la couleur et l'index de la couleur
|
||||
*/
|
||||
@Override
|
||||
public String toString() {
|
||||
return "Bloc [cases=" + cases + ", couleur=" + couleur + ", couleurIndex=" + couleurIndex + " \u001B[0m]";
|
||||
|
||||
@@ -1,32 +1,69 @@
|
||||
package sudoku;
|
||||
|
||||
/**
|
||||
* Classe permettant de créer une case.
|
||||
*/
|
||||
public class Case {
|
||||
private final int ligne;
|
||||
private final int colonne;
|
||||
private Symbole symbole;
|
||||
|
||||
/**
|
||||
* Constructeur permettant de créer une case grace aux paramètres suivants :
|
||||
*
|
||||
* @param ligne : coordonnée de la ligne
|
||||
* @param colonne : coordonnée de la colonne
|
||||
* @param symbole : symbole de la case
|
||||
*/
|
||||
public Case(int ligne, int colonne, Symbole symbole) {
|
||||
this.ligne = ligne;
|
||||
this.colonne = colonne;
|
||||
this.symbole = symbole;
|
||||
}
|
||||
|
||||
/**
|
||||
* Méthode permettant de renvoyer la coordonnée de la ligne qui compose la case
|
||||
*
|
||||
* @return ligne
|
||||
*/
|
||||
public int getLigne() {
|
||||
return ligne;
|
||||
}
|
||||
|
||||
/**
|
||||
* Méthode permettant de renvoyer la coordonnée de la colonne qui compose la
|
||||
* case
|
||||
*
|
||||
* @return colonne
|
||||
*/
|
||||
public int getColonne() {
|
||||
return colonne;
|
||||
}
|
||||
|
||||
/**
|
||||
* Méthode permettant de renvoyer le symbole qui compose la case
|
||||
*
|
||||
* @return symbole
|
||||
*/
|
||||
public Symbole getSymbole() {
|
||||
return symbole;
|
||||
}
|
||||
|
||||
/**
|
||||
* Méthode permettant de modifier le symbole qui compose la case
|
||||
*
|
||||
* @param symbole : symbole de la case
|
||||
*/
|
||||
public void setSymbole(Symbole symbole) {
|
||||
this.symbole = symbole;
|
||||
}
|
||||
|
||||
/**
|
||||
* Méthode qui permet d'afficher le symbole de la case ou "-" si la case est
|
||||
* vide
|
||||
*
|
||||
* @return symbole de la case
|
||||
*/
|
||||
@Override
|
||||
public String toString() {
|
||||
return (symbole == null) ? "-" : symbole.toString();
|
||||
|
||||
@@ -1,5 +1,17 @@
|
||||
package sudoku;
|
||||
|
||||
/**
|
||||
* Interface permettant d'évaluer toutes les contraintes et de retourner un
|
||||
* boolean indiquant si elles ont étés respectées.
|
||||
*/
|
||||
public interface Contrainte {
|
||||
/**
|
||||
* Méthode permettant de savoir si l'ensemble des contraintes concernant une
|
||||
* case sont respectées.
|
||||
*
|
||||
* @param grille : Grille
|
||||
* @param c : Case
|
||||
* @return boolean : true si toutes les contraintes sont respectées, false sinon
|
||||
*/
|
||||
boolean estRespectee(Grille grille, Case c);
|
||||
}
|
||||
|
||||
@@ -1,15 +1,41 @@
|
||||
package sudoku;
|
||||
|
||||
/**
|
||||
* Implémentation de l'interface Contrainte sur les blocs.
|
||||
* Cette classe permet de vérifier si les contraintes sur les blocs sont
|
||||
* respectées.
|
||||
*/
|
||||
public class ContrainteBloc implements Contrainte {
|
||||
private final int blocRows;
|
||||
private final int blocCols;
|
||||
|
||||
/**
|
||||
* Constructeur permettant de créer une contrainte de bloc
|
||||
*
|
||||
* @param blocRows : nombre de lignes du bloc
|
||||
* @param blocCols : nombre de colonnes du bloc
|
||||
*/
|
||||
public ContrainteBloc(int blocRows, int blocCols) {
|
||||
this.blocRows = blocRows;
|
||||
this.blocCols = blocCols;
|
||||
}
|
||||
|
||||
/**
|
||||
* Méthode permettant de savoir pour une case donnée si l'ensemble des
|
||||
* contraintes concernant le bloc sont respectées.<br />
|
||||
*
|
||||
* @param grille : Grille
|
||||
* @param c : Case
|
||||
* @return boolean : true si toutes les contraintes sont respectées, false sinon
|
||||
*/
|
||||
@Override
|
||||
public boolean estRespectee(Grille grille, Case c) {
|
||||
int blocSize = (int) Math.sqrt(grille.getTaille());
|
||||
int startRow = (c.getLigne() / blocSize) * blocSize;
|
||||
int startCol = (c.getColonne() / blocSize) * blocSize;
|
||||
int startRow = (c.getLigne() / blocRows) * blocRows;
|
||||
int startCol = (c.getColonne() / blocCols) * blocCols;
|
||||
Symbole symbole = c.getSymbole();
|
||||
|
||||
for (int i = 0; i < blocSize; i++) {
|
||||
for (int j = 0; j < blocSize; j++) {
|
||||
|
||||
for (int i = 0; i < blocRows; i++) {
|
||||
for (int j = 0; j < blocCols; j++) {
|
||||
Case currentCase = grille.getCase(startRow + i, startCol + j);
|
||||
if (currentCase != c && currentCase.getSymbole() != null && currentCase.getSymbole().equals(symbole)) {
|
||||
return false;
|
||||
|
||||
@@ -1,6 +1,26 @@
|
||||
package sudoku;
|
||||
|
||||
/**
|
||||
* Implémentation de l'interface Contrainte sur les colonnes.
|
||||
* Cette classe permet de vérifier si les contraintes sur les colonnes sont
|
||||
* respectées.
|
||||
*/
|
||||
public class ContrainteColonne implements Contrainte {
|
||||
|
||||
/**
|
||||
* Constructeur de la classe ContrainteColonne
|
||||
*/
|
||||
public ContrainteColonne() {
|
||||
}
|
||||
|
||||
/**
|
||||
* Méthode permettant de savoir pour une case donnée si l'ensemble des
|
||||
* contraintes concernant la colonne sont respectées.<br />
|
||||
*
|
||||
* @param grille : Grille
|
||||
* @param c : Case
|
||||
* @return boolean : true si toutes les contraintes sont respectées, false sinon
|
||||
*/
|
||||
@Override
|
||||
public boolean estRespectee(Grille grille, Case c) {
|
||||
int colonne = c.getColonne();
|
||||
|
||||
@@ -1,6 +1,28 @@
|
||||
package sudoku;
|
||||
|
||||
/**
|
||||
* Implémentation de l'interface Contrainte sur les lignes.
|
||||
* Cette classe permet de vérifier si les contraintes sur les lignes sont
|
||||
* respectées.
|
||||
*/
|
||||
public class ContrainteLigne implements Contrainte {
|
||||
|
||||
/**
|
||||
* Constructeur de la classe ContrainteLigne
|
||||
*/
|
||||
public ContrainteLigne() {
|
||||
}
|
||||
|
||||
/**
|
||||
* Méthode permettant de savoir si l'ensemble des contraintes concernant la
|
||||
* ligne sont respectées.<br />
|
||||
* Renvoie 0 si au moins l'une des contraintes n'est pas respectée<br />
|
||||
* Renvoie 1 si toutes les contraintes sont respectées
|
||||
*
|
||||
* @param grille : Grille
|
||||
* @param c : Case
|
||||
* @return boolean : true si toutes les contraintes sont respectées, false sinon
|
||||
*/
|
||||
@Override
|
||||
public boolean estRespectee(Grille grille, Case c) {
|
||||
int ligne = c.getLigne();
|
||||
|
||||
@@ -6,8 +6,11 @@ import java.util.Objects;
|
||||
import java.util.Scanner;
|
||||
|
||||
import sudoku.core.Console;
|
||||
import sudoku.gui.ColorGenerator;
|
||||
import sudoku.core.GenerateurCouleur;
|
||||
|
||||
/**
|
||||
* Classe Grille permettant de créer une grille de sudoku.
|
||||
*/
|
||||
public class Grille {
|
||||
private final int taille;
|
||||
private final Case[][] cases;
|
||||
@@ -17,6 +20,13 @@ public class Grille {
|
||||
private Multidoku multidoku; // Référence à Multidoku
|
||||
private List<String> generatedColors;
|
||||
|
||||
/**
|
||||
* Constructeur permettant d'initialiser une grille grace aux paramètres
|
||||
* suivants :
|
||||
*
|
||||
* @param taille : taille de la grille
|
||||
* @param sudoku : sudoku
|
||||
*/
|
||||
public Grille(int taille, Sudoku sudoku) {
|
||||
this.taille = taille;
|
||||
this.cases = new Case[taille][taille];
|
||||
@@ -33,6 +43,12 @@ public class Grille {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Méthode permettant de mettre à jour la référence au multidoku
|
||||
*
|
||||
* @param multidoku : multidoku
|
||||
* @see Multidoku
|
||||
*/
|
||||
public void setMultidoku(Multidoku multidoku) {
|
||||
this.multidoku = multidoku;
|
||||
}
|
||||
@@ -44,20 +60,34 @@ public class Grille {
|
||||
*/
|
||||
private void initColors() {
|
||||
// nombre de couleurs = nombre de blocs (pour sudoku classique)
|
||||
List<ColorGenerator.Color> colors = ColorGenerator.greatScheme(taille);
|
||||
List<GenerateurCouleur.Couleur> colors = GenerateurCouleur.paletteCouleurEtendue(taille);
|
||||
generatedColors = new ArrayList<>();
|
||||
for (ColorGenerator.Color color : colors) {
|
||||
for (GenerateurCouleur.Couleur color : colors) {
|
||||
generatedColors.add(convertToAnsi(color));
|
||||
}
|
||||
}
|
||||
|
||||
private String convertToAnsi(ColorGenerator.Color color) {
|
||||
/**
|
||||
* Convertit une couleur en format ANSI pour l'affichage en console.
|
||||
*
|
||||
* @param color : couleur à convertir
|
||||
* @return couleur convertie
|
||||
*/
|
||||
private String convertToAnsi(GenerateurCouleur.Couleur color) {
|
||||
int r = Math.round(color.r * 255);
|
||||
int g = Math.round(color.g * 255);
|
||||
int b = Math.round(color.b * 255);
|
||||
return String.format("\u001B[38;2;%d;%d;%dm", r, g, b);
|
||||
}
|
||||
|
||||
/**
|
||||
* Méthode permettant de définir un symbole dans une case en fonction de sa
|
||||
* ligne, de sa colonne et du symbole
|
||||
*
|
||||
* @param ligne : coordonnée de la ligne
|
||||
* @param colonne : coordonnée de la colonne
|
||||
* @param symbole : symbole à placer
|
||||
*/
|
||||
public void setCase(int ligne, int colonne, Symbole symbole) {
|
||||
try {
|
||||
if (symbole != null && !symbolesPossibles.contains(symbole)) {
|
||||
@@ -79,26 +109,37 @@ public class Grille {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Méthode permettant de retourner une case en fonction de sa ligne et de sa
|
||||
* colonne
|
||||
*
|
||||
* @param ligne : coordonnée de la ligne
|
||||
* @param colonne : coordonnée de la colonne
|
||||
* @return Case
|
||||
*/
|
||||
public Case getCase(int ligne, int colonne) {
|
||||
return cases[ligne][colonne];
|
||||
}
|
||||
|
||||
/**
|
||||
* Crée un bloc personnalisé à partir des positions spécifiées.
|
||||
* La couleur du bloc est choisie de façon cyclique dans la palette générée.
|
||||
* Méthode permettant de créer un bloc personnalisé en fonction des positions
|
||||
* passées en paramètre <br />
|
||||
* <br />
|
||||
*
|
||||
* Exemple d'utilisation :
|
||||
* sudoku.getGrille().creerBlocPersonnalise(Arrays.asList(
|
||||
* new int[] { 0, 0 },
|
||||
* new int[] { 0, 1 },
|
||||
* new int[] { 0, 2 },
|
||||
* new int[] { 1, 0 },
|
||||
* new int[] { 1, 1 },
|
||||
* new int[] { 1, 2 },
|
||||
* new int[] { 2, 0 },
|
||||
* new int[] { 2, 1 },
|
||||
* new int[] { 2, 2 }
|
||||
* ));
|
||||
* Exemple de positions pour un sudoku 9x9 : <br />
|
||||
* sudoku.getGrille().creerBlocPersonnalise(Arrays.asList( <br />
|
||||
* new int[] { 0, 0 }, <br />
|
||||
* new int[] { 0, 1 }, <br />
|
||||
* new int[] { 0, 2 }, <br />
|
||||
* new int[] { 1, 0 }, <br />
|
||||
* new int[] { 1, 1 }, <br />
|
||||
* new int[] { 1, 2 }, <br />
|
||||
* new int[] { 2, 0 }, <br />
|
||||
* new int[] { 2, 1 }, <br />
|
||||
* new int[] { 2, 2 } <br />
|
||||
* );
|
||||
*
|
||||
* @param positions : liste de positions pour le bloc personnalisé <br />
|
||||
*/
|
||||
public void creerBlocPersonnalise(List<int[]> positions) {
|
||||
try {
|
||||
@@ -157,9 +198,10 @@ public class Grille {
|
||||
}
|
||||
|
||||
/**
|
||||
* Crée des blocs rectangulaires automatiquement à partir de la taille de la
|
||||
* grille.
|
||||
* Ne fonctionne pas pour les grilles dont la taille est un carré parfait.
|
||||
* Crée des blocs rectangulaires.
|
||||
*
|
||||
* @param blocHeight : hauteur du bloc
|
||||
* @param blocWidth : largeur du bloc
|
||||
*/
|
||||
public void creerBlocRectangulaire(int blocHeight, int blocWidth) {
|
||||
if (taille % blocHeight != 0 || taille % blocWidth != 0) {
|
||||
@@ -190,12 +232,23 @@ public class Grille {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Méthode permettant d'afficher les blocs de la grille à l'aide de la méthode
|
||||
* toString de la classe Bloc.
|
||||
*/
|
||||
public void printBlocs() {
|
||||
for (Bloc bloc : blocs) {
|
||||
System.out.println(bloc.toString());
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Méthode utilisée pour le menu princial.
|
||||
* Méthode permettant de choisir le type de symbole à utiliser pour la grille
|
||||
*
|
||||
* @param scanner : scanner pour lire l'entrée utilisateur
|
||||
* @return int : choix de l'utilisateur
|
||||
*/
|
||||
public static int choisirTypeSymbole(Scanner scanner) {
|
||||
while (true) {
|
||||
System.out.println("Choisissez le type de symbole :");
|
||||
@@ -217,6 +270,14 @@ public class Grille {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Méthode utilisée pour le menu principal.
|
||||
* Méthode permettant de demander à l'utilisateur de saisir les symboles
|
||||
* possibles pour la grille.
|
||||
*
|
||||
* @param choix : choix de l'utilisateur
|
||||
* @param scanner : scanner pour lire l'entrée utilisateur
|
||||
*/
|
||||
public void askSetSymbolesPossibles(int choix, Scanner scanner) {
|
||||
try {
|
||||
for (int i = 0; i < taille; i++) {
|
||||
@@ -274,17 +335,34 @@ public class Grille {
|
||||
}
|
||||
} catch (Exception e) {
|
||||
Console.errorln("Une erreur est survenue : " + e.getMessage());
|
||||
Console.errorln("Une erreur est survenue : " + e.getMessage());
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Méthode permettant de retourner la liste des symboles possible.
|
||||
* Cela dépend de ce que saisit l'utilisateur dans la méthode
|
||||
* askSetSymbolesPossibles
|
||||
*
|
||||
* @return List la liste des symboles possibles
|
||||
* @see Symbole
|
||||
*/
|
||||
public List<Symbole> getSymbolesPossibles() {
|
||||
return symbolesPossibles;
|
||||
}
|
||||
|
||||
/**
|
||||
* Méthode permettant d'ajouter un symbole à la liste des symboles possibles
|
||||
*
|
||||
* @param symbolesPossibles : liste des symboles possibles
|
||||
*/
|
||||
public void setSymbolesPossibles(ArrayList<Symbole> symbolesPossibles) {
|
||||
this.symbolesPossibles = symbolesPossibles;
|
||||
}
|
||||
|
||||
/**
|
||||
* Méthode permettant d'afficher la liste des symboles possibles
|
||||
*/
|
||||
public void printSymbolesPossibles() {
|
||||
StringBuilder sb = new StringBuilder();
|
||||
for (Symbole symbole : symbolesPossibles) {
|
||||
@@ -293,6 +371,11 @@ public class Grille {
|
||||
System.out.println(sb);
|
||||
}
|
||||
|
||||
/**
|
||||
* Méthode permettant de retourner la taille de la grille
|
||||
*
|
||||
* @return taille
|
||||
*/
|
||||
public int getTaille() {
|
||||
return taille;
|
||||
}
|
||||
@@ -303,15 +386,15 @@ public class Grille {
|
||||
return bloc;
|
||||
}
|
||||
}
|
||||
return null; // Ne devrait jamais arriver si la grille est bien construite
|
||||
return null; // Ne dois jamais arriver si la grille est bien construite
|
||||
}
|
||||
|
||||
/**
|
||||
* Vérifie si toutes les contraintes sont respectées.
|
||||
* S'arrête dès qu'une contrainte n'est pas respectée.
|
||||
*
|
||||
* @param contraintes
|
||||
* @return
|
||||
* @param contraintes : liste des contraintes à vérifier
|
||||
* @return true si toutes les contraintes sont respectées, false sinon
|
||||
*/
|
||||
public boolean verifierToutesContraintes(List<Contrainte> contraintes) {
|
||||
// Vérifier chaque case de la grille
|
||||
@@ -334,6 +417,12 @@ public class Grille {
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Méthode permettant de retourner la longueur du symbole le plus long pour
|
||||
* dimensionner correctement les cases et la grille en console
|
||||
*
|
||||
* @return int
|
||||
*/
|
||||
public int getLongueurSymboleLePlusLong() {
|
||||
int max = 0;
|
||||
for (Symbole symbole : symbolesPossibles) {
|
||||
@@ -344,6 +433,11 @@ public class Grille {
|
||||
return max;
|
||||
}
|
||||
|
||||
/**
|
||||
* Méthode permettant d'afficher la grille
|
||||
*
|
||||
* @return String : représentation de la grille
|
||||
*/
|
||||
@Override
|
||||
public String toString() {
|
||||
StringBuilder sb = new StringBuilder();
|
||||
|
||||
@@ -1,22 +1,47 @@
|
||||
package sudoku;
|
||||
|
||||
import java.util.*;
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.Set;
|
||||
|
||||
/**
|
||||
* Classe représentant un Multidoku, c'est-à-dire une grille combinée de
|
||||
* plusieurs
|
||||
* sudokus, avec des contraintes de partage entre les cases.
|
||||
*/
|
||||
public class Multidoku {
|
||||
private final List<SudokuPlacement> placements = new ArrayList<>();
|
||||
private final List<ContrainteCasePartagee> contraintesPartagees;
|
||||
|
||||
/**
|
||||
* Constructeur de la classe Multidoku.
|
||||
*/
|
||||
public Multidoku() {
|
||||
this.contraintesPartagees = new ArrayList<>();
|
||||
}
|
||||
|
||||
/**
|
||||
* Ajoute un sudoku à la grille combinée, avec un décalage spécifié par rapport
|
||||
* à l'origine.
|
||||
*
|
||||
* @param sudoku : sudoku à ajouter
|
||||
* @param offsetLigne : décalage de la ligne
|
||||
* @param offsetColonne : décalage de la colonne
|
||||
*/
|
||||
public void ajouterSudoku(Sudoku sudoku, int offsetLigne, int offsetColonne) {
|
||||
placements.add(new SudokuPlacement(sudoku, offsetLigne, offsetColonne));
|
||||
sudoku.getGrille().setMultidoku(this);
|
||||
}
|
||||
|
||||
/**
|
||||
* Ajoute une contrainte de partage entre les cases spécifiées.
|
||||
*
|
||||
* @param cases : liste de cases partagées
|
||||
*/
|
||||
public void ajouterCasesPartagees(List<Case> cases) {
|
||||
ContrainteCasePartagee contrainte = new ContrainteCasePartagee(cases, this);
|
||||
ContrainteCasePartagee contrainte = new ContrainteCasePartagee(cases);
|
||||
contraintesPartagees.add(contrainte);
|
||||
|
||||
// Vérifier immédiatement la validité après l'ajout
|
||||
@@ -26,11 +51,23 @@ public class Multidoku {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Résout le Multidoku en utilisant un algorithme de backtracking.
|
||||
*
|
||||
* @param afficherEtape : true pour afficher les étapes de résolution
|
||||
* @return true si une solution a été trouvée, false sinon
|
||||
*/
|
||||
public boolean resoudreMultidoku(boolean afficherEtape) {
|
||||
List<GlobalCell> globalCells = collecterCellulesVides();
|
||||
return resoudreGlobal(globalCells, 0, afficherEtape);
|
||||
}
|
||||
|
||||
/**
|
||||
* Collecte toutes les cases vides d'abord pour les cases partagées, puis pour
|
||||
* les cases non partagées de la grille combinée.
|
||||
*
|
||||
* @return liste de cases vides
|
||||
*/
|
||||
private List<GlobalCell> collecterCellulesVides() {
|
||||
List<GlobalCell> cells = new ArrayList<>();
|
||||
// Ajout d'abord des cases partagées
|
||||
@@ -44,7 +81,7 @@ public class Multidoku {
|
||||
}
|
||||
// Ajout ensuite des cases non partagées
|
||||
for (SudokuPlacement sp : placements) {
|
||||
Sudoku s = sp.getSudoku();
|
||||
Sudoku s = sp.sudoku();
|
||||
Grille g = s.getGrille();
|
||||
int taille = g.getTaille();
|
||||
for (int i = 0; i < taille; i++) {
|
||||
@@ -59,6 +96,15 @@ public class Multidoku {
|
||||
return cells;
|
||||
}
|
||||
|
||||
/**
|
||||
* Résout récursivement les cases vides de la grille combinée, en utilisant un
|
||||
* algorithme de backtracking.
|
||||
*
|
||||
* @param globalCells : liste de cases vides
|
||||
* @param index : index de la case actuelle
|
||||
* @param afficherEtape : true pour afficher les étapes de résolution
|
||||
* @return true si une solution a été trouvée, false sinon
|
||||
*/
|
||||
private boolean resoudreGlobal(List<GlobalCell> globalCells, int index, boolean afficherEtape) {
|
||||
if (index == globalCells.size()) {
|
||||
return true;
|
||||
@@ -78,7 +124,7 @@ public class Multidoku {
|
||||
if (afficherEtape) {
|
||||
System.out.println("\nTentative symbole " + symbole + " sur " + gc.sudoku.getNom() + " [" + gc.ligne
|
||||
+ "," + gc.colonne + "]");
|
||||
System.out.println(this.toStringCombined()); // Afficher l'état actuel
|
||||
System.out.println(this); // Afficher l'état actuel
|
||||
}
|
||||
|
||||
boolean ok;
|
||||
@@ -96,7 +142,7 @@ public class Multidoku {
|
||||
if (ok) {
|
||||
if (afficherEtape) {
|
||||
System.out.println("-> Affectation réussie pour " + symbole);
|
||||
System.out.println(this.toStringCombined());
|
||||
System.out.println(this);
|
||||
}
|
||||
if (globalValide() && resoudreGlobal(globalCells, index + 1, afficherEtape)) {
|
||||
return true;
|
||||
@@ -106,18 +152,33 @@ public class Multidoku {
|
||||
restaurerCases(sauvegarde);
|
||||
if (afficherEtape) {
|
||||
System.out.println("Backtracking sur " + gc.sudoku.getNom() + " [" + gc.ligne + "," + gc.colonne + "]");
|
||||
System.out.println(this.toStringCombined());
|
||||
System.out.println(this);
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Restaure les cases à leur état précédent en utilisant une sauvegarde.
|
||||
*
|
||||
* @param sauvegarde : sauvegarde des cases à restaurer
|
||||
*/
|
||||
private void restaurerCases(Map<Case, Symbole> sauvegarde) {
|
||||
for (Map.Entry<Case, Symbole> entry : sauvegarde.entrySet()) {
|
||||
entry.getKey().setSymbole(entry.getValue());
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Affecte un symbole à une case, et propage la valeur dans les cases
|
||||
* correspondantes des autres sudokus concernés.
|
||||
*
|
||||
* @param ligne : ligne de la case
|
||||
* @param colonne : colonne de la case
|
||||
* @param symbole : symbole à affecter
|
||||
* @param s : sudoku actuel
|
||||
* @return true si l'affectation est valide, false sinon
|
||||
*/
|
||||
private boolean setCaseAvecPropagation(int ligne, int colonne, Symbole symbole, Sudoku s) {
|
||||
Grille g = s.getGrille();
|
||||
Case c = g.getCase(ligne, colonne);
|
||||
@@ -152,16 +213,29 @@ public class Multidoku {
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Trouve le sudoku auquel appartient une case donnée.
|
||||
*
|
||||
* @param c : case
|
||||
* @return sudoku auquel appartient la case, ou null si non trouvé
|
||||
*/
|
||||
private Sudoku trouverSudokuPourCase(Case c) {
|
||||
for (SudokuPlacement sp : placements) {
|
||||
if (belongsToSudoku(c, sp.getSudoku())) {
|
||||
return sp.getSudoku();
|
||||
if (appartientAuSudoku(c, sp.sudoku())) {
|
||||
return sp.sudoku();
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
private boolean belongsToSudoku(Case c, Sudoku s) {
|
||||
/**
|
||||
* Vérifie si une case appartient à un sudoku donné.
|
||||
*
|
||||
* @param c : case
|
||||
* @param s : sudoku
|
||||
* @return true si la case appartient au sudoku, false sinon
|
||||
*/
|
||||
private boolean appartientAuSudoku(Case c, Sudoku s) {
|
||||
Grille g = s.getGrille();
|
||||
int taille = g.getTaille();
|
||||
for (int i = 0; i < taille; i++) {
|
||||
@@ -174,9 +248,14 @@ public class Multidoku {
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Vérifie si la grille combinée est valide.
|
||||
*
|
||||
* @return true si la grille est valide, false sinon
|
||||
*/
|
||||
private boolean globalValide() {
|
||||
for (SudokuPlacement sp : placements) {
|
||||
if (!sp.getSudoku().estValide())
|
||||
if (!sp.sudoku().estValide())
|
||||
return false;
|
||||
}
|
||||
for (Contrainte c : contraintesPartagees) {
|
||||
@@ -186,11 +265,22 @@ public class Multidoku {
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Vérifie si les contraintes partagées sont respectées.
|
||||
*
|
||||
* @return true si les contraintes sont respectées, false sinon
|
||||
*/
|
||||
public boolean verifierContraintesPartagees() {
|
||||
return contraintesPartagees.stream()
|
||||
.allMatch(c -> c.estRespectee(null, null));
|
||||
}
|
||||
|
||||
/**
|
||||
* Vérifie si une case est partagée.
|
||||
*
|
||||
* @param c : case
|
||||
* @return true si la case est partagée, false sinon
|
||||
*/
|
||||
public boolean isSharedCase(Case c) {
|
||||
for (ContrainteCasePartagee contrainte : contraintesPartagees) {
|
||||
if (contrainte.getCasesLiees().contains(c)) {
|
||||
@@ -200,12 +290,26 @@ public class Multidoku {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Classe utilitaire pour représenter une case vide dans un sudoku particulier
|
||||
/**
|
||||
* Classe interne pour le placement d'un sudoku dans la grille combinée.
|
||||
*/
|
||||
public static class GlobalCell {
|
||||
/** Référence au sudoku auquel appartient cette cellule */
|
||||
public Sudoku sudoku;
|
||||
|
||||
/** Index de ligne dans la grille du sudoku parent */
|
||||
public int ligne;
|
||||
|
||||
/** Index de colonne dans la grille du sudoku parent */
|
||||
public int colonne;
|
||||
|
||||
/**
|
||||
* Constructeur de la cellule globale.
|
||||
*
|
||||
* @param sudoku : sudoku
|
||||
* @param ligne : ligne
|
||||
* @param colonne : colonne
|
||||
*/
|
||||
public GlobalCell(Sudoku sudoku, int ligne, int colonne) {
|
||||
this.sudoku = sudoku;
|
||||
this.ligne = ligne;
|
||||
@@ -213,14 +317,19 @@ public class Multidoku {
|
||||
}
|
||||
}
|
||||
|
||||
// Classe interne pour la contrainte de cases partagées
|
||||
/**
|
||||
* Classe interne pour la contrainte de cases partagées.
|
||||
*/
|
||||
public static class ContrainteCasePartagee implements Contrainte {
|
||||
private final Map<Case, Case> casesLiees; // Map associant chaque case à sa correspondante
|
||||
private final Set<Sudoku> sudokusLies;
|
||||
|
||||
public ContrainteCasePartagee(List<Case> cases, Multidoku multidoku) {
|
||||
/**
|
||||
* Constructeur de la contrainte de cases partagées.
|
||||
*
|
||||
* @param cases : liste de cases partagées
|
||||
*/
|
||||
public ContrainteCasePartagee(List<Case> cases) {
|
||||
this.casesLiees = new HashMap<>();
|
||||
this.sudokusLies = new HashSet<>();
|
||||
|
||||
// Les cases sont données dans l'ordre : d'abord celles du premier sudoku,
|
||||
// puis celles du second dans le même ordre.
|
||||
@@ -230,19 +339,15 @@ public class Multidoku {
|
||||
Case c2 = cases.get(i + size);
|
||||
casesLiees.put(c1, c2);
|
||||
casesLiees.put(c2, c1);
|
||||
|
||||
Sudoku s1 = multidoku.trouverSudokuPourCase(c1);
|
||||
Sudoku s2 = multidoku.trouverSudokuPourCase(c2);
|
||||
if (s1 != null)
|
||||
sudokusLies.add(s1);
|
||||
if (s2 != null)
|
||||
sudokusLies.add(s2);
|
||||
}
|
||||
|
||||
// Propager les valeurs initiales
|
||||
propagerValeursInitiales();
|
||||
}
|
||||
|
||||
/**
|
||||
* Propage les valeurs initiales des cases partagées.
|
||||
*/
|
||||
private void propagerValeursInitiales() {
|
||||
for (Map.Entry<Case, Case> entry : casesLiees.entrySet()) {
|
||||
Case c1 = entry.getKey();
|
||||
@@ -256,6 +361,13 @@ public class Multidoku {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Vérifie si la contrainte de cases partagées est respectée.
|
||||
*
|
||||
* @param grille : grille
|
||||
* @param caseActuelle : case actuelle
|
||||
* @return true si la contrainte est respectée, false sinon
|
||||
*/
|
||||
@Override
|
||||
public boolean estRespectee(Grille grille, Case caseActuelle) {
|
||||
for (Map.Entry<Case, Case> entry : casesLiees.entrySet()) {
|
||||
@@ -270,24 +382,41 @@ public class Multidoku {
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Récupère la case correspondante à une case donnée.
|
||||
*
|
||||
* @param c : case
|
||||
* @return case correspondante
|
||||
*/
|
||||
public Case getCaseCorrespondante(Case c) {
|
||||
return casesLiees.get(c);
|
||||
}
|
||||
|
||||
/**
|
||||
* Récupère la liste des cases partagées.
|
||||
*
|
||||
* @return liste de cases partagées
|
||||
*/
|
||||
public Set<Case> getCasesLiees() {
|
||||
return casesLiees.keySet();
|
||||
}
|
||||
}
|
||||
|
||||
public String toStringCombined() {
|
||||
/**
|
||||
* Méthode toString pour l'affichage de la grille combinée.
|
||||
*
|
||||
* @return String : représentation de la grille combinée
|
||||
*/
|
||||
@Override
|
||||
public String toString() {
|
||||
// 1. Déterminer la taille globale de la grille combinée et la largeur maximale
|
||||
int maxLigne = 0, maxColonne = 0;
|
||||
int globalMaxLen = 0;
|
||||
for (SudokuPlacement sp : placements) {
|
||||
int taille = sp.getSudoku().getGrille().getTaille();
|
||||
maxLigne = Math.max(maxLigne, sp.getOffsetLigne() + taille);
|
||||
maxColonne = Math.max(maxColonne, sp.getOffsetColonne() + taille);
|
||||
globalMaxLen = Math.max(globalMaxLen, sp.getSudoku().getGrille().getLongueurSymboleLePlusLong());
|
||||
int taille = sp.sudoku().getGrille().getTaille();
|
||||
maxLigne = Math.max(maxLigne, sp.offsetLigne() + taille);
|
||||
maxColonne = Math.max(maxColonne, sp.offsetColonne() + taille);
|
||||
globalMaxLen = Math.max(globalMaxLen, sp.sudoku().getGrille().getLongueurSymboleLePlusLong());
|
||||
}
|
||||
|
||||
// On ajoute un espace supplémentaire pour séparer les colonnes
|
||||
@@ -304,13 +433,13 @@ public class Multidoku {
|
||||
// 3. Pour chaque sudoku, placer l'affichage de chacune de ses cases dans la
|
||||
// grille globale
|
||||
for (SudokuPlacement sp : placements) {
|
||||
Grille grille = sp.getSudoku().getGrille();
|
||||
Grille grille = sp.sudoku().getGrille();
|
||||
int taille = grille.getTaille();
|
||||
for (int i = 0; i < taille; i++) {
|
||||
for (int j = 0; j < taille; j++) {
|
||||
// Coordonnées globales calculées à partir de l'offset
|
||||
int globalLigne = sp.getOffsetLigne() + i;
|
||||
int globalColonne = sp.getOffsetColonne() + j;
|
||||
int globalLigne = sp.offsetLigne() + i;
|
||||
int globalColonne = sp.offsetColonne() + j;
|
||||
|
||||
Case currentCase = grille.getCase(i, j);
|
||||
String cellStr = currentCase.toString();
|
||||
|
||||
@@ -1,5 +1,15 @@
|
||||
package sudoku;
|
||||
|
||||
/**
|
||||
* Interface permettant de résoudre un sudoku
|
||||
*/
|
||||
public interface Resolveur {
|
||||
/**
|
||||
* Méthode permettant de résoudre un sudoku
|
||||
*
|
||||
* @param s : sudoku à résoudre
|
||||
* @param afficherEtape : afficher les étapes de la résolution
|
||||
* @return true si le sudoku est résolvable, false sinon
|
||||
*/
|
||||
boolean resoudre(Sudoku s, boolean afficherEtape);
|
||||
}
|
||||
|
||||
@@ -4,8 +4,30 @@ import java.util.List;
|
||||
|
||||
import sudoku.core.Console;
|
||||
|
||||
/**
|
||||
* Implémentation d'un résolveur de Sudoku utilisant l'algorithme de
|
||||
* backtracking.
|
||||
* Cette classe fournit une solution pour résoudre les grilles de Sudoku
|
||||
* en testant systématiquement toutes les possibilités valides.
|
||||
*/
|
||||
public class ResolveurBacktraceSimple implements Resolveur {
|
||||
|
||||
/**
|
||||
* Constructeur par défaut du résolveur backtracking.
|
||||
* Initialise un nouveau résolveur sans état initial.
|
||||
*/
|
||||
public ResolveurBacktraceSimple() {
|
||||
// Constructeur par défaut
|
||||
}
|
||||
|
||||
/**
|
||||
* Méthode permettant de résoudre un sudoku en utilisant la méthode de
|
||||
* backtracking
|
||||
*
|
||||
* @param s : sudoku à résoudre
|
||||
* @param afficherEtape : afficher les étapes de la résolution
|
||||
* @return true si le sudoku est résolvable, false sinon
|
||||
*/
|
||||
@Override
|
||||
public boolean resoudre(Sudoku s, boolean afficherEtape) {
|
||||
EtatResolution etat = new EtatResolution(0, 0);
|
||||
@@ -16,6 +38,15 @@ public class ResolveurBacktraceSimple implements Resolveur {
|
||||
return solved;
|
||||
}
|
||||
|
||||
/**
|
||||
* Méthode récursive permettant de résoudre un sudoku, utilisant la méthode de
|
||||
* backtracking.
|
||||
*
|
||||
* @param s : sudoku à résoudre
|
||||
* @param afficherEtape : afficher les étapes de la résolution
|
||||
* @param etat : état de la résolution
|
||||
* @return true si le sudoku est résolvable, false sinon
|
||||
*/
|
||||
private boolean resoudre(Sudoku s, boolean afficherEtape, EtatResolution etat) {
|
||||
Grille g = s.getGrille();
|
||||
List<Symbole> symboles = g.getSymbolesPossibles();
|
||||
@@ -45,15 +76,33 @@ public class ResolveurBacktraceSimple implements Resolveur {
|
||||
return true; // Si la grille est déjà résolue
|
||||
}
|
||||
|
||||
/**
|
||||
* Méthode permettant d'afficher le sudoku à chaque étape de sa résolution
|
||||
*
|
||||
* @param s : sudoku
|
||||
* @param compteur : compteur de l'étape en cours
|
||||
* @param compteurGeneral : compteur général de la résolution du sudoku (nombre
|
||||
* total de tentatives)
|
||||
*/
|
||||
private void afficherEtapeResolution(Sudoku s, int compteur, int compteurGeneral) {
|
||||
System.out.println("Sudoku, Etape " + compteur + " (Tentative " + compteurGeneral + ")");
|
||||
System.out.println(s.getGrille().toString());
|
||||
}
|
||||
|
||||
/**
|
||||
* Classe interne permettant de stocker l'état de la résolution
|
||||
*/
|
||||
private static class EtatResolution {
|
||||
int compteur;
|
||||
int compteurGeneral;
|
||||
|
||||
/**
|
||||
* Méthode permettant de fixer l'état de la résolution
|
||||
*
|
||||
* @param compteur : compteur de l'étape en cours
|
||||
* @param compteurGeneral : compteur général de la résolution du sudoku (nombre
|
||||
* total de tentatives)
|
||||
*/
|
||||
EtatResolution(int compteur, int compteurGeneral) {
|
||||
this.compteur = compteur;
|
||||
this.compteurGeneral = compteurGeneral;
|
||||
|
||||
@@ -9,28 +9,59 @@ import java.util.Set;
|
||||
|
||||
import sudoku.core.Console;
|
||||
|
||||
/**
|
||||
* Classe représentant un sudoku.
|
||||
*/
|
||||
public class Sudoku {
|
||||
private final Grille grille;
|
||||
private final List<Contrainte> contraintes;
|
||||
private String nom;
|
||||
|
||||
/**
|
||||
* Constructeur permettant d'initialiser un sudoku à partir de la taille de sa
|
||||
* grille
|
||||
*
|
||||
* @param taille : taille de la grille
|
||||
*/
|
||||
public Sudoku(int taille) {
|
||||
this.grille = new Grille(taille, this);
|
||||
this.contraintes = new ArrayList<>();
|
||||
}
|
||||
|
||||
/**
|
||||
* Méthode permettant de modifier le nom du sudoku, utilisé pour l'affichage.
|
||||
*
|
||||
* @param nom : nom du sudoku
|
||||
*/
|
||||
public void setNom(String nom) {
|
||||
this.nom = nom;
|
||||
}
|
||||
|
||||
/**
|
||||
* Méthode permettant de récupérer le nom du sudoku
|
||||
*
|
||||
* @return nom du sudoku
|
||||
*/
|
||||
public String getNom() {
|
||||
return this.nom;
|
||||
}
|
||||
|
||||
/**
|
||||
* Méthode permettant d'ajouter une contrainte à un sudoku
|
||||
*
|
||||
* @param contrainte : contrainte à ajouter
|
||||
*/
|
||||
public void ajouterContrainte(Contrainte contrainte) {
|
||||
contraintes.add(contrainte);
|
||||
}
|
||||
|
||||
/**
|
||||
* Méthode permettant de vérifier si une case est valide en fonction des
|
||||
* contraintes la concernant
|
||||
*
|
||||
* @param c : case à vérifier
|
||||
* @return boolean : true si la case est valide, false sinon
|
||||
*/
|
||||
public boolean estValide(Case c) {
|
||||
for (Contrainte contrainte : contraintes) {
|
||||
if (!contrainte.estRespectee(grille, c)) {
|
||||
@@ -40,6 +71,12 @@ public class Sudoku {
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Méthode permettant de vérifier si un sudoku est valide, c'est-à-dire si
|
||||
* toutes les cases sont valides.
|
||||
*
|
||||
* @return boolean : true si le sudoku est valide, false sinon
|
||||
*/
|
||||
public boolean estValide() {
|
||||
for (int i = 0; i < this.getGrille().getTaille(); i++) {
|
||||
for (int j = 0; j < this.getGrille().getTaille(); j++) {
|
||||
@@ -52,14 +89,28 @@ public class Sudoku {
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Méthode utilisée pour verifier toute les contraintes lors d'un ajout de Case
|
||||
* dans la grille.
|
||||
*
|
||||
* @return boolean : true si toutes les contraintes sont respectées, false sinon
|
||||
*/
|
||||
public boolean verifierToutesContraintes() {
|
||||
return grille.verifierToutesContraintes(contraintes);
|
||||
}
|
||||
|
||||
/**
|
||||
* Méthode permettant de retourner la grille complète
|
||||
*
|
||||
* @return Grille
|
||||
*/
|
||||
public Grille getGrille() {
|
||||
return grille;
|
||||
}
|
||||
|
||||
/**
|
||||
* Méthode du menu principal du jeu.
|
||||
*/
|
||||
public static void menu() {
|
||||
Scanner scanner = new Scanner(System.in);
|
||||
System.out.println("BIENVENUE DANS LE JEU DE SUDOKU");
|
||||
@@ -108,7 +159,7 @@ public class Sudoku {
|
||||
Multidoku multidoku = creerMultidoku(choix);
|
||||
if (multidoku != null) {
|
||||
System.out.println("\nMultidoku initial :");
|
||||
System.out.println(multidoku.toStringCombined());
|
||||
System.out.println(multidoku);
|
||||
|
||||
System.out.println("\nDébut de la résolution dans 3 secondes...");
|
||||
try {
|
||||
@@ -120,7 +171,7 @@ public class Sudoku {
|
||||
|
||||
if (multidoku.resoudreMultidoku(true)) {
|
||||
System.out.println("\nMultidoku résolu :");
|
||||
System.out.println(multidoku.toStringCombined());
|
||||
System.out.println(multidoku);
|
||||
} else {
|
||||
System.out.println("Ce Multidoku n'a pas de solution.");
|
||||
}
|
||||
@@ -147,7 +198,7 @@ public class Sudoku {
|
||||
s.getGrille().setSymbolesPossibles(symboles);
|
||||
s.ajouterContrainte(new ContrainteLigne());
|
||||
s.ajouterContrainte(new ContrainteColonne());
|
||||
s.ajouterContrainte(new ContrainteBloc());
|
||||
s.ajouterContrainte(new ContrainteBloc(s.getGrille().getTaille(), s.getGrille().getTaille()));
|
||||
s.getGrille().creerBlocCarre();
|
||||
}
|
||||
|
||||
@@ -226,6 +277,9 @@ public class Sudoku {
|
||||
return multidoku;
|
||||
}
|
||||
|
||||
/**
|
||||
* Méthode du menu principal du jeu de sudoku.
|
||||
*/
|
||||
public static void menuGrille() {
|
||||
Scanner scanner = new Scanner(System.in);
|
||||
// ETAPE 1 : TAILLE GRILLE
|
||||
@@ -279,7 +333,8 @@ public class Sudoku {
|
||||
for (int choixContrainte : contraintesChoisies) {
|
||||
switch (choixContrainte) {
|
||||
case 1:
|
||||
sudoku.ajouterContrainte(new ContrainteBloc());
|
||||
sudoku.ajouterContrainte(
|
||||
new ContrainteBloc(sudoku.getGrille().getTaille(), sudoku.getGrille().getTaille()));
|
||||
System.out.println("Contrainte Bloc ajoutée.");
|
||||
break;
|
||||
case 2:
|
||||
@@ -331,10 +386,10 @@ public class Sudoku {
|
||||
try {
|
||||
tailleGrille = Integer.parseInt(scanner.nextLine());
|
||||
if (tailleGrille <= 0) {
|
||||
System.out.println("Erreur : Veuillez entrer un entier positif.");
|
||||
Console.errorln("Erreur : Veuillez entrer un entier positif.");
|
||||
}
|
||||
} catch (NumberFormatException e) {
|
||||
System.out.println("Erreur : Entrée invalide. Veuillez entrer un nombre.");
|
||||
Console.errorln("Erreur : Entrée invalide. Veuillez entrer un nombre.");
|
||||
}
|
||||
}
|
||||
return tailleGrille;
|
||||
@@ -400,14 +455,14 @@ public class Sudoku {
|
||||
break; // Sortie de la boucle si l'utilisateur tape ESC
|
||||
}
|
||||
if (input.isEmpty()) {
|
||||
System.out.println("Veuillez entrer un numéro de ligne valide.");
|
||||
Console.errorln("Veuillez entrer un numéro de ligne valide.");
|
||||
continue; // Recommencer la saisie de la ligne si l'entrée est vide
|
||||
}
|
||||
try {
|
||||
ligne = Integer.parseInt(input); // Convertir la ligne en entier
|
||||
break; // Sortir de la boucle si la ligne est valide
|
||||
} catch (NumberFormatException e) {
|
||||
System.out.println("Veuillez entrer un numéro de ligne valide (un nombre entier).");
|
||||
Console.errorln("Veuillez entrer un numéro de ligne valide (un nombre entier).");
|
||||
}
|
||||
}
|
||||
// ARRET DE LA BOUCLE SI SAISIE DE "ESC"
|
||||
@@ -421,14 +476,14 @@ public class Sudoku {
|
||||
System.out.println("Entrez le numéro de colonne :");
|
||||
input = scanner.nextLine(); // Lire la colonne
|
||||
if (input.isEmpty()) {
|
||||
System.out.println("Veuillez entrer un numéro de colonne valide.");
|
||||
Console.errorln("Veuillez entrer un numéro de colonne valide.");
|
||||
continue; // Recommencer la saisie de la colonne si l'entrée est vide
|
||||
}
|
||||
try {
|
||||
colonne = Integer.parseInt(input); // Convertir la colonne en entier
|
||||
break; // Sortir de la boucle si la colonne est valide
|
||||
} catch (NumberFormatException e) {
|
||||
System.out.println("Veuillez entrer un numéro de colonne valide (un nombre entier).");
|
||||
Console.errorln("Veuillez entrer un numéro de colonne valide (un nombre entier).");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -438,7 +493,7 @@ public class Sudoku {
|
||||
System.out.println("Entrez le symbole :");
|
||||
symbole = scanner.nextLine(); // Lire le symbole
|
||||
if (symbole.isEmpty()) {
|
||||
System.out.println("Veuillez entrer un symbole valide.");
|
||||
Console.errorln("Veuillez entrer un symbole valide.");
|
||||
continue; // Recommencer la saisie du symbole si l'entrée est vide
|
||||
}
|
||||
try {
|
||||
@@ -501,7 +556,7 @@ public class Sudoku {
|
||||
// Vérification des limites
|
||||
if (choixLigne < 0 || choixLigne >= tailleGrille || choixColonne < 0
|
||||
|| choixColonne >= tailleGrille) {
|
||||
System.out.println("Erreur : Coordonnées hors limites ! Veuillez réessayer.");
|
||||
Console.errorln("Erreur : Coordonnées hors limites ! Veuillez réessayer.");
|
||||
coordonneesValides = false;
|
||||
continue;
|
||||
}
|
||||
@@ -509,7 +564,7 @@ public class Sudoku {
|
||||
// Vérification si la coordonnée existe déjà dans TOUTE la grille
|
||||
String coordonneeStr = choixLigne + "-" + choixColonne;
|
||||
if (toutesLesCoordonnees.contains(coordonneeStr)) {
|
||||
System.out.println(
|
||||
Console.errorln(
|
||||
"Erreur : Ces coordonnées sont déjà utilisées dans un autre bloc ! Veuillez en entrer une nouvelle.");
|
||||
coordonneesValides = false;
|
||||
}
|
||||
@@ -526,7 +581,7 @@ public class Sudoku {
|
||||
sudoku.getGrille().creerBlocPersonnalise(listeCases);
|
||||
System.out.println("Bloc " + nombreBloc + " enregistré avec succès !");
|
||||
} catch (IllegalArgumentException e) {
|
||||
System.out.println("Erreur lors de la création du bloc : " + e.getMessage());
|
||||
Console.errorln("Erreur lors de la création du bloc : " + e.getMessage());
|
||||
System.out.println("Veuillez recommencer la saisie de ce bloc.");
|
||||
continue; // Recommence le bloc en cours
|
||||
}
|
||||
|
||||
@@ -1,25 +1,12 @@
|
||||
package sudoku;
|
||||
|
||||
public class SudokuPlacement {
|
||||
private final Sudoku sudoku;
|
||||
private final int offsetLigne;
|
||||
private final int offsetColonne;
|
||||
|
||||
public SudokuPlacement(Sudoku sudoku, int offsetLigne, int offsetColonne) {
|
||||
this.sudoku = sudoku;
|
||||
this.offsetLigne = offsetLigne;
|
||||
this.offsetColonne = offsetColonne;
|
||||
}
|
||||
|
||||
public Sudoku getSudoku() {
|
||||
return sudoku;
|
||||
}
|
||||
|
||||
public int getOffsetLigne() {
|
||||
return offsetLigne;
|
||||
}
|
||||
|
||||
public int getOffsetColonne() {
|
||||
return offsetColonne;
|
||||
}
|
||||
/**
|
||||
* Classe permettant de stocker un placement de symbole dans une grille de
|
||||
* multidoku.
|
||||
*
|
||||
* @param sudoku : le sudoku associé
|
||||
* @param offsetLigne : décalage de la ligne
|
||||
* @param offsetColonne : décalage de la colonne
|
||||
*/
|
||||
public record SudokuPlacement(Sudoku sudoku, int offsetLigne, int offsetColonne) {
|
||||
}
|
||||
|
||||
@@ -1,25 +1,57 @@
|
||||
package sudoku;
|
||||
|
||||
/**
|
||||
* Classe permettant de créer et gérer un symbole.
|
||||
*/
|
||||
public class Symbole {
|
||||
private final String valeur;
|
||||
|
||||
/**
|
||||
* Constructeur permettant de créer un symbole
|
||||
*
|
||||
* @param symbole : symbole
|
||||
*/
|
||||
public Symbole(String symbole) {
|
||||
this.valeur = symbole;
|
||||
}
|
||||
|
||||
// Factory methods pour différents types
|
||||
// Factory methods pour différents types de symboles
|
||||
|
||||
/**
|
||||
* Méthode permettant de créer un symbole de type String
|
||||
*
|
||||
* @param s : symbole
|
||||
* @return symbole
|
||||
*/
|
||||
public static Symbole of(String s) {
|
||||
return new Symbole(s);
|
||||
}
|
||||
|
||||
/**
|
||||
* Méthode permettant de créer un symbole de type int
|
||||
*
|
||||
* @param n : entier
|
||||
* @return symbole
|
||||
*/
|
||||
public static Symbole of(int n) {
|
||||
return new Symbole(String.valueOf(n));
|
||||
}
|
||||
|
||||
/**
|
||||
* Méthode permettant de créer un symbole de type char
|
||||
*
|
||||
* @param c : caractère
|
||||
* @return symbole
|
||||
*/
|
||||
public static Symbole of(char c) {
|
||||
return new Symbole(String.valueOf(c));
|
||||
}
|
||||
|
||||
/**
|
||||
* Méthode permettant de vérifier si un symbole est de type int
|
||||
*
|
||||
* @return boolean
|
||||
*/
|
||||
public boolean isInt() {
|
||||
try {
|
||||
Integer.parseInt(valeur);
|
||||
@@ -29,15 +61,31 @@ public class Symbole {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Méthode permettant de vérifier si un symbole est de type letter (char)
|
||||
*
|
||||
* @return boolean
|
||||
*/
|
||||
public boolean isLetter() {
|
||||
return valeur.length() == 1 && Character.isLetter(valeur.charAt(0));
|
||||
}
|
||||
|
||||
/**
|
||||
* Méthode permettant de vérifier si un symbole est de type string
|
||||
*
|
||||
* @return boolean
|
||||
*/
|
||||
@Override
|
||||
public String toString() {
|
||||
return valeur;
|
||||
}
|
||||
|
||||
/**
|
||||
* Méthode permettant de retourner un booléen si 2 objets sont identiques
|
||||
*
|
||||
* @param obj : objet
|
||||
* @return boolean
|
||||
*/
|
||||
@Override
|
||||
public boolean equals(Object obj) {
|
||||
if (this == obj)
|
||||
|
||||
@@ -1,27 +1,55 @@
|
||||
package sudoku.core;
|
||||
|
||||
/**
|
||||
* Console classe pour afficher des messages en couleur dans la console
|
||||
* Console classe pour afficher des messages en couleur dans la console.
|
||||
*/
|
||||
public class Console {
|
||||
|
||||
/**
|
||||
* Constructeur privé pour empêcher l'instanciation de la classe Console.
|
||||
*/
|
||||
private Console() {
|
||||
}
|
||||
|
||||
// Codes ANSI pour les couleurs
|
||||
private static final String ANSI_RESET = "\u001B[0m";
|
||||
private static final String ANSI_RED = "\u001B[31m";
|
||||
private static final String ANSI_GREEN = "\u001B[32m";
|
||||
private static final String ANSI_YELLOW = "\u001B[33m";
|
||||
static final String ANSI_BOLD = "\u001B[1m";
|
||||
|
||||
/**
|
||||
* Affiche un message en rouge
|
||||
*
|
||||
* @param message : String
|
||||
*/
|
||||
public static void errorln(String message) {
|
||||
System.err.println(ANSI_RED + ANSI_BOLD + message + ANSI_RESET + "\n");
|
||||
}
|
||||
|
||||
/**
|
||||
* Affiche un message en vert
|
||||
*
|
||||
* @param message : String
|
||||
*/
|
||||
public static void successln(String message) {
|
||||
System.out.println(ANSI_GREEN + ANSI_BOLD + message + ANSI_RESET + "\n");
|
||||
}
|
||||
|
||||
/**
|
||||
* Affiche un message en jaune
|
||||
*
|
||||
* @param message : String
|
||||
*/
|
||||
public static void warnln(String message) {
|
||||
System.out.println(ANSI_YELLOW + ANSI_BOLD + message + ANSI_RESET + "\n");
|
||||
}
|
||||
|
||||
/**
|
||||
* Affiche un message en blanc (par défaut)
|
||||
*
|
||||
* @param message : String
|
||||
*/
|
||||
public static void infoln(String message) {
|
||||
System.out.println(message + "\n");
|
||||
}
|
||||
|
||||
123
app/src/main/java/sudoku/core/GenerateurCouleur.java
Normal file
123
app/src/main/java/sudoku/core/GenerateurCouleur.java
Normal file
@@ -0,0 +1,123 @@
|
||||
package sudoku.core;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Classe permettant de générer des couleurs pour les cases de la grille.
|
||||
*/
|
||||
public class GenerateurCouleur {
|
||||
|
||||
/**
|
||||
* Constructeur privé pour empêcher l'instanciation de la classe
|
||||
* GenerateurCouleur.
|
||||
*/
|
||||
private GenerateurCouleur() {
|
||||
}
|
||||
|
||||
/**
|
||||
* Classe interne Couleur représentant une couleur avec des composantes rouge,
|
||||
* vert et bleu.
|
||||
*/
|
||||
public static class Couleur {
|
||||
/** Composant rouge de la couleur, valeur entre 0 et 1 */
|
||||
public float r;
|
||||
|
||||
/** Composant vert de la couleur, valeur entre 0 et 1 */
|
||||
public float g;
|
||||
|
||||
/** Composant bleu de la couleur, valeur entre 0 et 1 */
|
||||
public float b;
|
||||
|
||||
/**
|
||||
* Constructeur de la classe Couleur.
|
||||
*
|
||||
* @param r Composant rouge (valeur entre 0 et 1)
|
||||
* @param g Composant vert (valeur entre 0 et 1)
|
||||
* @param b Composant bleu (valeur entre 0 et 1)
|
||||
*/
|
||||
public Couleur(float r, float g, float b) {
|
||||
this.r = r;
|
||||
this.g = g;
|
||||
this.b = b;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Génère une palette de couleurs pour les cases de la grille.
|
||||
*
|
||||
* @param colorCount Nombre de couleurs à générer
|
||||
* @return {@code List<Couleur>} Liste de couleurs générées
|
||||
*/
|
||||
public static List<Couleur> paletteCouleur(int colorCount) {
|
||||
List<Couleur> colors = paletteCouleurEtendue(colorCount);
|
||||
List<Couleur> newOrder = new ArrayList<>();
|
||||
int newIndex = 0;
|
||||
while (!colors.isEmpty()) {
|
||||
int randomIndex = newIndex % colors.size();
|
||||
newOrder.add(colors.get(randomIndex));
|
||||
colors.remove(randomIndex);
|
||||
newIndex += Math.sqrt(colorCount) + 1;
|
||||
}
|
||||
return newOrder;
|
||||
}
|
||||
|
||||
/**
|
||||
* Génère une palette de couleurs étendue pour les cases de la grille.
|
||||
*
|
||||
* @param colorCount Nombre de couleurs à générer
|
||||
* @return {@code List<Couleur>} Liste de couleurs générées
|
||||
*/
|
||||
public static List<Couleur> paletteCouleurEtendue(int colorCount) {
|
||||
List<Couleur> colors = new ArrayList<>();
|
||||
for (int i = 0; i < colorCount; i++) {
|
||||
colors.add(hslToRgb((float) (i) / (float) colorCount, 0.9f, 0.4f));
|
||||
}
|
||||
return colors;
|
||||
}
|
||||
|
||||
/**
|
||||
* Convertit une couleur HSL en RGB
|
||||
*
|
||||
* @param h : float : Hue
|
||||
* @param s : float : Saturation
|
||||
* @param l : float : Lightness
|
||||
* @return Couleur : couleur RGB
|
||||
*/
|
||||
public static Couleur hslToRgb(float h, float s, float l) {
|
||||
float r, g, b;
|
||||
|
||||
if (s == 0f) {
|
||||
r = g = b = l; // achromatic
|
||||
} else {
|
||||
float q = l < 0.5f ? l * (1 + s) : l + s - l * s;
|
||||
float p = 2 * l - q;
|
||||
r = hueToRgb(p, q, h + 1f / 3f);
|
||||
g = hueToRgb(p, q, h);
|
||||
b = hueToRgb(p, q, h - 1f / 3f);
|
||||
}
|
||||
return new Couleur(r, g, b);
|
||||
}
|
||||
|
||||
/**
|
||||
* Convertit une couleur hue en RGB
|
||||
*
|
||||
* @param p : float
|
||||
* @param q : float
|
||||
* @param t : float
|
||||
* @return float
|
||||
*/
|
||||
public static float hueToRgb(float p, float q, float t) {
|
||||
if (t < 0f)
|
||||
t += 1f;
|
||||
if (t > 1f)
|
||||
t -= 1f;
|
||||
if (t < 1f / 6f)
|
||||
return p + (q - p) * 6f * t;
|
||||
if (t < 1f / 2f)
|
||||
return q;
|
||||
if (t < 2f / 3f)
|
||||
return p + (q - p) * (2f / 3f - t) * 6f;
|
||||
return p;
|
||||
}
|
||||
}
|
||||
@@ -1,67 +0,0 @@
|
||||
package sudoku.gui;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
public class ColorGenerator {
|
||||
|
||||
public static class Color {
|
||||
public float r, g, b;
|
||||
|
||||
public Color(float r, float g, float b) {
|
||||
this.r = r;
|
||||
this.g = g;
|
||||
this.b = b;
|
||||
}
|
||||
}
|
||||
|
||||
public static List<Color> greatPalette(int colorCount) {
|
||||
List<Color> colors = greatScheme(colorCount);
|
||||
List<Color> newOrder = new ArrayList<>();
|
||||
int newIndex = 0;
|
||||
while (!colors.isEmpty()) {
|
||||
int randomIndex = newIndex % colors.size();
|
||||
newOrder.add(colors.get(randomIndex));
|
||||
colors.remove(randomIndex);
|
||||
newIndex += Math.sqrt(colorCount) + 1;
|
||||
}
|
||||
return newOrder;
|
||||
}
|
||||
|
||||
public static List<Color> greatScheme(int colorCount) {
|
||||
List<Color> colors = new ArrayList<>();
|
||||
for (int i = 0; i < colorCount; i++) {
|
||||
colors.add(hslToRgb((float) (i) / (float) colorCount, 0.9f, 0.4f));
|
||||
}
|
||||
return colors;
|
||||
}
|
||||
|
||||
public static Color hslToRgb(float h, float s, float l) {
|
||||
float r, g, b;
|
||||
|
||||
if (s == 0f) {
|
||||
r = g = b = l; // achromatic
|
||||
} else {
|
||||
float q = l < 0.5f ? l * (1 + s) : l + s - l * s;
|
||||
float p = 2 * l - q;
|
||||
r = hueToRgb(p, q, h + 1f / 3f);
|
||||
g = hueToRgb(p, q, h);
|
||||
b = hueToRgb(p, q, h - 1f / 3f);
|
||||
}
|
||||
return new Color(r, g, b);
|
||||
}
|
||||
|
||||
public static float hueToRgb(float p, float q, float t) {
|
||||
if (t < 0f)
|
||||
t += 1f;
|
||||
if (t > 1f)
|
||||
t -= 1f;
|
||||
if (t < 1f / 6f)
|
||||
return p + (q - p) * 6f * t;
|
||||
if (t < 1f / 2f)
|
||||
return q;
|
||||
if (t < 2f / 3f)
|
||||
return p + (q - p) * (2f / 3f - t) * 6f;
|
||||
return p;
|
||||
}
|
||||
}
|
||||
@@ -55,7 +55,8 @@ public class AppTest {
|
||||
|
||||
sudoku.ajouterContrainte(new ContrainteLigne());
|
||||
sudoku.ajouterContrainte(new ContrainteColonne());
|
||||
sudoku.ajouterContrainte(new ContrainteBloc());
|
||||
sudoku.ajouterContrainte(
|
||||
new ContrainteBloc(sudoku.getGrille().getTaille() / 4, sudoku.getGrille().getTaille() / 4));
|
||||
|
||||
System.out.println(sudoku.getGrille().toString());
|
||||
|
||||
|
||||
@@ -7,63 +7,64 @@ import org.junit.jupiter.api.Test;
|
||||
|
||||
public class TestBlocParticuliers {
|
||||
|
||||
@Test
|
||||
public void blocParticuliers() {
|
||||
System.out.println("TEST BLOC PARTICULIERS : ");
|
||||
System.out.println(new App().getGreeting());
|
||||
// Create a new Sudoku
|
||||
Sudoku sudoku = new Sudoku(4);
|
||||
@Test
|
||||
public void blocParticuliers() {
|
||||
System.out.println("TEST BLOC PARTICULIERS : ");
|
||||
|
||||
sudoku.getGrille().setSymbolesPossibles(new ArrayList<>(Arrays.asList(
|
||||
Symbole.of(1),
|
||||
Symbole.of(2),
|
||||
Symbole.of(3),
|
||||
Symbole.of(4))));
|
||||
// Create a new Sudoku
|
||||
Sudoku sudoku = new Sudoku(4);
|
||||
|
||||
sudoku.ajouterContrainte(new ContrainteBloc());
|
||||
sudoku.ajouterContrainte(new ContrainteLigne());
|
||||
sudoku.ajouterContrainte(new ContrainteColonne());
|
||||
sudoku.getGrille().setSymbolesPossibles(new ArrayList<>(Arrays.asList(
|
||||
Symbole.of(1),
|
||||
Symbole.of(2),
|
||||
Symbole.of(3),
|
||||
Symbole.of(4))));
|
||||
|
||||
sudoku.getGrille().setCase(0, 0, Symbole.of(1));
|
||||
sudoku.getGrille().setCase(3, 1, Symbole.of(2));
|
||||
sudoku.getGrille().setCase(2, 2, Symbole.of(3));
|
||||
sudoku.ajouterContrainte(new ContrainteBloc(sudoku.getGrille().getTaille() / 2,
|
||||
sudoku.getGrille().getTaille() / 2));
|
||||
sudoku.ajouterContrainte(new ContrainteLigne());
|
||||
sudoku.ajouterContrainte(new ContrainteColonne());
|
||||
|
||||
sudoku.getGrille().creerBlocPersonnalise(Arrays.asList(
|
||||
new int[] { 0, 0 },
|
||||
new int[] { 3, 3 },
|
||||
new int[] { 0, 1 },
|
||||
new int[] { 2, 3 }));
|
||||
sudoku.getGrille().creerBlocPersonnalise(Arrays.asList(
|
||||
new int[] { 0, 2 },
|
||||
new int[] { 1, 3 },
|
||||
new int[] { 1, 2 },
|
||||
new int[] { 3, 1 }));
|
||||
sudoku.getGrille().creerBlocPersonnalise(Arrays.asList(
|
||||
new int[] { 1, 1 },
|
||||
new int[] { 1, 0 },
|
||||
new int[] { 0, 3 },
|
||||
new int[] { 3, 0 }));
|
||||
sudoku.getGrille().creerBlocPersonnalise(Arrays.asList(
|
||||
new int[] { 2, 0 },
|
||||
new int[] { 2, 1 },
|
||||
new int[] { 2, 2 },
|
||||
new int[] { 3, 2 }));
|
||||
sudoku.getGrille().setCase(0, 0, Symbole.of(1));
|
||||
sudoku.getGrille().setCase(3, 1, Symbole.of(2));
|
||||
sudoku.getGrille().setCase(2, 2, Symbole.of(3));
|
||||
|
||||
System.out.println("Sudoku :");
|
||||
System.out.println(sudoku.getGrille().toString());
|
||||
sudoku.getGrille().creerBlocPersonnalise(Arrays.asList(
|
||||
new int[] { 0, 0 },
|
||||
new int[] { 3, 3 },
|
||||
new int[] { 0, 1 },
|
||||
new int[] { 2, 3 }));
|
||||
sudoku.getGrille().creerBlocPersonnalise(Arrays.asList(
|
||||
new int[] { 0, 2 },
|
||||
new int[] { 1, 3 },
|
||||
new int[] { 1, 2 },
|
||||
new int[] { 3, 1 }));
|
||||
sudoku.getGrille().creerBlocPersonnalise(Arrays.asList(
|
||||
new int[] { 1, 1 },
|
||||
new int[] { 1, 0 },
|
||||
new int[] { 0, 3 },
|
||||
new int[] { 3, 0 }));
|
||||
sudoku.getGrille().creerBlocPersonnalise(Arrays.asList(
|
||||
new int[] { 2, 0 },
|
||||
new int[] { 2, 1 },
|
||||
new int[] { 2, 2 },
|
||||
new int[] { 3, 2 }));
|
||||
|
||||
System.out.println("Blocs :");
|
||||
sudoku.getGrille().printBlocs();
|
||||
System.out.println("Sudoku :");
|
||||
System.out.println(sudoku.getGrille().toString());
|
||||
|
||||
System.out.println("Symboles possibles :");
|
||||
sudoku.getGrille().printSymbolesPossibles();
|
||||
System.out.println("Blocs :");
|
||||
sudoku.getGrille().printBlocs();
|
||||
|
||||
ResolveurBacktraceSimple resolveur = new ResolveurBacktraceSimple();
|
||||
resolveur.resoudre(sudoku, true);
|
||||
System.out.println("Symboles possibles :");
|
||||
sudoku.getGrille().printSymbolesPossibles();
|
||||
|
||||
System.out.println("Sudoku résolu :");
|
||||
System.out.println(sudoku.getGrille().toString());
|
||||
ResolveurBacktraceSimple resolveur = new ResolveurBacktraceSimple();
|
||||
resolveur.resoudre(sudoku, true);
|
||||
|
||||
System.out.println("FIN TEST BLOC PARTICULIERS");
|
||||
}
|
||||
System.out.println("Sudoku résolu :");
|
||||
System.out.println(sudoku.getGrille().toString());
|
||||
|
||||
System.out.println("FIN TEST BLOC PARTICULIERS");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -9,7 +9,7 @@ public class TestBlocRectangle {
|
||||
@Test
|
||||
public void blocRectangle() {
|
||||
System.out.println("TEST BLOC RECTANGLE : ");
|
||||
System.out.println(new App().getGreeting());
|
||||
|
||||
// Create a new Sudoku
|
||||
Sudoku sudoku = new Sudoku(15);
|
||||
ArrayList<Symbole> symboles = new ArrayList<>();
|
||||
@@ -20,7 +20,8 @@ public class TestBlocRectangle {
|
||||
|
||||
sudoku.ajouterContrainte(new ContrainteLigne());
|
||||
sudoku.ajouterContrainte(new ContrainteColonne());
|
||||
sudoku.ajouterContrainte(new ContrainteBloc());
|
||||
sudoku.ajouterContrainte(
|
||||
new ContrainteBloc(sudoku.getGrille().getTaille() / 5, sudoku.getGrille().getTaille() / 3));
|
||||
|
||||
sudoku.getGrille().setCase(0, 0, Symbole.of(1));
|
||||
sudoku.getGrille().setCase(6, 1, Symbole.of(2));
|
||||
@@ -35,7 +36,7 @@ public class TestBlocRectangle {
|
||||
sudoku.getGrille().setCase(3, 0, Symbole.of(4));
|
||||
|
||||
sudoku.getGrille().creerBlocRectangulaire(3, 5);
|
||||
|
||||
|
||||
System.out.println("Sudoku :");
|
||||
System.out.println(sudoku.getGrille().toString());
|
||||
|
||||
|
||||
@@ -88,7 +88,8 @@ public class TestCreationGrilleRectangulaireSansSolution {
|
||||
|
||||
sudoku.getGrille().creerBlocRectangulaire(3, 4);
|
||||
|
||||
sudoku.ajouterContrainte(new ContrainteBloc());
|
||||
sudoku.ajouterContrainte(
|
||||
new ContrainteBloc(sudoku.getGrille().getTaille() / 4, sudoku.getGrille().getTaille() / 3));
|
||||
sudoku.ajouterContrainte(new ContrainteColonne());
|
||||
sudoku.ajouterContrainte(new ContrainteLigne());
|
||||
|
||||
|
||||
@@ -2,16 +2,14 @@ package sudoku;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertFalse;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
|
||||
public class TestDoublonBloc {
|
||||
@Test
|
||||
public void testBloc() {
|
||||
public void testDoublonBloc() {
|
||||
System.out.println("TEST DOUBLON BLOC : ");
|
||||
System.out.println(new App().getGreeting());
|
||||
|
||||
// Create a new Sudoku
|
||||
Sudoku sudoku = new Sudoku(9);
|
||||
sudoku.getGrille().setSymbolesPossibles(new ArrayList<>(Arrays.asList(
|
||||
@@ -26,7 +24,8 @@ public class TestDoublonBloc {
|
||||
Symbole.of(9))));
|
||||
|
||||
// Add constraints
|
||||
sudoku.ajouterContrainte(new ContrainteBloc());
|
||||
sudoku.ajouterContrainte(
|
||||
new ContrainteBloc(sudoku.getGrille().getTaille() / 3, sudoku.getGrille().getTaille() / 3));
|
||||
|
||||
sudoku.getGrille().setCase(0, 0, Symbole.of(1));
|
||||
sudoku.getGrille().setCase(6, 1, Symbole.of(2));
|
||||
@@ -37,9 +36,8 @@ public class TestDoublonBloc {
|
||||
sudoku.getGrille().setCase(5, 6, Symbole.of(7));
|
||||
sudoku.getGrille().setCase(0, 7, Symbole.of(8));
|
||||
sudoku.getGrille().setCase(4, 8, Symbole.of(9));
|
||||
//doublon bloc
|
||||
// doublon bloc
|
||||
sudoku.getGrille().setCase(1, 1, Symbole.of(1));
|
||||
assertFalse(sudoku.estValide(sudoku.getGrille().getCase(1, 1)));
|
||||
|
||||
sudoku.getGrille().creerBlocCarre();
|
||||
|
||||
|
||||
@@ -2,16 +2,14 @@ package sudoku;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertFalse;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
|
||||
public class TestDoublonColonne {
|
||||
@Test
|
||||
public void testColonne() {
|
||||
public void testDoublonColonne() {
|
||||
System.out.println("TEST DOUBLON COLONNE : ");
|
||||
System.out.println(new App().getGreeting());
|
||||
|
||||
// Create a new Sudoku
|
||||
Sudoku sudoku = new Sudoku(9);
|
||||
sudoku.getGrille().setSymbolesPossibles(new ArrayList<>(Arrays.asList(
|
||||
@@ -38,7 +36,6 @@ public class TestDoublonColonne {
|
||||
sudoku.getGrille().setCase(4, 8, Symbole.of(9));
|
||||
// doublon colonne
|
||||
sudoku.getGrille().setCase(4, 0, Symbole.of(1));
|
||||
assertFalse(sudoku.estValide(sudoku.getGrille().getCase(4, 0)));
|
||||
|
||||
sudoku.getGrille().creerBlocCarre();
|
||||
|
||||
|
||||
@@ -9,7 +9,7 @@ public class TestDoublonLigne {
|
||||
@Test
|
||||
public void testDoublonLigne() {
|
||||
System.out.println("TEST DOUBLON LIGNE : ");
|
||||
System.out.println(new App().getGreeting());
|
||||
|
||||
// Create a new Sudoku
|
||||
Sudoku sudoku = new Sudoku(9);
|
||||
sudoku.getGrille().setSymbolesPossibles(new ArrayList<>(Arrays.asList(
|
||||
@@ -34,7 +34,7 @@ public class TestDoublonLigne {
|
||||
sudoku.getGrille().setCase(5, 6, Symbole.of(7));
|
||||
sudoku.getGrille().setCase(0, 7, Symbole.of(8));
|
||||
sudoku.getGrille().setCase(4, 8, Symbole.of(9));
|
||||
//doublon ligne
|
||||
// doublon ligne
|
||||
sudoku.getGrille().setCase(0, 4, Symbole.of(1));
|
||||
|
||||
sudoku.getGrille().creerBlocCarre();
|
||||
|
||||
@@ -35,7 +35,8 @@ public class TestMultidokuBloc {
|
||||
sudoku.getGrille().setSymbolesPossibles(symboles);
|
||||
sudoku.ajouterContrainte(new ContrainteLigne());
|
||||
sudoku.ajouterContrainte(new ContrainteColonne());
|
||||
sudoku.ajouterContrainte(new ContrainteBloc());
|
||||
sudoku.ajouterContrainte(
|
||||
new ContrainteBloc(sudoku.getGrille().getTaille() / 3, sudoku.getGrille().getTaille() / 3));
|
||||
sudoku.getGrille().creerBlocCarre();
|
||||
}
|
||||
|
||||
@@ -73,11 +74,11 @@ public class TestMultidokuBloc {
|
||||
System.out.println(s2.getGrille().toString());
|
||||
|
||||
System.out.println("\nAffichage Multidoku combiné :");
|
||||
System.out.println(multidoku.toStringCombined());
|
||||
System.out.println(multidoku.toString());
|
||||
|
||||
if (multidoku.resoudreMultidoku(false)) {
|
||||
System.out.println("Multidoku résolu :");
|
||||
System.out.println(multidoku.toStringCombined());
|
||||
System.out.println(multidoku.toString());
|
||||
} else {
|
||||
System.out.println("Multidoku non résolu");
|
||||
}
|
||||
|
||||
@@ -40,7 +40,8 @@ public class TestMultidokuCase {
|
||||
sudoku.getGrille().setSymbolesPossibles(symboles);
|
||||
sudoku.ajouterContrainte(new ContrainteLigne());
|
||||
sudoku.ajouterContrainte(new ContrainteColonne());
|
||||
sudoku.ajouterContrainte(new ContrainteBloc());
|
||||
sudoku.ajouterContrainte(
|
||||
new ContrainteBloc(sudoku.getGrille().getTaille() / 3, sudoku.getGrille().getTaille() / 3));
|
||||
sudoku.getGrille().creerBlocCarre();
|
||||
}
|
||||
|
||||
@@ -55,11 +56,11 @@ public class TestMultidokuCase {
|
||||
System.out.println(s2.getGrille().toString());
|
||||
|
||||
System.out.println("\nAffichage Multidoku combiné :");
|
||||
System.out.println(multidoku.toStringCombined());
|
||||
System.out.println(multidoku.toString());
|
||||
|
||||
if (multidoku.resoudreMultidoku(false)) {
|
||||
System.out.println("Multidoku résolu !");
|
||||
System.out.println(multidoku.toStringCombined());
|
||||
System.out.println(multidoku.toString());
|
||||
} else {
|
||||
System.out.println("Échec de la résolution du multidoku.");
|
||||
}
|
||||
|
||||
@@ -32,7 +32,8 @@ public class TestMultidokuColonne {
|
||||
sudoku.getGrille().setSymbolesPossibles(symboles);
|
||||
sudoku.ajouterContrainte(new ContrainteLigne());
|
||||
sudoku.ajouterContrainte(new ContrainteColonne());
|
||||
sudoku.ajouterContrainte(new ContrainteBloc());
|
||||
sudoku.ajouterContrainte(
|
||||
new ContrainteBloc(sudoku.getGrille().getTaille() / 3, sudoku.getGrille().getTaille() / 3));
|
||||
sudoku.getGrille().creerBlocCarre();
|
||||
}
|
||||
|
||||
@@ -68,11 +69,11 @@ public class TestMultidokuColonne {
|
||||
System.out.println(s2.getGrille().toString());
|
||||
|
||||
System.out.println("\nAffichage Multidoku combiné :");
|
||||
System.out.println(multidoku.toStringCombined());
|
||||
System.out.println(multidoku.toString());
|
||||
|
||||
if (multidoku.resoudreMultidoku(false)) {
|
||||
System.out.println("Multidoku résolu :");
|
||||
System.out.println(multidoku.toStringCombined());
|
||||
System.out.println(multidoku.toString());
|
||||
} else {
|
||||
System.out.println("Multidoku non résolu");
|
||||
}
|
||||
|
||||
@@ -32,7 +32,8 @@ public class TestMultidokuLigne {
|
||||
sudoku.getGrille().setSymbolesPossibles(symboles);
|
||||
sudoku.ajouterContrainte(new ContrainteLigne());
|
||||
sudoku.ajouterContrainte(new ContrainteColonne());
|
||||
sudoku.ajouterContrainte(new ContrainteBloc());
|
||||
sudoku.ajouterContrainte(
|
||||
new ContrainteBloc(sudoku.getGrille().getTaille() / 3, sudoku.getGrille().getTaille() / 3));
|
||||
sudoku.getGrille().creerBlocCarre();
|
||||
}
|
||||
|
||||
@@ -68,11 +69,11 @@ public class TestMultidokuLigne {
|
||||
System.out.println(s2.getGrille().toString());
|
||||
|
||||
System.out.println("\nAffichage Multidoku combiné :");
|
||||
System.out.println(multidoku.toStringCombined());
|
||||
System.out.println(multidoku.toString());
|
||||
|
||||
if (multidoku.resoudreMultidoku(false)) {
|
||||
System.out.println("Multidoku résolu :");
|
||||
System.out.println(multidoku.toStringCombined());
|
||||
System.out.println(multidoku.toString());
|
||||
} else {
|
||||
System.out.println("Multidoku non résolu");
|
||||
}
|
||||
|
||||
@@ -9,7 +9,7 @@ public class TestResolveurBacktraceSimpleSudoku16 {
|
||||
@Test
|
||||
public void testResolution() {
|
||||
System.out.println("TEST RESOLVEUR BACKTRACE SIMPLE : ");
|
||||
System.out.println(new App().getGreeting());
|
||||
|
||||
// Create a new Sudoku
|
||||
Sudoku sudoku = new Sudoku(16);
|
||||
sudoku.getGrille().setSymbolesPossibles(new ArrayList<>(Arrays.asList(
|
||||
@@ -34,7 +34,8 @@ public class TestResolveurBacktraceSimpleSudoku16 {
|
||||
|
||||
sudoku.ajouterContrainte(new ContrainteLigne());
|
||||
sudoku.ajouterContrainte(new ContrainteColonne());
|
||||
sudoku.ajouterContrainte(new ContrainteBloc());
|
||||
sudoku.ajouterContrainte(
|
||||
new ContrainteBloc(sudoku.getGrille().getTaille() / 4, sudoku.getGrille().getTaille() / 4));
|
||||
|
||||
sudoku.getGrille().setCase(0, 0, Symbole.of(1));
|
||||
sudoku.getGrille().setCase(6, 1, Symbole.of(2));
|
||||
|
||||
@@ -11,52 +11,53 @@
|
||||
// import org.junit.jupiter.api.Test;
|
||||
|
||||
// public class TestResolveurBacktraceSimpleSudoku25 {
|
||||
// @Test
|
||||
// public void testResolution() {
|
||||
// System.out.println("TEST RESOLVEUR BACKTRACE SIMPLE : ");
|
||||
// System.out.println(new App().getGreeting());
|
||||
// // Create a new Sudoku
|
||||
// Sudoku sudoku = new Sudoku(25);
|
||||
// @Test
|
||||
// public void testResolution() {
|
||||
// System.out.println("TEST RESOLVEUR BACKTRACE SIMPLE : ");
|
||||
//
|
||||
// // Create a new Sudoku
|
||||
// Sudoku sudoku = new Sudoku(25);
|
||||
|
||||
// ArrayList<Symbole> symboles = new ArrayList<>();
|
||||
// for (int i = 1; i <= 25; i++) {
|
||||
// symboles.add(Symbole.of(i));
|
||||
// }
|
||||
// sudoku.getGrille().setSymbolesPossibles(symboles);
|
||||
|
||||
// sudoku.ajouterContrainte(new ContrainteLigne());
|
||||
// sudoku.ajouterContrainte(new ContrainteColonne());
|
||||
// sudoku.ajouterContrainte(new ContrainteBloc());
|
||||
|
||||
// sudoku.getGrille().setCase(0, 0, Symbole.of(1));
|
||||
// sudoku.getGrille().setCase(6, 1, Symbole.of(2));
|
||||
// sudoku.getGrille().setCase(2, 2, Symbole.of(3));
|
||||
// sudoku.getGrille().setCase(0, 3, Symbole.of(4));
|
||||
// sudoku.getGrille().setCase(4, 4, Symbole.of(5));
|
||||
// sudoku.getGrille().setCase(0, 5, Symbole.of(6));
|
||||
// sudoku.getGrille().setCase(5, 6, Symbole.of(7));
|
||||
// sudoku.getGrille().setCase(0, 7, Symbole.of(8));
|
||||
// sudoku.getGrille().setCase(4, 8, Symbole.of(9));
|
||||
// sudoku.getGrille().setCase(0, 9, Symbole.of(25));
|
||||
// sudoku.getGrille().setCase(6, 10, Symbole.of(11));
|
||||
// sudoku.getGrille().setCase(2, 11, Symbole.of(12));
|
||||
// sudoku.getGrille().setCase(0, 12, Symbole.of(13));
|
||||
|
||||
// sudoku.getGrille().creerBlocCarre();
|
||||
|
||||
// System.out.println("Sudoku :");
|
||||
// System.out.println(sudoku.getGrille().toString());
|
||||
|
||||
// System.out.println("Blocs :");
|
||||
// sudoku.getGrille().printBlocs();
|
||||
|
||||
// System.out.println("Symboles possibles :");
|
||||
// sudoku.getGrille().printSymbolesPossibles();
|
||||
|
||||
// ResolveurBacktraceSimple resolveur = new ResolveurBacktraceSimple();
|
||||
// resolveur.resoudre(sudoku, false);
|
||||
// System.out.println("Sudoku resolu :");
|
||||
// System.out.println(sudoku.getGrille().toString());
|
||||
// System.out.println("FIN TEST RESOLVEUR BACKTRACE SIMPLE");
|
||||
// }
|
||||
// ArrayList<Symbole> symboles = new ArrayList<>();
|
||||
// for (int i = 1; i <= 25; i++) {
|
||||
// symboles.add(Symbole.of(i));
|
||||
// }
|
||||
// sudoku.getGrille().setSymbolesPossibles(symboles);
|
||||
|
||||
// sudoku.ajouterContrainte(new ContrainteLigne());
|
||||
// sudoku.ajouterContrainte(new ContrainteColonne());
|
||||
// sudoku.ajouterContrainte(new ContrainteBloc(sudoku.getGrille().getTaille() /
|
||||
// 5, sudoku.getGrille().getTaille() / 5));
|
||||
|
||||
// sudoku.getGrille().setCase(0, 0, Symbole.of(1));
|
||||
// sudoku.getGrille().setCase(6, 1, Symbole.of(2));
|
||||
// sudoku.getGrille().setCase(2, 2, Symbole.of(3));
|
||||
// sudoku.getGrille().setCase(0, 3, Symbole.of(4));
|
||||
// sudoku.getGrille().setCase(4, 4, Symbole.of(5));
|
||||
// sudoku.getGrille().setCase(0, 5, Symbole.of(6));
|
||||
// sudoku.getGrille().setCase(5, 6, Symbole.of(7));
|
||||
// sudoku.getGrille().setCase(0, 7, Symbole.of(8));
|
||||
// sudoku.getGrille().setCase(4, 8, Symbole.of(9));
|
||||
// sudoku.getGrille().setCase(0, 9, Symbole.of(25));
|
||||
// sudoku.getGrille().setCase(6, 10, Symbole.of(11));
|
||||
// sudoku.getGrille().setCase(2, 11, Symbole.of(12));
|
||||
// sudoku.getGrille().setCase(0, 12, Symbole.of(13));
|
||||
|
||||
// sudoku.getGrille().creerBlocCarre();
|
||||
|
||||
// System.out.println("Sudoku :");
|
||||
// System.out.println(sudoku.getGrille().toString());
|
||||
|
||||
// System.out.println("Blocs :");
|
||||
// sudoku.getGrille().printBlocs();
|
||||
|
||||
// System.out.println("Symboles possibles :");
|
||||
// sudoku.getGrille().printSymbolesPossibles();
|
||||
|
||||
// ResolveurBacktraceSimple resolveur = new ResolveurBacktraceSimple();
|
||||
// resolveur.resoudre(sudoku, false);
|
||||
// System.out.println("Sudoku resolu :");
|
||||
// System.out.println(sudoku.getGrille().toString());
|
||||
// System.out.println("FIN TEST RESOLVEUR BACKTRACE SIMPLE");
|
||||
// }
|
||||
// }
|
||||
|
||||
@@ -9,7 +9,7 @@ public class TestResolveurBacktraceSimpleSudoku9 {
|
||||
@Test
|
||||
public void testResolution() {
|
||||
System.out.println("TEST RESOLVEUR BACKTRACE SIMPLE : ");
|
||||
System.out.println(new App().getGreeting());
|
||||
|
||||
// Create a new Sudoku
|
||||
Sudoku sudoku = new Sudoku(9);
|
||||
sudoku.getGrille().setSymbolesPossibles(new ArrayList<>(Arrays.asList(
|
||||
@@ -25,7 +25,8 @@ public class TestResolveurBacktraceSimpleSudoku9 {
|
||||
|
||||
sudoku.ajouterContrainte(new ContrainteLigne());
|
||||
sudoku.ajouterContrainte(new ContrainteColonne());
|
||||
sudoku.ajouterContrainte(new ContrainteBloc());
|
||||
sudoku.ajouterContrainte(
|
||||
new ContrainteBloc(sudoku.getGrille().getTaille() / 3, sudoku.getGrille().getTaille() / 3));
|
||||
|
||||
sudoku.getGrille().setCase(0, 0, Symbole.of(1));
|
||||
sudoku.getGrille().setCase(6, 1, Symbole.of(2));
|
||||
|
||||
@@ -9,7 +9,7 @@ public class TestSudokuEmojis {
|
||||
@Test
|
||||
public void sudokuEmojis() {
|
||||
System.out.println("TEST SUDOKU EMOJIS : ");
|
||||
System.out.println(new App().getGreeting());
|
||||
|
||||
// Create a new Sudoku
|
||||
Sudoku sudoku = new Sudoku(9);
|
||||
|
||||
@@ -28,7 +28,8 @@ public class TestSudokuEmojis {
|
||||
|
||||
sudoku.ajouterContrainte(new ContrainteLigne());
|
||||
sudoku.ajouterContrainte(new ContrainteColonne());
|
||||
sudoku.ajouterContrainte(new ContrainteBloc());
|
||||
sudoku.ajouterContrainte(
|
||||
new ContrainteBloc(sudoku.getGrille().getTaille() / 3, sudoku.getGrille().getTaille() / 3));
|
||||
|
||||
sudoku.getGrille().setCase(0, 0, Symbole.of("😎"));
|
||||
sudoku.getGrille().setCase(6, 1, Symbole.of("😂"));
|
||||
|
||||
@@ -9,7 +9,7 @@ public class TestSudokuLettres {
|
||||
@Test
|
||||
public void sudokuLettres() {
|
||||
System.out.println("TEST SUDOKU LETTRES : ");
|
||||
System.out.println(new App().getGreeting());
|
||||
|
||||
// Create a new Sudoku
|
||||
Sudoku sudoku = new Sudoku(9);
|
||||
|
||||
@@ -28,7 +28,8 @@ public class TestSudokuLettres {
|
||||
|
||||
sudoku.ajouterContrainte(new ContrainteLigne());
|
||||
sudoku.ajouterContrainte(new ContrainteColonne());
|
||||
sudoku.ajouterContrainte(new ContrainteBloc());
|
||||
sudoku.ajouterContrainte(
|
||||
new ContrainteBloc(sudoku.getGrille().getTaille() / 3, sudoku.getGrille().getTaille() / 3));
|
||||
|
||||
sudoku.getGrille().setCase(0, 0, Symbole.of("L"));
|
||||
sudoku.getGrille().setCase(6, 1, Symbole.of("E"));
|
||||
|
||||
@@ -9,7 +9,7 @@ public class TestSudokusString {
|
||||
@Test
|
||||
public void sudokuString() {
|
||||
System.out.println("TEST SUDOKU STRING : ");
|
||||
System.out.println(new App().getGreeting());
|
||||
|
||||
// Create a new Sudoku
|
||||
Sudoku sudoku = new Sudoku(9);
|
||||
|
||||
@@ -29,7 +29,8 @@ public class TestSudokusString {
|
||||
|
||||
sudoku.ajouterContrainte(new ContrainteLigne());
|
||||
sudoku.ajouterContrainte(new ContrainteColonne());
|
||||
sudoku.ajouterContrainte(new ContrainteBloc());
|
||||
sudoku.ajouterContrainte(
|
||||
new ContrainteBloc(sudoku.getGrille().getTaille() / 3, sudoku.getGrille().getTaille() / 3));
|
||||
|
||||
sudoku.getGrille().setCase(0, 0, Symbole.of("Sudoku"));
|
||||
sudoku.getGrille().setCase(6, 1, Symbole.of("String"));
|
||||
|
||||
Reference in New Issue
Block a user