Compare commits
18 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
| f52849c43f | |||
| 7308d45671 | |||
| 411e37951f | |||
| 7968d5fede | |||
| 86fe45c358 | |||
| ea868017ee | |||
| a060cde5b2 | |||
| a3e60c1c93 | |||
| 09776489fa | |||
| 436967da03 | |||
| 0f72113d67 | |||
| 690be279bd | |||
| b836670cda | |||
| f002667e54 | |||
| bf9bfc8323 | |||
| dd21b9a13a | |||
| a36960c57a | |||
| 1c1da09e1f |
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"
|
||||
}
|
||||
@@ -27,6 +27,14 @@ application {
|
||||
mainClass = 'sudoku.App'
|
||||
}
|
||||
|
||||
jar {
|
||||
manifest {
|
||||
attributes(
|
||||
'Main-Class': 'sudoku.App'
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
test {
|
||||
testLogging {
|
||||
// Affiche les événements de passage, échec, saut et sortie standard/erreur
|
||||
|
||||
@@ -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 {
|
||||
Sudoku.menuGrille();
|
||||
Sudoku.menu();
|
||||
} catch (Exception e) {
|
||||
System.err.println("Une erreur fatale est survenue : " + e.getMessage());
|
||||
e.printStackTrace();
|
||||
logger.log(Level.SEVERE, "Une erreur fatale est survenue : " + e.getMessage(), e);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -3,42 +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);
|
||||
}
|
||||
|
||||
public boolean contains(Symbole s) {
|
||||
for (Case c : cases) {
|
||||
if (c.getSymbole().equals(s)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Méthode permettant de renvoyer la couleur d'un bloc
|
||||
*
|
||||
* @return couleur du bloc
|
||||
*/
|
||||
public String getCouleur() {
|
||||
return couleur;
|
||||
}
|
||||
|
||||
public int getCouleurIndex() {
|
||||
return couleurIndex;
|
||||
}
|
||||
|
||||
/**
|
||||
* 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,24 +6,33 @@ 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;
|
||||
private final ArrayList<Bloc> blocs;
|
||||
private ArrayList<Symbole> symbolesPossibles;
|
||||
private final Sudoku sudoku;
|
||||
private final Sudoku sudoku; // Référence à Sudoku
|
||||
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];
|
||||
this.blocs = new ArrayList<>();
|
||||
this.symbolesPossibles = new ArrayList<>();
|
||||
this.sudoku = sudoku;
|
||||
// Pour un sudoku classique, on attend "taille" blocs, donc on génère "taille"
|
||||
// couleurs.
|
||||
initColors();
|
||||
|
||||
// Initialiser les cases
|
||||
@@ -34,70 +43,103 @@ 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;
|
||||
}
|
||||
|
||||
/**
|
||||
* Génère une palette de couleurs en fonction du nombre de blocs attendus.
|
||||
* Pour un sudoku classique, la grille est de taille n², et il y a n² blocs,
|
||||
* on génère donc 'taille' couleurs.
|
||||
*/
|
||||
private void initColors() {
|
||||
int numberOfColors = taille; // nombre de couleurs = nombre de blocs (pour sudoku classique)
|
||||
List<ColorGenerator.Color> colors = ColorGenerator.greatScheme(numberOfColors);
|
||||
// nombre de couleurs = nombre de blocs (pour sudoku classique)
|
||||
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)) {
|
||||
throw new IllegalArgumentException("Symbole non autorisé : " + symbole);
|
||||
}
|
||||
// Sauvegarder l'ancien symbole
|
||||
Symbole ancienSymbole = cases[ligne][colonne].getSymbole();
|
||||
|
||||
// Affecter le nouveau symbole
|
||||
cases[ligne][colonne].setSymbole(symbole);
|
||||
Case currentCase = cases[ligne][colonne];
|
||||
Symbole ancienSymbole = currentCase.getSymbole();
|
||||
currentCase.setSymbole(symbole);
|
||||
|
||||
// Vérifier les contraintes
|
||||
if (!sudoku.verifierToutesContraintes()) {
|
||||
// Revenir sur le changement
|
||||
cases[ligne][colonne].setSymbole(ancienSymbole);
|
||||
throw new IllegalArgumentException("SET CASE: Les contraintes ne sont pas respectées pour la case ("
|
||||
+ ligne + ", " + colonne + ")");
|
||||
if (!sudoku.verifierToutesContraintes() ||
|
||||
(multidoku != null && !multidoku.verifierContraintesPartagees())) {
|
||||
currentCase.setSymbole(ancienSymbole);
|
||||
throw new IllegalArgumentException(
|
||||
"Les contraintes ne sont pas respectées pour la case (" + ligne + ", " + colonne + ")");
|
||||
}
|
||||
} catch (Exception e) {
|
||||
Console.errorln(e.getMessage());
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 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 {
|
||||
@@ -109,6 +151,14 @@ public class Grille {
|
||||
}
|
||||
|
||||
// Choisir la couleur suivante en fonction du nombre de blocs déjà créés
|
||||
setCouleurBloc(positions);
|
||||
|
||||
} catch (IllegalArgumentException e) {
|
||||
Console.errorln(e.getMessage());
|
||||
}
|
||||
}
|
||||
|
||||
private void setCouleurBloc(List<int[]> positions) {
|
||||
int couleurIndex = blocs.size() % generatedColors.size();
|
||||
Bloc bloc = new Bloc(generatedColors.get(couleurIndex), couleurIndex);
|
||||
|
||||
@@ -116,17 +166,12 @@ public class Grille {
|
||||
bloc.ajouterCase(cases[pos[0]][pos[1]]);
|
||||
}
|
||||
blocs.add(bloc);
|
||||
|
||||
} catch (IllegalArgumentException e) {
|
||||
Console.errorln(e.getMessage());
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Crée des blocs carrés (par exemple pour un sudoku classique).
|
||||
*/
|
||||
public void creerBlocCarre() {
|
||||
try {
|
||||
int blocSize = (int) Math.sqrt(taille);
|
||||
if (blocSize * blocSize != taille) {
|
||||
throw new IllegalArgumentException("La taille de la grille doit être un carré parfait.");
|
||||
@@ -147,28 +192,18 @@ public class Grille {
|
||||
}
|
||||
}
|
||||
|
||||
// Affectation cyclique d'une couleur issue de la palette générée
|
||||
int couleurIndex = blocs.size() % generatedColors.size();
|
||||
Bloc bloc = new Bloc(generatedColors.get(couleurIndex), couleurIndex);
|
||||
|
||||
for (int[] pos : positions) {
|
||||
bloc.ajouterCase(cases[pos[0]][pos[1]]);
|
||||
setCouleurBloc(positions);
|
||||
}
|
||||
blocs.add(bloc);
|
||||
}
|
||||
}
|
||||
} catch (IllegalArgumentException e) {
|
||||
Console.errorln(e.getMessage());
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 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) {
|
||||
try {
|
||||
if (taille % blocHeight != 0 || taille % blocWidth != 0) {
|
||||
throw new IllegalArgumentException(
|
||||
"La taille de la grille doit être divisible par les dimensions des blocs.");
|
||||
@@ -192,26 +227,28 @@ public class Grille {
|
||||
}
|
||||
}
|
||||
|
||||
int couleurIndex = blocs.size() % generatedColors.size();
|
||||
Bloc bloc = new Bloc(generatedColors.get(couleurIndex), couleurIndex);
|
||||
|
||||
for (int[] pos : positions) {
|
||||
bloc.ajouterCase(cases[pos[0]][pos[1]]);
|
||||
setCouleurBloc(positions);
|
||||
}
|
||||
blocs.add(bloc);
|
||||
}
|
||||
}
|
||||
} catch (IllegalArgumentException e) {
|
||||
Console.errorln(e.getMessage());
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 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 :");
|
||||
@@ -233,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++) {
|
||||
@@ -256,7 +301,7 @@ public class Grille {
|
||||
break;
|
||||
|
||||
case 2: // Lettres
|
||||
if (input.length() == 1 && Character.isLetter(input.charAt(0))) {
|
||||
if (input.length() == 1 && Symbole.of(input.charAt(0)).isLetter()) {
|
||||
Symbole charTemp = Symbole.of(input.charAt(0));
|
||||
if (symbolesPossibles.contains(charTemp)) {
|
||||
Console.errorln("Ce symbole existe déjà, veuillez entrer un autre symbole");
|
||||
@@ -290,44 +335,66 @@ 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) {
|
||||
sb.append(symbole.toString()).append(" ");
|
||||
}
|
||||
System.out.println(sb.toString());
|
||||
System.out.println(sb);
|
||||
}
|
||||
|
||||
/**
|
||||
* Méthode permettant de retourner la taille de la grille
|
||||
*
|
||||
* @return taille
|
||||
*/
|
||||
public int getTaille() {
|
||||
return taille;
|
||||
}
|
||||
|
||||
private Bloc findBlocForCase(Case target) {
|
||||
Bloc findBlocForCase(Case target) {
|
||||
for (Bloc bloc : blocs) {
|
||||
if (bloc.getCases().contains(target)) {
|
||||
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
|
||||
@@ -350,17 +417,12 @@ public class Grille {
|
||||
return true;
|
||||
}
|
||||
|
||||
public Case getCaseLibre() {
|
||||
for (int i = 0; i < taille; i++) {
|
||||
for (int j = 0; j < taille; j++) {
|
||||
if (cases[i][j].getSymbole() == null) {
|
||||
return cases[i][j];
|
||||
}
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* 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) {
|
||||
@@ -371,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();
|
||||
@@ -382,23 +449,23 @@ public class Grille {
|
||||
String cellStr = currentCase.toString();
|
||||
// Calculer le nombre d'espaces à ajouter pour atteindre maxLen
|
||||
int pad = maxLen - cellStr.length();
|
||||
String padding = " ".repeat(pad); // nécessite Java 11 ou ultérieur
|
||||
String padding = " ".repeat(pad);
|
||||
|
||||
Bloc bloc = findBlocForCase(currentCase);
|
||||
|
||||
if (bloc != null) {
|
||||
sb.append(bloc.getCouleur()) // couleur du bloc
|
||||
.append(cellStr)
|
||||
.append(padding)
|
||||
.append(cellStr) // symbole
|
||||
.append(padding) // padding pour aligner les symboles
|
||||
.append("\u001B[0m ") // réinitialiser la couleur
|
||||
.append(" ");
|
||||
} else {
|
||||
} else { // pas de bloc, afficher normalement
|
||||
sb.append(cellStr)
|
||||
.append(padding)
|
||||
.append(" ");
|
||||
}
|
||||
}
|
||||
sb.append("\n");
|
||||
sb.append("\n"); // nouvelle ligne
|
||||
}
|
||||
return sb.toString();
|
||||
}
|
||||
|
||||
479
app/src/main/java/sudoku/Multidoku.java
Normal file
479
app/src/main/java/sudoku/Multidoku.java
Normal file
@@ -0,0 +1,479 @@
|
||||
package sudoku;
|
||||
|
||||
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);
|
||||
contraintesPartagees.add(contrainte);
|
||||
|
||||
// Vérifier immédiatement la validité après l'ajout
|
||||
if (!contrainte.estRespectee(null, null)) {
|
||||
throw new IllegalStateException(
|
||||
"La contrainte de partage n'est pas respectée après l'ajout des cases partagées");
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 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
|
||||
for (ContrainteCasePartagee contrainte : contraintesPartagees) {
|
||||
for (Case c : contrainte.getCasesLiees()) {
|
||||
if (c.getSymbole() == null) {
|
||||
Sudoku s = trouverSudokuPourCase(c);
|
||||
cells.add(new GlobalCell(s, c.getLigne(), c.getColonne()));
|
||||
}
|
||||
}
|
||||
}
|
||||
// Ajout ensuite des cases non partagées
|
||||
for (SudokuPlacement sp : placements) {
|
||||
Sudoku s = sp.sudoku();
|
||||
Grille g = s.getGrille();
|
||||
int taille = g.getTaille();
|
||||
for (int i = 0; i < taille; i++) {
|
||||
for (int j = 0; j < taille; j++) {
|
||||
Case c = g.getCase(i, j);
|
||||
if (c.getSymbole() == null && !isSharedCase(c)) {
|
||||
cells.add(new GlobalCell(s, i, j));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
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;
|
||||
}
|
||||
GlobalCell gc = globalCells.get(index);
|
||||
Sudoku s = gc.sudoku;
|
||||
Grille g = s.getGrille();
|
||||
Case c = g.getCase(gc.ligne, gc.colonne);
|
||||
List<Symbole> symboles = g.getSymbolesPossibles();
|
||||
|
||||
Symbole symboleOriginal = c.getSymbole();
|
||||
Map<Case, Symbole> sauvegarde = new HashMap<>();
|
||||
sauvegarde.put(c, symboleOriginal);
|
||||
|
||||
for (Symbole symbole : symboles) {
|
||||
// Affichage AVANT la tentative d'assignation
|
||||
if (afficherEtape) {
|
||||
System.out.println("\nTentative symbole " + symbole + " sur " + gc.sudoku.getNom() + " [" + gc.ligne
|
||||
+ "," + gc.colonne + "]");
|
||||
System.out.println(this); // Afficher l'état actuel
|
||||
}
|
||||
|
||||
boolean ok;
|
||||
if (isSharedCase(c)) { // Si la case est partagée, on doit propager la valeur dans les cases
|
||||
// correspondantes des autres sudokus concernés
|
||||
ok = setCaseAvecPropagation(gc.ligne, gc.colonne, symbole, s);
|
||||
} else {
|
||||
c.setSymbole(symbole);
|
||||
ok = s.estValide(c);
|
||||
if (!ok) {
|
||||
c.setSymbole(null);
|
||||
}
|
||||
}
|
||||
|
||||
if (ok) {
|
||||
if (afficherEtape) {
|
||||
System.out.println("-> Affectation réussie pour " + symbole);
|
||||
System.out.println(this);
|
||||
}
|
||||
if (globalValide() && resoudreGlobal(globalCells, index + 1, afficherEtape)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
// Backtracking : restauration de l'état sauvegardé
|
||||
restaurerCases(sauvegarde);
|
||||
if (afficherEtape) {
|
||||
System.out.println("Backtracking sur " + gc.sudoku.getNom() + " [" + gc.ligne + "," + gc.colonne + "]");
|
||||
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);
|
||||
Map<Case, Symbole> sauvegarde = new HashMap<>();
|
||||
|
||||
// Sauvegarde et définition de la case actuelle
|
||||
sauvegarde.put(c, c.getSymbole());
|
||||
c.setSymbole(symbole);
|
||||
|
||||
if (!s.estValide(c)) {
|
||||
restaurerCases(sauvegarde);
|
||||
return false;
|
||||
}
|
||||
|
||||
// Propagation à la case correspondante dans les autres sudokus concernés
|
||||
for (ContrainteCasePartagee contrainte : contraintesPartagees) {
|
||||
if (contrainte.getCasesLiees().contains(c)) {
|
||||
Case caseCorrespondante = contrainte.getCaseCorrespondante(c);
|
||||
if (caseCorrespondante != null) {
|
||||
sauvegarde.put(caseCorrespondante, caseCorrespondante.getSymbole());
|
||||
caseCorrespondante.setSymbole(symbole);
|
||||
|
||||
Sudoku autreSudoku = trouverSudokuPourCase(caseCorrespondante);
|
||||
if (autreSudoku != null && !autreSudoku.estValide(caseCorrespondante)) {
|
||||
restaurerCases(sauvegarde);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
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 (appartientAuSudoku(c, sp.sudoku())) {
|
||||
return sp.sudoku();
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* 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++) {
|
||||
for (int j = 0; j < taille; j++) {
|
||||
if (g.getCase(i, j) == c) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
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.sudoku().estValide())
|
||||
return false;
|
||||
}
|
||||
for (Contrainte c : contraintesPartagees) {
|
||||
if (!c.estRespectee(null, null))
|
||||
return false;
|
||||
}
|
||||
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)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* 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;
|
||||
this.colonne = colonne;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 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
|
||||
|
||||
/**
|
||||
* Constructeur de la contrainte de cases partagées.
|
||||
*
|
||||
* @param cases : liste de cases partagées
|
||||
*/
|
||||
public ContrainteCasePartagee(List<Case> cases) {
|
||||
this.casesLiees = new HashMap<>();
|
||||
|
||||
// Les cases sont données dans l'ordre : d'abord celles du premier sudoku,
|
||||
// puis celles du second dans le même ordre.
|
||||
int size = cases.size() / 2;
|
||||
for (int i = 0; i < size; i++) {
|
||||
Case c1 = cases.get(i);
|
||||
Case c2 = cases.get(i + size);
|
||||
casesLiees.put(c1, c2);
|
||||
casesLiees.put(c2, c1);
|
||||
}
|
||||
|
||||
// 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();
|
||||
Case c2 = entry.getValue();
|
||||
|
||||
if (c1.getSymbole() != null && c2.getSymbole() == null) {
|
||||
c2.setSymbole(c1.getSymbole());
|
||||
} else if (c2.getSymbole() != null && c1.getSymbole() == null) {
|
||||
c1.setSymbole(c2.getSymbole());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 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()) {
|
||||
Case c1 = entry.getKey();
|
||||
Case c2 = entry.getValue();
|
||||
|
||||
if (c1.getSymbole() != null && c2.getSymbole() != null
|
||||
&& !c1.getSymbole().equals(c2.getSymbole())) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
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();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 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.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
|
||||
int cellWidth = globalMaxLen + 1;
|
||||
|
||||
// 2. Création et initialisation de la matrice globale
|
||||
String[][] global = new String[maxLigne][maxColonne];
|
||||
for (int i = 0; i < maxLigne; i++) {
|
||||
for (int j = 0; j < maxColonne; j++) {
|
||||
global[i][j] = " ".repeat(cellWidth); // case vide affichée par défaut
|
||||
}
|
||||
}
|
||||
|
||||
// 3. Pour chaque sudoku, placer l'affichage de chacune de ses cases dans la
|
||||
// grille globale
|
||||
for (SudokuPlacement sp : placements) {
|
||||
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.offsetLigne() + i;
|
||||
int globalColonne = sp.offsetColonne() + j;
|
||||
|
||||
Case currentCase = grille.getCase(i, j);
|
||||
String cellStr = currentCase.toString();
|
||||
int pad = globalMaxLen - cellStr.length();
|
||||
String padding = " ".repeat(pad);
|
||||
|
||||
// Récupérer le bloc associé à la case afin d'obtenir sa couleur
|
||||
Bloc bloc = grille.findBlocForCase(currentCase);
|
||||
String cellDisplay;
|
||||
// Si la case est partagée, on force l'affichage en blanc
|
||||
if (isSharedCase(currentCase)) {
|
||||
cellDisplay = "\u001B[37m" + cellStr + padding + "\u001B[0m";
|
||||
} else {
|
||||
if (bloc != null) {
|
||||
cellDisplay = bloc.getCouleur() + cellStr + padding + "\u001B[0m";
|
||||
} else {
|
||||
cellDisplay = cellStr + padding;
|
||||
}
|
||||
}
|
||||
// Insertion dans la matrice globale (ajout d'un espace pour séparer les
|
||||
// colonnes)
|
||||
global[globalLigne][globalColonne] = cellDisplay + " ";
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 4. Construction de la chaîne d'affichage finale
|
||||
StringBuilder sb = new StringBuilder();
|
||||
for (int i = 0; i < maxLigne; i++) {
|
||||
for (int j = 0; j < maxColonne; j++) {
|
||||
sb.append(global[i][j]);
|
||||
}
|
||||
sb.append("\n");
|
||||
}
|
||||
return sb.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);
|
||||
}
|
||||
|
||||
@@ -2,20 +2,51 @@ package sudoku;
|
||||
|
||||
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 {
|
||||
|
||||
private final Sudoku sudoku;
|
||||
|
||||
public ResolveurBacktraceSimple(Sudoku sudoku) {
|
||||
this.sudoku = sudoku;
|
||||
/**
|
||||
* 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);
|
||||
return resoudre(s, afficherEtape, etat);
|
||||
boolean solved = resoudre(s, afficherEtape, etat);
|
||||
if (!solved) {
|
||||
Console.errorln("Ce Sudoku n'a pas de solution");
|
||||
}
|
||||
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;
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
package sudoku;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.HashSet;
|
||||
import java.util.List;
|
||||
import java.util.Scanner;
|
||||
@@ -8,23 +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);
|
||||
}
|
||||
|
||||
// public void creerBloc(List<int[]> positions, int blocHeight, int blocWidth) {
|
||||
// grille.creerBloc(positions, blocHeight, blocWidth);
|
||||
// }
|
||||
|
||||
/**
|
||||
* 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)) {
|
||||
@@ -34,19 +71,220 @@ 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++) {
|
||||
Case c = this.getGrille().getCase(i, j);
|
||||
if (c.getSymbole() != null && !this.estValide(c)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
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;
|
||||
}
|
||||
|
||||
public static Sudoku menuGrille() {
|
||||
/**
|
||||
* 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");
|
||||
|
||||
while (true) {
|
||||
System.out.println("\nChoisissez le type de jeu :");
|
||||
System.out.println("1 : Sudoku classique");
|
||||
System.out.println("2 : Multidoku (prérempli)");
|
||||
System.out.println("0 : Quitter");
|
||||
|
||||
try {
|
||||
int choix = Integer.parseInt(scanner.nextLine());
|
||||
|
||||
switch (choix) {
|
||||
case 0:
|
||||
System.out.println("Au revoir !");
|
||||
return;
|
||||
case 1:
|
||||
menuSudoku();
|
||||
break;
|
||||
case 2:
|
||||
menuMultidoku();
|
||||
break;
|
||||
default:
|
||||
System.out.println("Choix invalide. Veuillez réessayer.");
|
||||
}
|
||||
} catch (NumberFormatException e) {
|
||||
System.out.println("Entrée invalide. Veuillez entrer un nombre.");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static void menuMultidoku() {
|
||||
final int PAUSE_TIME = 3000; // 3 seconds
|
||||
|
||||
System.out.println("MULTIDOKU");
|
||||
System.out.println("\nChoisissez un type de Multidoku :");
|
||||
System.out.println("1 : Multidoku avec cases partagées");
|
||||
System.out.println("2 : Multidoku avec bloc partagé");
|
||||
System.out.println("3 : Multidoku avec ligne partagée");
|
||||
System.out.println("4 : Multidoku avec colonne partagée");
|
||||
|
||||
Scanner scanner = new Scanner(System.in);
|
||||
try {
|
||||
int choix = Integer.parseInt(scanner.nextLine());
|
||||
Multidoku multidoku = creerMultidoku(choix);
|
||||
if (multidoku != null) {
|
||||
System.out.println("\nMultidoku initial :");
|
||||
System.out.println(multidoku);
|
||||
|
||||
System.out.println("\nDébut de la résolution dans 3 secondes...");
|
||||
try {
|
||||
Thread.sleep(PAUSE_TIME);
|
||||
} catch (InterruptedException e) {
|
||||
Thread.currentThread().interrupt();
|
||||
}
|
||||
System.out.println("\nRésolution du Multidoku...");
|
||||
|
||||
if (multidoku.resoudreMultidoku(true)) {
|
||||
System.out.println("\nMultidoku résolu :");
|
||||
System.out.println(multidoku);
|
||||
} else {
|
||||
System.out.println("Ce Multidoku n'a pas de solution.");
|
||||
}
|
||||
}
|
||||
} catch (NumberFormatException e) {
|
||||
System.out.println("Entrée invalide. Veuillez entrer un nombre.");
|
||||
}
|
||||
}
|
||||
|
||||
private static Multidoku creerMultidoku(int type) {
|
||||
Multidoku multidoku = new Multidoku();
|
||||
Sudoku s1 = new Sudoku(9);
|
||||
Sudoku s2 = new Sudoku(9);
|
||||
s1.setNom("Sudoku 1");
|
||||
s2.setNom("Sudoku 2");
|
||||
|
||||
// Configuration commune
|
||||
ArrayList<Symbole> symboles = new ArrayList<>();
|
||||
for (int i = 1; i <= 9; i++) {
|
||||
symboles.add(Symbole.of(i));
|
||||
}
|
||||
|
||||
for (Sudoku s : Arrays.asList(s1, s2)) {
|
||||
s.getGrille().setSymbolesPossibles(symboles);
|
||||
s.ajouterContrainte(new ContrainteLigne());
|
||||
s.ajouterContrainte(new ContrainteColonne());
|
||||
s.ajouterContrainte(new ContrainteBloc(s.getGrille().getTaille(), s.getGrille().getTaille()));
|
||||
s.getGrille().creerBlocCarre();
|
||||
}
|
||||
|
||||
switch (type) {
|
||||
case 1: // Cases partagées
|
||||
multidoku.ajouterSudoku(s1, 0, 0);
|
||||
multidoku.ajouterSudoku(s2, 8, 8);
|
||||
multidoku.ajouterCasesPartagees(Arrays.asList(
|
||||
s1.getGrille().getCase(8, 8),
|
||||
s2.getGrille().getCase(0, 0)));
|
||||
break;
|
||||
case 2: // Bloc partagé
|
||||
multidoku.ajouterSudoku(s1, 0, 0);
|
||||
multidoku.ajouterSudoku(s2, 6, 6);
|
||||
List<Case> casesBloc = new ArrayList<>();
|
||||
for (int i = 6; i < 9; i++) {
|
||||
for (int j = 6; j < 9; j++) {
|
||||
casesBloc.add(s1.getGrille().getCase(i, j));
|
||||
}
|
||||
}
|
||||
for (int i = 0; i < 3; i++) {
|
||||
for (int j = 0; j < 3; j++) {
|
||||
casesBloc.add(s2.getGrille().getCase(i, j));
|
||||
}
|
||||
}
|
||||
multidoku.ajouterCasesPartagees(casesBloc);
|
||||
break;
|
||||
case 3: // Ligne partagée
|
||||
multidoku.ajouterSudoku(s1, 0, 0);
|
||||
multidoku.ajouterSudoku(s2, 8, 1);
|
||||
multidoku.ajouterCasesPartagees(Arrays.asList(s1.getGrille().getCase(8, 1),
|
||||
s1.getGrille().getCase(8, 2),
|
||||
s1.getGrille().getCase(8, 3),
|
||||
s1.getGrille().getCase(8, 4),
|
||||
s1.getGrille().getCase(8, 5),
|
||||
s1.getGrille().getCase(8, 6),
|
||||
s1.getGrille().getCase(8, 7),
|
||||
s1.getGrille().getCase(8, 8),
|
||||
|
||||
s2.getGrille().getCase(0, 0),
|
||||
s2.getGrille().getCase(0, 1),
|
||||
s2.getGrille().getCase(0, 2),
|
||||
s2.getGrille().getCase(0, 3),
|
||||
s2.getGrille().getCase(0, 4),
|
||||
s2.getGrille().getCase(0, 5),
|
||||
s2.getGrille().getCase(0, 6),
|
||||
s2.getGrille().getCase(0, 7)));
|
||||
break;
|
||||
case 4: // Colonne partagée
|
||||
multidoku.ajouterSudoku(s1, 0, 0);
|
||||
multidoku.ajouterSudoku(s2, 1, 8);
|
||||
multidoku.ajouterCasesPartagees(Arrays.asList(
|
||||
s1.getGrille().getCase(1, 8),
|
||||
s1.getGrille().getCase(2, 8),
|
||||
s1.getGrille().getCase(3, 8),
|
||||
s1.getGrille().getCase(4, 8),
|
||||
s1.getGrille().getCase(5, 8),
|
||||
s1.getGrille().getCase(6, 8),
|
||||
s1.getGrille().getCase(7, 8),
|
||||
s1.getGrille().getCase(8, 8),
|
||||
|
||||
s2.getGrille().getCase(0, 0),
|
||||
s2.getGrille().getCase(1, 0),
|
||||
s2.getGrille().getCase(2, 0),
|
||||
s2.getGrille().getCase(3, 0),
|
||||
s2.getGrille().getCase(4, 0),
|
||||
s2.getGrille().getCase(5, 0),
|
||||
s2.getGrille().getCase(6, 0),
|
||||
s2.getGrille().getCase(7, 0)));
|
||||
break;
|
||||
default:
|
||||
System.out.println("Type de Multidoku non valide");
|
||||
return null;
|
||||
}
|
||||
|
||||
return multidoku;
|
||||
}
|
||||
|
||||
/**
|
||||
* Méthode du menu principal du jeu de sudoku.
|
||||
*/
|
||||
public static void menuSudoku() {
|
||||
Scanner scanner = new Scanner(System.in);
|
||||
// ETAPE 1 : TAILLE GRILLE
|
||||
System.out.println("ETAPE 1 : Choisir la taille de la grille");
|
||||
int tailleGrille = setTailleGrille(scanner); // récpère la taille de la grille
|
||||
int tailleGrille = setTailleGrille(scanner); // récupère la taille de la grille
|
||||
Sudoku sudoku = new Sudoku(tailleGrille);
|
||||
// ETAPE 2 : SYMBOLE POSSIBLE
|
||||
System.out.println("ETAPE 2 : Choisir les symboles possibles");
|
||||
@@ -63,15 +301,13 @@ public class Sudoku {
|
||||
// ETAPE 5 : RESOLUTION
|
||||
System.out.println("ETAPE 5 : Résolution du sudoku");
|
||||
choixResolution(sudoku, scanner);
|
||||
|
||||
return sudoku;
|
||||
}
|
||||
|
||||
private static void choixContraintes(Sudoku sudoku, Scanner scanner) {
|
||||
System.out.println("Choisissez une combinaison entre 0 et 3 contraintes parmi les suivantes :");
|
||||
System.out.println("1: Contrainte Bloc, 2: Contrainte Ligne, 3: Contrainte Colonne");
|
||||
System.out.println(
|
||||
"Entrez les numéros des contraintes séparés par des virgules (par exemple, 1,2,3) ou appuyez sur Entrée pour aucune contrainte :");
|
||||
"Entrez les numéros des contraintes séparés par des virgules (par exemple, 1,2,3 pour choisir toute les contraintes) ou appuyez sur Entrée pour aucune contrainte :");
|
||||
|
||||
String input = scanner.nextLine();
|
||||
if (input.trim().isEmpty()) {
|
||||
@@ -97,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:
|
||||
@@ -115,7 +352,7 @@ public class Sudoku {
|
||||
}
|
||||
|
||||
private void resolutionSudoku(Sudoku sudoku, boolean afficherEtape) {
|
||||
ResolveurBacktraceSimple resolveur = new ResolveurBacktraceSimple(sudoku);
|
||||
ResolveurBacktraceSimple resolveur = new ResolveurBacktraceSimple();
|
||||
resolveur.resoudre(sudoku, afficherEtape);
|
||||
System.out.println("Sudoku résolu :");
|
||||
System.out.println(sudoku.getGrille().toString());
|
||||
@@ -125,8 +362,6 @@ public class Sudoku {
|
||||
System.out.println("Voulez-vous résoudre le sudoku ? (O/N)");
|
||||
String choix = scanner.nextLine();
|
||||
if (choix.equalsIgnoreCase("O")) {
|
||||
System.out.println("Résolution du sudoku.");
|
||||
// resolutionSudoku(sudoku);
|
||||
System.out.println("Voulez-vous afficher les étapes de la résolution ? (O/N)");
|
||||
String choixAffichageEtapes = scanner.nextLine();
|
||||
|
||||
@@ -151,38 +386,31 @@ 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;
|
||||
}
|
||||
|
||||
private static Sudoku setValeursGrille(Sudoku sudoku, Scanner scanner, int tailleGrille, int typeSymbole) {
|
||||
// Etude de la taille de la grille pour choisir le type de génération
|
||||
if (carreParfait(tailleGrille)) {
|
||||
System.out.println(tailleGrille + " est un carré parfait.");
|
||||
sudoku.getGrille().creerBlocCarre();
|
||||
} else {
|
||||
private static void setValeursGrille(Sudoku sudoku, Scanner scanner, int tailleGrille, int typeSymbole) {
|
||||
while (true) {
|
||||
try {
|
||||
System.out.println("Veuillez faire votre choix");
|
||||
System.out.println("1 : Entrer les blocs manuellement");
|
||||
System.out.println("2 : Entrer les blocs à l'aide de la longueur et de la largeur");
|
||||
System.out.println("3 : Générer des blocs carrés");
|
||||
|
||||
int choixGenerationBloc = Integer.parseInt(scanner.nextLine());
|
||||
|
||||
switch (choixGenerationBloc) {
|
||||
case 1:
|
||||
// Entrer les blocs manuellement
|
||||
System.out.println("Entrez les blocs manuellement.");
|
||||
creationBlocMannuel(sudoku, scanner, tailleGrille);
|
||||
creationBlocManuel(sudoku, scanner, tailleGrille);
|
||||
break;
|
||||
case 2:
|
||||
// Entrer les blocs à l'aide de la longueur et de la largeur
|
||||
boolean validDimensions = false;
|
||||
while (!validDimensions) {
|
||||
try {
|
||||
System.out.println("Entrez les blocs à l'aide de la longueur et de la largeur.");
|
||||
System.out.println("Entrez la longueur du bloc : ");
|
||||
@@ -190,18 +418,26 @@ public class Sudoku {
|
||||
System.out.println("Entrez la largeur du bloc :");
|
||||
int largeurBloc = Integer.parseInt(scanner.nextLine());
|
||||
sudoku.getGrille().creerBlocRectangulaire(longueurBloc, largeurBloc);
|
||||
validDimensions = true; // Sortir de la boucle si aucune exception n'est lancée
|
||||
break;
|
||||
} catch (IllegalArgumentException e) {
|
||||
Console.errorln("Erreur : " + e.getMessage());
|
||||
Console.errorln("Veuillez entrer des dimensions valides.");
|
||||
}
|
||||
continue;
|
||||
}
|
||||
case 3:
|
||||
try {
|
||||
sudoku.getGrille().creerBlocCarre();
|
||||
break;
|
||||
} catch (IllegalArgumentException e) {
|
||||
Console.errorln("Erreur : " + e.getMessage());
|
||||
continue;
|
||||
}
|
||||
default:
|
||||
Console.errorln("Choix invalide.");
|
||||
continue;
|
||||
}
|
||||
break;
|
||||
break; // Sort de la boucle si la création des blocs a réussi
|
||||
} catch (NumberFormatException e) {
|
||||
Console.errorln("Erreur : Veuillez entrer un nombre valide.");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -219,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"
|
||||
@@ -235,48 +471,48 @@ public class Sudoku {
|
||||
}
|
||||
|
||||
// Demander et vérifier la colonne
|
||||
int colonne = -1;
|
||||
int colonne;
|
||||
while (true) {
|
||||
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).");
|
||||
}
|
||||
}
|
||||
|
||||
// Demander et vérifier le symbole
|
||||
String symbole = "";
|
||||
String symbole;
|
||||
while (true) {
|
||||
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 {
|
||||
Symbole s = null;
|
||||
Symbole s;
|
||||
switch (typeSymbole) {
|
||||
case 1:
|
||||
// Entiers
|
||||
case 1: // Entiers
|
||||
if (!Symbole.of(symbole).isInt()) {
|
||||
throw new IllegalArgumentException("Veuillez entrer un nombre valide.");
|
||||
}
|
||||
s = Symbole.of(Integer.parseInt(symbole));
|
||||
break;
|
||||
case 2:
|
||||
// Lettres
|
||||
if (symbole.length() == 1 && Character.isLetter(symbole.charAt(0))) {
|
||||
s = Symbole.of(symbole.charAt(0));
|
||||
} else {
|
||||
case 2: // Lettres
|
||||
Symbole tempSymbole = Symbole.of(symbole);
|
||||
if (!tempSymbole.isLetter()) {
|
||||
throw new IllegalArgumentException("Veuillez entrer une seule lettre.");
|
||||
}
|
||||
s = tempSymbole;
|
||||
break;
|
||||
case 3:
|
||||
// Chaînes de caractères
|
||||
case 3: // Chaînes de caractères
|
||||
s = Symbole.of(symbole);
|
||||
break;
|
||||
default:
|
||||
@@ -291,18 +527,9 @@ public class Sudoku {
|
||||
}
|
||||
}
|
||||
}
|
||||
return sudoku;
|
||||
}
|
||||
|
||||
private static boolean carreParfait(int nombre) {
|
||||
if (nombre < 0) {
|
||||
return false;
|
||||
}
|
||||
int racine = (int) Math.sqrt(nombre);
|
||||
return racine * racine == nombre;
|
||||
}
|
||||
|
||||
private static Sudoku creationBlocMannuel(Sudoku sudoku, Scanner scanner, int tailleGrille) {
|
||||
private static void creationBlocManuel(Sudoku sudoku, Scanner scanner, int tailleGrille) {
|
||||
int nombreBloc = tailleGrille; // Nombre de blocs dans la grille
|
||||
|
||||
Set<String> toutesLesCoordonnees = new HashSet<>(); // Stocke toutes les coordonnées utilisées
|
||||
@@ -329,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;
|
||||
}
|
||||
@@ -337,10 +564,9 @@ 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;
|
||||
continue;
|
||||
}
|
||||
|
||||
} while (!coordonneesValides); // Tant que la saisie est invalide, on redemande
|
||||
@@ -355,13 +581,12 @@ 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
|
||||
}
|
||||
|
||||
nombreBloc--; // Passer au bloc suivant
|
||||
}
|
||||
return sudoku;
|
||||
}
|
||||
}
|
||||
12
app/src/main/java/sudoku/SudokuPlacement.java
Normal file
12
app/src/main/java/sudoku/SudokuPlacement.java
Normal file
@@ -0,0 +1,12 @@
|
||||
package sudoku;
|
||||
|
||||
/**
|
||||
* 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)
|
||||
@@ -48,8 +96,4 @@ public class Symbole {
|
||||
Symbole symbole = (Symbole) obj;
|
||||
return valeur.equals(symbole.valeur);
|
||||
}
|
||||
|
||||
public int getHashCode() {
|
||||
return valeur.hashCode();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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,11 +55,12 @@ 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());
|
||||
|
||||
Resolveur resolveur = new ResolveurBacktraceSimple(sudoku);
|
||||
Resolveur resolveur = new ResolveurBacktraceSimple();
|
||||
resolveur.resoudre(sudoku, false);
|
||||
System.out.println("Sudoku résolu :");
|
||||
System.out.println(sudoku.getGrille().toString());
|
||||
|
||||
@@ -10,7 +10,7 @@ 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);
|
||||
|
||||
@@ -20,7 +20,8 @@ public class TestBlocParticuliers {
|
||||
Symbole.of(3),
|
||||
Symbole.of(4))));
|
||||
|
||||
sudoku.ajouterContrainte(new ContrainteBloc());
|
||||
sudoku.ajouterContrainte(new ContrainteBloc(sudoku.getGrille().getTaille() / 2,
|
||||
sudoku.getGrille().getTaille() / 2));
|
||||
sudoku.ajouterContrainte(new ContrainteLigne());
|
||||
sudoku.ajouterContrainte(new ContrainteColonne());
|
||||
|
||||
@@ -58,7 +59,7 @@ public class TestBlocParticuliers {
|
||||
System.out.println("Symboles possibles :");
|
||||
sudoku.getGrille().printSymbolesPossibles();
|
||||
|
||||
ResolveurBacktraceSimple resolveur = new ResolveurBacktraceSimple(sudoku);
|
||||
ResolveurBacktraceSimple resolveur = new ResolveurBacktraceSimple();
|
||||
resolveur.resoudre(sudoku, true);
|
||||
|
||||
System.out.println("Sudoku résolu :");
|
||||
|
||||
@@ -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));
|
||||
@@ -45,9 +46,6 @@ public class TestBlocRectangle {
|
||||
System.out.println("Symboles possibles :");
|
||||
sudoku.getGrille().printSymbolesPossibles();
|
||||
|
||||
// blocRectangle.resoudre(sudoku, true);
|
||||
// System.out.println("Sudoku resolu :");
|
||||
// System.out.println(sudoku.getGrille().toString());
|
||||
System.out.println("FIN TEST BLOC RECTANGLE");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -5,9 +5,9 @@ import org.junit.jupiter.api.Test;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
|
||||
public class TestCreationGrille {
|
||||
public class TestCreationGrilleRectangulaireSansSolution {
|
||||
@Test
|
||||
public void testLigne() {
|
||||
public void testCreationGrilleSansSolution() {
|
||||
// CREATION D'UN SUDOKU SIMPLE 12*12
|
||||
Sudoku sudoku = new Sudoku(12);
|
||||
sudoku.getGrille().setSymbolesPossibles(new ArrayList<>(Arrays.asList(
|
||||
@@ -88,7 +88,8 @@ public class TestCreationGrille {
|
||||
|
||||
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());
|
||||
|
||||
@@ -98,6 +99,12 @@ public class TestCreationGrille {
|
||||
sudoku.getGrille().printBlocs();
|
||||
System.out.println("Symboles possibles :");
|
||||
sudoku.getGrille().printSymbolesPossibles();
|
||||
|
||||
ResolveurBacktraceSimple resolveur = new ResolveurBacktraceSimple();
|
||||
boolean solved = resolveur.resoudre(sudoku, false);
|
||||
System.out.println("Sudoku " + (solved ? "résolu" : "non résolu") + " :");
|
||||
System.out.println(sudoku.getGrille().toString());
|
||||
|
||||
System.out.println("FIN TEST LIGNE");
|
||||
}
|
||||
}
|
||||
@@ -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));
|
||||
@@ -39,7 +38,6 @@ public class TestDoublonBloc {
|
||||
sudoku.getGrille().setCase(4, 8, Symbole.of(9));
|
||||
// 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(
|
||||
|
||||
92
app/src/test/java/sudoku/TestMultidokuBloc.java
Normal file
92
app/src/test/java/sudoku/TestMultidokuBloc.java
Normal file
@@ -0,0 +1,92 @@
|
||||
package sudoku;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
public class TestMultidokuBloc {
|
||||
|
||||
@Test
|
||||
public void testMultidokuBloc() {
|
||||
Multidoku multidoku = new Multidoku();
|
||||
Sudoku s1 = new Sudoku(9);
|
||||
Sudoku s2 = new Sudoku(9);
|
||||
|
||||
s1.setNom("Sudoku 1");
|
||||
s2.setNom("Sudoku 2");
|
||||
|
||||
// Placer sudoku1 en haut à gauche (offset (0,0))
|
||||
multidoku.ajouterSudoku(s1, 0, 0);
|
||||
|
||||
// Placer sudoku2 de façon à ce que sa case (0,0) se retrouve en (6,6) de la
|
||||
// grille globale
|
||||
multidoku.ajouterSudoku(s2, 6, 6);
|
||||
|
||||
ArrayList<Symbole> symboles = new ArrayList<>();
|
||||
for (int i = 10; i <= 19; i++) {
|
||||
symboles.add(Symbole.of(i));
|
||||
}
|
||||
|
||||
s1.getGrille().setSymbolesPossibles(symboles);
|
||||
List<Sudoku> sudokus = Arrays.asList(s1, s2);
|
||||
for (Sudoku sudoku : sudokus) {
|
||||
sudoku.getGrille().setSymbolesPossibles(symboles);
|
||||
sudoku.ajouterContrainte(new ContrainteLigne());
|
||||
sudoku.ajouterContrainte(new ContrainteColonne());
|
||||
sudoku.ajouterContrainte(
|
||||
new ContrainteBloc(sudoku.getGrille().getTaille() / 3, sudoku.getGrille().getTaille() / 3));
|
||||
sudoku.getGrille().creerBlocCarre();
|
||||
}
|
||||
|
||||
for (int i = 0; i < s1.getGrille().getTaille(); i++) {
|
||||
s1.getGrille().setCase(i, i, symboles.get(i));
|
||||
}
|
||||
|
||||
// Créer un lien entre la case (6,6) de s1 et (0,0) de s2
|
||||
List<Case> casesPartagees = Arrays.asList(
|
||||
s1.getGrille().getCase(6, 6),
|
||||
s1.getGrille().getCase(6, 7),
|
||||
s1.getGrille().getCase(6, 8),
|
||||
s1.getGrille().getCase(7, 6),
|
||||
s1.getGrille().getCase(7, 7),
|
||||
s1.getGrille().getCase(7, 8),
|
||||
s1.getGrille().getCase(8, 6),
|
||||
s1.getGrille().getCase(8, 7),
|
||||
s1.getGrille().getCase(8, 8),
|
||||
|
||||
s2.getGrille().getCase(0, 0),
|
||||
s2.getGrille().getCase(0, 1),
|
||||
s2.getGrille().getCase(0, 2),
|
||||
s2.getGrille().getCase(1, 0),
|
||||
s2.getGrille().getCase(1, 1),
|
||||
s2.getGrille().getCase(1, 2),
|
||||
s2.getGrille().getCase(2, 0),
|
||||
s2.getGrille().getCase(2, 1),
|
||||
s2.getGrille().getCase(2, 2));
|
||||
multidoku.ajouterCasesPartagees(casesPartagees);
|
||||
|
||||
System.out.println("Sudoku 1 :");
|
||||
System.out.println(s1.getGrille().toString());
|
||||
|
||||
System.out.println("Sudoku 2 :");
|
||||
System.out.println(s2.getGrille().toString());
|
||||
|
||||
System.out.println("\nAffichage Multidoku combiné :");
|
||||
System.out.println(multidoku.toString());
|
||||
|
||||
if (multidoku.resoudreMultidoku(false)) {
|
||||
System.out.println("Multidoku résolu :");
|
||||
System.out.println(multidoku.toString());
|
||||
} else {
|
||||
System.out.println("Multidoku non résolu");
|
||||
}
|
||||
|
||||
System.out.println("Sudoku 1 résolu :");
|
||||
System.out.println(s1.getGrille().toString());
|
||||
|
||||
System.out.println("Sudoku 2 résolu :");
|
||||
System.out.println(s2.getGrille().toString());
|
||||
}
|
||||
}
|
||||
74
app/src/test/java/sudoku/TestMultidokuCase.java
Normal file
74
app/src/test/java/sudoku/TestMultidokuCase.java
Normal file
@@ -0,0 +1,74 @@
|
||||
package sudoku;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
public class TestMultidokuCase {
|
||||
|
||||
@Test
|
||||
public void testMultidokuCase() {
|
||||
Multidoku multidoku = new Multidoku();
|
||||
Sudoku s1 = new Sudoku(9);
|
||||
Sudoku s2 = new Sudoku(9);
|
||||
|
||||
s1.setNom("Sudoku 1");
|
||||
s2.setNom("Sudoku 2");
|
||||
|
||||
// Placer sudoku1 en haut à gauche (offset (0,0))
|
||||
multidoku.ajouterSudoku(s1, 0, 0);
|
||||
// Placer sudoku2 de façon à ce que sa case (0,0) se retrouve en (8,8) de la
|
||||
// grille globale
|
||||
multidoku.ajouterSudoku(s2, 8, 8);
|
||||
|
||||
// Créer un lien entre la case (8,8) de s1 et (0,0) de s2
|
||||
List<Case> casesPartagees = Arrays.asList(
|
||||
s1.getGrille().getCase(8, 8),
|
||||
s2.getGrille().getCase(0, 0));
|
||||
multidoku.ajouterCasesPartagees(casesPartagees);
|
||||
|
||||
ArrayList<Symbole> symboles = new ArrayList<>();
|
||||
for (int i = 10; i <= 19; i++) {
|
||||
symboles.add(Symbole.of(i));
|
||||
}
|
||||
|
||||
s1.getGrille().setSymbolesPossibles(symboles);
|
||||
List<Sudoku> sudokus = Arrays.asList(s1, s2);
|
||||
for (Sudoku sudoku : sudokus) {
|
||||
sudoku.getGrille().setSymbolesPossibles(symboles);
|
||||
sudoku.ajouterContrainte(new ContrainteLigne());
|
||||
sudoku.ajouterContrainte(new ContrainteColonne());
|
||||
sudoku.ajouterContrainte(
|
||||
new ContrainteBloc(sudoku.getGrille().getTaille() / 3, sudoku.getGrille().getTaille() / 3));
|
||||
sudoku.getGrille().creerBlocCarre();
|
||||
}
|
||||
|
||||
for (int i = 0; i < s1.getGrille().getTaille(); i++) {
|
||||
s1.getGrille().setCase(i, i, symboles.get(i));
|
||||
}
|
||||
|
||||
System.out.println("Sudoku 1 :");
|
||||
System.out.println(s1.getGrille().toString());
|
||||
|
||||
System.out.println("Sudoku 2 :");
|
||||
System.out.println(s2.getGrille().toString());
|
||||
|
||||
System.out.println("\nAffichage Multidoku combiné :");
|
||||
System.out.println(multidoku.toString());
|
||||
|
||||
if (multidoku.resoudreMultidoku(false)) {
|
||||
System.out.println("Multidoku résolu !");
|
||||
System.out.println(multidoku.toString());
|
||||
} else {
|
||||
System.out.println("Échec de la résolution du multidoku.");
|
||||
}
|
||||
|
||||
System.out.println("Sudoku 1 résolu :");
|
||||
System.out.println(s1.getGrille().toString());
|
||||
|
||||
System.out.println("Sudoku 2 résolu :");
|
||||
System.out.println(s2.getGrille().toString());
|
||||
}
|
||||
}
|
||||
87
app/src/test/java/sudoku/TestMultidokuColonne.java
Normal file
87
app/src/test/java/sudoku/TestMultidokuColonne.java
Normal file
@@ -0,0 +1,87 @@
|
||||
package sudoku;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
public class TestMultidokuColonne {
|
||||
@Test
|
||||
public void testMultidokuColonne() {
|
||||
Multidoku multidoku = new Multidoku();
|
||||
Sudoku s1 = new Sudoku(9);
|
||||
Sudoku s2 = new Sudoku(9);
|
||||
|
||||
s1.setNom("Sudoku 1");
|
||||
s2.setNom("Sudoku 2");
|
||||
|
||||
// Placer sudoku1 en haut à gauche (offset (0,0))
|
||||
multidoku.ajouterSudoku(s1, 0, 0);
|
||||
|
||||
multidoku.ajouterSudoku(s2, 1, 8);
|
||||
|
||||
ArrayList<Symbole> symboles = new ArrayList<>();
|
||||
for (int i = 10; i <= 19; i++) {
|
||||
symboles.add(Symbole.of(i));
|
||||
}
|
||||
|
||||
s1.getGrille().setSymbolesPossibles(symboles);
|
||||
List<Sudoku> sudokus = Arrays.asList(s1, s2);
|
||||
for (Sudoku sudoku : sudokus) {
|
||||
sudoku.getGrille().setSymbolesPossibles(symboles);
|
||||
sudoku.ajouterContrainte(new ContrainteLigne());
|
||||
sudoku.ajouterContrainte(new ContrainteColonne());
|
||||
sudoku.ajouterContrainte(
|
||||
new ContrainteBloc(sudoku.getGrille().getTaille() / 3, sudoku.getGrille().getTaille() / 3));
|
||||
sudoku.getGrille().creerBlocCarre();
|
||||
}
|
||||
|
||||
for (int i = 0; i < s1.getGrille().getTaille(); i++) {
|
||||
s1.getGrille().setCase(i, i, symboles.get(i));
|
||||
}
|
||||
|
||||
List<Case> casesPartagees = Arrays.asList(
|
||||
s1.getGrille().getCase(1, 8),
|
||||
s1.getGrille().getCase(2, 8),
|
||||
s1.getGrille().getCase(3, 8),
|
||||
s1.getGrille().getCase(4, 8),
|
||||
s1.getGrille().getCase(5, 8),
|
||||
s1.getGrille().getCase(6, 8),
|
||||
s1.getGrille().getCase(7, 8),
|
||||
s1.getGrille().getCase(8, 8),
|
||||
|
||||
s2.getGrille().getCase(0, 0),
|
||||
s2.getGrille().getCase(1, 0),
|
||||
s2.getGrille().getCase(2, 0),
|
||||
s2.getGrille().getCase(3, 0),
|
||||
s2.getGrille().getCase(4, 0),
|
||||
s2.getGrille().getCase(5, 0),
|
||||
s2.getGrille().getCase(6, 0),
|
||||
s2.getGrille().getCase(7, 0));
|
||||
|
||||
multidoku.ajouterCasesPartagees(casesPartagees);
|
||||
|
||||
System.out.println("Sudoku 1 :");
|
||||
System.out.println(s1.getGrille().toString());
|
||||
|
||||
System.out.println("Sudoku 2 :");
|
||||
System.out.println(s2.getGrille().toString());
|
||||
|
||||
System.out.println("\nAffichage Multidoku combiné :");
|
||||
System.out.println(multidoku.toString());
|
||||
|
||||
if (multidoku.resoudreMultidoku(false)) {
|
||||
System.out.println("Multidoku résolu :");
|
||||
System.out.println(multidoku.toString());
|
||||
} else {
|
||||
System.out.println("Multidoku non résolu");
|
||||
}
|
||||
|
||||
System.out.println("Sudoku 1 résolu :");
|
||||
System.out.println(s1.getGrille().toString());
|
||||
|
||||
System.out.println("Sudoku 2 résolu :");
|
||||
System.out.println(s2.getGrille().toString());
|
||||
}
|
||||
}
|
||||
87
app/src/test/java/sudoku/TestMultidokuLigne.java
Normal file
87
app/src/test/java/sudoku/TestMultidokuLigne.java
Normal file
@@ -0,0 +1,87 @@
|
||||
package sudoku;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
public class TestMultidokuLigne {
|
||||
@Test
|
||||
public void testMultidokuLigne() {
|
||||
Multidoku multidoku = new Multidoku();
|
||||
Sudoku s1 = new Sudoku(9);
|
||||
Sudoku s2 = new Sudoku(9);
|
||||
|
||||
s1.setNom("Sudoku 1");
|
||||
s2.setNom("Sudoku 2");
|
||||
|
||||
// Placer sudoku1 en haut à gauche (offset (0,0))
|
||||
multidoku.ajouterSudoku(s1, 0, 0);
|
||||
|
||||
multidoku.ajouterSudoku(s2, 8, 1);
|
||||
|
||||
ArrayList<Symbole> symboles = new ArrayList<>();
|
||||
for (int i = 10; i <= 19; i++) {
|
||||
symboles.add(Symbole.of(i));
|
||||
}
|
||||
|
||||
s1.getGrille().setSymbolesPossibles(symboles);
|
||||
List<Sudoku> sudokus = Arrays.asList(s1, s2);
|
||||
for (Sudoku sudoku : sudokus) {
|
||||
sudoku.getGrille().setSymbolesPossibles(symboles);
|
||||
sudoku.ajouterContrainte(new ContrainteLigne());
|
||||
sudoku.ajouterContrainte(new ContrainteColonne());
|
||||
sudoku.ajouterContrainte(
|
||||
new ContrainteBloc(sudoku.getGrille().getTaille() / 3, sudoku.getGrille().getTaille() / 3));
|
||||
sudoku.getGrille().creerBlocCarre();
|
||||
}
|
||||
|
||||
for (int i = 0; i < s1.getGrille().getTaille(); i++) {
|
||||
s1.getGrille().setCase(i, i, symboles.get(i));
|
||||
}
|
||||
|
||||
List<Case> casesPartagees = Arrays.asList(
|
||||
s1.getGrille().getCase(8, 1),
|
||||
s1.getGrille().getCase(8, 2),
|
||||
s1.getGrille().getCase(8, 3),
|
||||
s1.getGrille().getCase(8, 4),
|
||||
s1.getGrille().getCase(8, 5),
|
||||
s1.getGrille().getCase(8, 6),
|
||||
s1.getGrille().getCase(8, 7),
|
||||
s1.getGrille().getCase(8, 8),
|
||||
|
||||
s2.getGrille().getCase(0, 0),
|
||||
s2.getGrille().getCase(0, 1),
|
||||
s2.getGrille().getCase(0, 2),
|
||||
s2.getGrille().getCase(0, 3),
|
||||
s2.getGrille().getCase(0, 4),
|
||||
s2.getGrille().getCase(0, 5),
|
||||
s2.getGrille().getCase(0, 6),
|
||||
s2.getGrille().getCase(0, 7));
|
||||
|
||||
multidoku.ajouterCasesPartagees(casesPartagees);
|
||||
|
||||
System.out.println("Sudoku 1 :");
|
||||
System.out.println(s1.getGrille().toString());
|
||||
|
||||
System.out.println("Sudoku 2 :");
|
||||
System.out.println(s2.getGrille().toString());
|
||||
|
||||
System.out.println("\nAffichage Multidoku combiné :");
|
||||
System.out.println(multidoku.toString());
|
||||
|
||||
if (multidoku.resoudreMultidoku(false)) {
|
||||
System.out.println("Multidoku résolu :");
|
||||
System.out.println(multidoku.toString());
|
||||
} else {
|
||||
System.out.println("Multidoku non résolu");
|
||||
}
|
||||
|
||||
System.out.println("Sudoku 1 résolu :");
|
||||
System.out.println(s1.getGrille().toString());
|
||||
|
||||
System.out.println("Sudoku 2 résolu :");
|
||||
System.out.println(s2.getGrille().toString());
|
||||
}
|
||||
}
|
||||
@@ -1,70 +1,71 @@
|
||||
// package sudoku;
|
||||
package sudoku;
|
||||
|
||||
// import java.util.ArrayList;
|
||||
// import java.util.Arrays;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
|
||||
// import org.junit.jupiter.api.Test;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
// 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(
|
||||
// Symbole.of(1),
|
||||
// Symbole.of(2),
|
||||
// Symbole.of(3),
|
||||
// Symbole.of(4),
|
||||
// Symbole.of(5),
|
||||
// Symbole.of(6),
|
||||
// Symbole.of(7),
|
||||
// Symbole.of(8),
|
||||
// Symbole.of(9),
|
||||
// Symbole.of(10),
|
||||
// Symbole.of(11),
|
||||
// Symbole.of(12),
|
||||
// Symbole.of(13),
|
||||
// Symbole.of(14),
|
||||
// Symbole.of(15),
|
||||
// Symbole.of(16)
|
||||
public class TestResolveurBacktraceSimpleSudoku16 {
|
||||
@Test
|
||||
public void testResolution() {
|
||||
System.out.println("TEST RESOLVEUR BACKTRACE SIMPLE : ");
|
||||
|
||||
// )));
|
||||
// Create a new Sudoku
|
||||
Sudoku sudoku = new Sudoku(16);
|
||||
sudoku.getGrille().setSymbolesPossibles(new ArrayList<>(Arrays.asList(
|
||||
Symbole.of(1),
|
||||
Symbole.of(2),
|
||||
Symbole.of(3),
|
||||
Symbole.of(4),
|
||||
Symbole.of(5),
|
||||
Symbole.of(6),
|
||||
Symbole.of(7),
|
||||
Symbole.of(8),
|
||||
Symbole.of(9),
|
||||
Symbole.of(10),
|
||||
Symbole.of(11),
|
||||
Symbole.of(12),
|
||||
Symbole.of(13),
|
||||
Symbole.of(14),
|
||||
Symbole.of(15),
|
||||
Symbole.of(16)
|
||||
|
||||
// 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(10));
|
||||
// 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.ajouterContrainte(new ContrainteLigne());
|
||||
sudoku.ajouterContrainte(new ContrainteColonne());
|
||||
sudoku.ajouterContrainte(
|
||||
new ContrainteBloc(sudoku.getGrille().getTaille() / 4, sudoku.getGrille().getTaille() / 4));
|
||||
|
||||
// sudoku.getGrille().creerBlocCarre();
|
||||
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(10));
|
||||
sudoku.getGrille().setCase(6, 10, Symbole.of(11));
|
||||
sudoku.getGrille().setCase(2, 11, Symbole.of(12));
|
||||
sudoku.getGrille().setCase(0, 12, Symbole.of(13));
|
||||
|
||||
// System.out.println("Sudoku :");
|
||||
// System.out.println(sudoku.getGrille().toString());
|
||||
sudoku.getGrille().creerBlocCarre();
|
||||
|
||||
// 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(sudoku);
|
||||
// resolveur.resoudre(sudoku, false);
|
||||
// System.out.println("Sudoku resolu :");
|
||||
// System.out.println(sudoku.getGrille().toString());
|
||||
// System.out.println("FIN TEST RESOLVEUR BACKTRACE SIMPLE");
|
||||
// }
|
||||
// }
|
||||
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");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,3 +1,9 @@
|
||||
/**
|
||||
* TestResolveurBacktraceSimpleSudoku25
|
||||
* Tentative de résolution d'un sudoku 25x25 avec le resolveur backtrace simple
|
||||
* Commenté car la résolution avec le resolveur backtrace simple est trop longue
|
||||
*/
|
||||
|
||||
// package sudoku;
|
||||
|
||||
// import java.util.ArrayList;
|
||||
@@ -8,7 +14,7 @@
|
||||
// @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);
|
||||
|
||||
@@ -20,7 +26,8 @@
|
||||
|
||||
// sudoku.ajouterContrainte(new ContrainteLigne());
|
||||
// sudoku.ajouterContrainte(new ContrainteColonne());
|
||||
// sudoku.ajouterContrainte(new ContrainteBloc());
|
||||
// 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));
|
||||
@@ -47,7 +54,7 @@
|
||||
// System.out.println("Symboles possibles :");
|
||||
// sudoku.getGrille().printSymbolesPossibles();
|
||||
|
||||
// ResolveurBacktraceSimple resolveur = new ResolveurBacktraceSimple(sudoku);
|
||||
// ResolveurBacktraceSimple resolveur = new ResolveurBacktraceSimple();
|
||||
// resolveur.resoudre(sudoku, false);
|
||||
// System.out.println("Sudoku resolu :");
|
||||
// System.out.println(sudoku.getGrille().toString());
|
||||
|
||||
@@ -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));
|
||||
@@ -48,7 +49,7 @@ public class TestResolveurBacktraceSimpleSudoku9 {
|
||||
System.out.println("Symboles possibles :");
|
||||
sudoku.getGrille().printSymbolesPossibles();
|
||||
|
||||
ResolveurBacktraceSimple resolveur = new ResolveurBacktraceSimple(sudoku);
|
||||
ResolveurBacktraceSimple resolveur = new ResolveurBacktraceSimple();
|
||||
resolveur.resoudre(sudoku, false);
|
||||
System.out.println("Sudoku resolu :");
|
||||
System.out.println(sudoku.getGrille().toString());
|
||||
|
||||
62
app/src/test/java/sudoku/TestSudokuEmojis.java
Normal file
62
app/src/test/java/sudoku/TestSudokuEmojis.java
Normal file
@@ -0,0 +1,62 @@
|
||||
package sudoku;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
public class TestSudokuEmojis {
|
||||
@Test
|
||||
public void sudokuEmojis() {
|
||||
System.out.println("TEST SUDOKU EMOJIS : ");
|
||||
|
||||
// Create a new Sudoku
|
||||
Sudoku sudoku = new Sudoku(9);
|
||||
|
||||
List<Symbole> symboles = new ArrayList<>();
|
||||
symboles.add(Symbole.of("😎"));
|
||||
symboles.add(Symbole.of("😂"));
|
||||
symboles.add(Symbole.of("😍"));
|
||||
symboles.add(Symbole.of("😜"));
|
||||
symboles.add(Symbole.of("😇"));
|
||||
symboles.add(Symbole.of("😘"));
|
||||
symboles.add(Symbole.of("😋"));
|
||||
symboles.add(Symbole.of("😊"));
|
||||
symboles.add(Symbole.of("😉"));
|
||||
sudoku.getGrille()
|
||||
.setSymbolesPossibles(new ArrayList<>(symboles));
|
||||
|
||||
sudoku.ajouterContrainte(new ContrainteLigne());
|
||||
sudoku.ajouterContrainte(new ContrainteColonne());
|
||||
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("😂"));
|
||||
sudoku.getGrille().setCase(2, 2, Symbole.of("😍"));
|
||||
sudoku.getGrille().setCase(0, 3, Symbole.of("😜"));
|
||||
sudoku.getGrille().setCase(4, 4, Symbole.of("😇"));
|
||||
sudoku.getGrille().setCase(0, 5, Symbole.of("😘"));
|
||||
sudoku.getGrille().setCase(5, 6, Symbole.of("😋"));
|
||||
sudoku.getGrille().setCase(0, 7, Symbole.of("😊"));
|
||||
|
||||
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 SUDOKU EMOJIS");
|
||||
}
|
||||
}
|
||||
61
app/src/test/java/sudoku/TestSudokuLettres.java
Normal file
61
app/src/test/java/sudoku/TestSudokuLettres.java
Normal file
@@ -0,0 +1,61 @@
|
||||
package sudoku;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
public class TestSudokuLettres {
|
||||
@Test
|
||||
public void sudokuLettres() {
|
||||
System.out.println("TEST SUDOKU LETTRES : ");
|
||||
|
||||
// Create a new Sudoku
|
||||
Sudoku sudoku = new Sudoku(9);
|
||||
|
||||
List<Symbole> symboles = new ArrayList<>();
|
||||
symboles.add(Symbole.of("L"));
|
||||
symboles.add(Symbole.of("E"));
|
||||
symboles.add(Symbole.of("T"));
|
||||
symboles.add(Symbole.of("T"));
|
||||
symboles.add(Symbole.of("R"));
|
||||
symboles.add(Symbole.of("E"));
|
||||
symboles.add(Symbole.of("S"));
|
||||
symboles.add(Symbole.of("O"));
|
||||
symboles.add(Symbole.of("H"));
|
||||
sudoku.getGrille()
|
||||
.setSymbolesPossibles(new ArrayList<>(symboles));
|
||||
|
||||
sudoku.ajouterContrainte(new ContrainteLigne());
|
||||
sudoku.ajouterContrainte(new ContrainteColonne());
|
||||
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"));
|
||||
sudoku.getGrille().setCase(2, 2, Symbole.of("T"));
|
||||
sudoku.getGrille().setCase(0, 3, Symbole.of("T"));
|
||||
sudoku.getGrille().setCase(4, 4, Symbole.of("R"));
|
||||
sudoku.getGrille().setCase(0, 5, Symbole.of("E"));
|
||||
sudoku.getGrille().setCase(5, 6, Symbole.of("S"));
|
||||
sudoku.getGrille().setCase(0, 7, Symbole.of("O"));
|
||||
|
||||
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();
|
||||
boolean solved = resolveur.resoudre(sudoku, false);
|
||||
System.out.println("Sudoku " + (solved ? "résolu" : "non résolu") + " :");
|
||||
System.out.println(sudoku.getGrille().toString());
|
||||
|
||||
System.out.println("FIN TEST SUDOKU LETTRES");
|
||||
}
|
||||
}
|
||||
60
app/src/test/java/sudoku/TestSudokusString.java
Normal file
60
app/src/test/java/sudoku/TestSudokusString.java
Normal file
@@ -0,0 +1,60 @@
|
||||
package sudoku;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
public class TestSudokusString {
|
||||
@Test
|
||||
public void sudokuString() {
|
||||
System.out.println("TEST SUDOKU STRING : ");
|
||||
|
||||
// Create a new Sudoku
|
||||
Sudoku sudoku = new Sudoku(9);
|
||||
|
||||
List<Symbole> symboles = new ArrayList<>();
|
||||
symboles.add(Symbole.of("Sudoku"));
|
||||
symboles.add(Symbole.of("🗿"));
|
||||
symboles.add(Symbole.of("Test"));
|
||||
symboles.add(Symbole.of("😂"));
|
||||
symboles.add(Symbole.of("1"));
|
||||
symboles.add(Symbole.of("woW"));
|
||||
symboles.add(Symbole.of("😎"));
|
||||
symboles.add(Symbole.of("42"));
|
||||
symboles.add(Symbole.of("π"));
|
||||
sudoku.getGrille()
|
||||
.setSymbolesPossibles(
|
||||
new ArrayList<>(symboles));
|
||||
|
||||
sudoku.ajouterContrainte(new ContrainteLigne());
|
||||
sudoku.ajouterContrainte(new ContrainteColonne());
|
||||
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"));
|
||||
sudoku.getGrille().setCase(2, 2, Symbole.of("Test"));
|
||||
sudoku.getGrille().setCase(0, 3, Symbole.of("😂"));
|
||||
sudoku.getGrille().setCase(4, 4, Symbole.of("1"));
|
||||
sudoku.getGrille().setCase(0, 5, Symbole.of("woW"));
|
||||
|
||||
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 résolu :");
|
||||
System.out.println(sudoku.getGrille().toString());
|
||||
|
||||
System.out.println("FIN TEST SUDOKU STRING");
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user