first

Main.kt

+package org.example
+fun dutchFlag(flag: Array<Int>): Array<Int> {
+    require(flag.isNotEmpty()) { "Le tableau ne peux être vide" }
+
+    val v: Int = flag[0]
+    var b: Int = 0
+    var r = flag.size - 1
+    var i: Int = 0
+    var ancien_variant = r - i;
+    assert(ancien_variant >= 0)
+    while (i <= r) {
+        //invariant
+
+        assert(
+
+            (flag.slice(0 until b - 1).all { it < v })
+                    &&
+                    (flag.slice(b until i).all { it == v })
+                    &&
+                    (flag.slice(r + 1 until flag.size - 1).all { it > v })
+
+
+        ) { "Invariant non respecté !" }
+
+        if (flag[i] < v) {
+
+            var tmp: Int = flag[i]
+            flag[i] = flag[b]
+            flag[b] = tmp
+            i++
+            b++
+        } else if (flag[i] > v) {
+
+            var tmp: Int = flag[i]
+            flag[i] = flag[r]
+            flag[r] = tmp
+            r--
+        } else {
+            i++
+        }
+        assert(r - i <= ancien_variant) { "Problème sur le variant" }
+        ancien_variant = r - i
+    }
+
+    return flag
+}
+
+
+
+fun main() {
+    println("Ma solution pour le drapeau hollandais avec des entiers")
+    //le tableau en entrée -> les trois partitions seront remplies
+    var flag: Array<Int> = arrayOf(8, 1, 5, 46, 2, 7, 8, 3, 12, 33, 8)
+    //affichage du tableau
+    println("*")
+    println("*")
+
+    println("Tableau en entrée = "+"["+flag.joinToString(",")+"]")
+
+    //tri du tableau
+    flag = dutchFlag(flag)
+
+    println("*")
+    println("*")
+
+    println("Tableau en sortie = "+"["+flag.joinToString(",")+"]")
+}
\ No newline at end of file

README.md

+# Drapeau Hollandais - Solution
+
+**Description**  
+Ce projet implémente l'algorithme du drapeau hollandais pour trier un tableau d'entiers, avec des variantes utilisant différents types de validation. Le projet comprend deux versions de l'algorithme :  
+- `Drapeau_Stierer.jar` : Implémentation de l'algorithme du drapeau hollandais.
+- `Drapeau_invariant_violated.jar` : Version de l'algorithme où l'invariant peut être violé.
+
+## Table des matières
+
+1. [Description](#description)
+2. [Prérequis](#prérequis)
+3. [Utilisation](#utilisation)
+
+## Description
+
+Ce projet présente deux implémentations de l'algorithme du drapeau hollandais pour trier un tableau d'entiers :
+
+1. **Drapeau_Stierer.jar** : Implémentation classique de l'algorithme, garantissant la conservation des invariants pendant l'exécution.
+2. **Drapeau_invariant_violated.jar** : Variante de l'algorithme où certains invariants peuvent être violés pour tester la robustesse de l'algorithme.
+
+## Prérequis
+
+Avant de lancer le projet, vous devez vous assurer que les éléments suivants sont installés :
+
+- **Java** : Ce projet a été testé avec Java 8 ou une version plus récente.
+- **Kotlin** : Les fichiers `.jar` sont générés à partir de fichiers Kotlin.
+
+## Utilisation
+
+### Lancer les JARs
+
+Une fois le projet compilé, vous pouvez exécuter les deux versions de l'algorithme en utilisant les commandes suivantes :
+
+1. **Lancer l'algorithme du drapeau hollandais (Stierer) :**
+    ```bash
+    java -ea -jar Drapeau_Stierer.jar
+    ```
+
+2. **Lancer l'algorithme avec invariant violé :**
+    ```bash
+    java -ea -jar Drapeau_invariant_violated.jar
+    ```
+
+Les options `-ea` (enable assertions) sont utilisées pour activer les assertions Java, afin de valider certains invariants pendant l'exécution.
+