L'objectif de ce défi est d'évaluer si une main de cinq cartes de poker peut former une suite (quinte). La partiuclarité réside dans l'utilisation de jokers, qui peuvent remplacer n'importe quelle carte pour compléter la séquence. Les règles de valorisation des cartes sont les suivantes : l'As (A) vaut 1, le Valet (J) vaut 11, la Dame (Q) vaut 12 et le Roi (K) vaut 13. Pour simplifier, les jokers sont représentés par la valeur 0.

Une suite est une séquence de cinq cartes consécutives (par exemple, 3, 4, 5, 6, 7). Les jokers agissent comme des "cartes universelles" pour combler les lacunes dans la séquence. Par exemple, une main comprenant "As (1), 3, Joker (0), Roi (13), 5" pourrait potentiellement former une suite si les jokers sont judicieusement utilisés. Une condition essentielle est qu'il ne peut y avoir de doublosn parmi les cartes non-jokers.

Approche Algorithmique

Pour résoudre ce problème, nous allons suivre une méthode basée sur le tri et le décompte des jokers et des écarts :

1. Validation de l'entrée : S'assurer que la main est valide (par exemple, non nulle et contenant le nombre attendu de cartes, ici 5).
2. Tri des cartes : Trier le tableau de cartes en ordre croissant. Cela facilite l'identification des séquences et des écarts.
3. Décompte des jokers : Parcourir le tableau trié pour compter le nombre de jokers (cartes de valeur 0) disponilbes.
4. Identification des écarts et des doublons :
   • Parcourir les cartes non-jokers pour identifier les "trous" qui doivent être comblés pour former une suite.
   • Si deux cartes non-jokers consécutives ont la même valeur après le tri, cela signifie qu'il y a un doublon. Dans ce cas, il est impossible de former une suite, et la fonction doit retourner false.
   • Pour chaque paire de cartes non-jokers adjacentes (c1, c2), le nombre de cartes nécessaires pour combler l'écart est c2 - c1 - 1. On additionne ces valeurs pour obtenir le total des écarts à combler.
5. Comparaison : Si le nombre total de jokers disponibles est supérieur ou égal au nombre total d'écarts à combler, alors une suite peut être formée. Dans le cas contraire, ce n'est pas possible.

Exemples de Code

Implémentation en C++

#include <vector>
#include <algorithm> // Nécessaire pour std::sort

class SolveurQuinte {
public:
    // Vérifie si un ensemble de cinq cartes peut former une quinte avec des jokers.
    bool peutFormerQuinte(std::vector<int>& cartes) {
        // Vérification basique de l'entrée. Une main de poker a typiquement 5 cartes.
        if (cartes.empty() || cartes.size() != 5) {
            return false;
        }

        // Tri des cartes pour faciliter l'analyse des séquences.
        std::sort(cartes.begin(), cartes.end());

        int jokersUtilisables = 0;
        // Compter les jokers (représentés par 0).
        for (int carte : cartes) {
            if (carte == 0) {
                jokersUtilisables++;
            }
        }

        // Trouver l'index de la première carte non-joker.
        // Toutes les cartes avant cet index sont des jokers.
        int indexDepartCartesReelles = jokersUtilisables;

        // Vérifier l'absence de doublons parmi les cartes réelles (non-jokers).
        // Si des doublons existent, une quinte est impossible.
        for (int i = indexDepartCartesReelles; i < cartes.size() - 1; ++i) {
            if (cartes[i] == cartes[i+1]) {
                return false; // Doublon détecté, impossible de former une quinte.
            }
        }

        int ecartsARemplir = 0;
        // Calculer le nombre total d'écarts nécessaires entre les cartes réelles.
        // Exemple: entre 3 et 5, il y a un écart (le 4).
        for (int i = indexDepartCartesReelles; i < cartes.size() - 1; ++i) {
            ecartsARemplir += (cartes[i+1] - cartes[i] - 1);
        }

        // La quinte est possible si le nombre de jokers disponibles
        // est suffisant pour combler tous les écarts.
        return jokersUtilisables >= ecartsARemplir;
    }
};

Implémentation en Java

import java.util.Arrays;

public class GestionnaireDePoker {

    /**
     * Détermine si une main de 5 cartes peut former une quinte,
     * en considérant que les 0 sont des jokers.
     * @param mainDeCartes Un tableau d'entiers représentant les 5 cartes.
     * @return true si une quinte peut être formée, false sinon.
     */
    public boolean verifierQuinteAvecJokers(int[] mainDeCartes) {
        // Validation de l'entrée : la main doit contenir exactement 5 cartes.
        if (mainDeCartes == null || mainDeCartes.length != 5) {
            return false;
        }

        // Trier les cartes pour simplifier la détection des séquences et des écarts.
        Arrays.sort(mainDeCartes);

        int nombreDeJokers = 0;
        int indexPremiereCarteValide = 0;

        // Compter les jokers (0) et trouver l'index de la première carte non-joker.
        for (int i = 0; i < mainDeCartes.length; i++) {
            if (mainDeCartes[i] == 0) {
                nombreDeJokers++;
            } else {
                indexPremiereCarteValide = i;
                break; // La première carte réelle est trouvée
            }
        }

        // Si toutes les cartes sont des jokers (ex: [0,0,0,0,0]), cela forme une quinte.
        if (nombreDeJokers == mainDeCartes.length) {
            return true;
        }

        int cartesManquantesPourSequence = 0;
        // La carte à partir de laquelle nous allons calculer les écarts.
        // C'est la première carte non-joker.
        int carteReference = mainDeCartes[indexPremiereCarteValide];

        // Parcourir les cartes non-jokers pour identifier les écarts et les doublons.
        for (int i = indexPremiereCarteValide + 1; i < mainDeCartes.length; i++) {
            int carteCourante = mainDeCartes[i];

            // Si une carte réelle est identique à la précédente, impossible de former une quinte.
            if (carteCourante == carteReference) {
                return false;
            }

            // Calculer l'écart entre la carte courante et la carte de référence.
            // Ex: si ref=3, curr=5, écart = 5 - 3 - 1 = 1 (il manque le 4).
            cartesManquantesPourSequence += (carteCourante - carteReference - 1);
            carteReference = carteCourante; // Mettre à jour la carte de référence pour la prochaine itération.
        }

        // Vérifier si le nombre de jokers est suffisant pour combler les cartes manquantes.
        return nombreDeJokers >= cartesManquantesPourSequence;
    }
}