- Inversion d'une chaîne de caractères
Description : Implémenter une fonction pour inverser un tableau de caractères en place, sans utiliser d'espace supplémentaire autre que O(1).
Exemple : Entrée : ["h","e","l","l","o"] → Sortie : ["o","l","l","e","h"]
Approche : Utilsier deux indices, l'un au début et l'autre à la fin du tableau, pour échanger les éléments progressivement jusqu'à ce qu'ils se rencontrent au milieu.
Implémentation en Java :
public class InversionChaine {
public void inverserTableau(char[] tableau) {
int debut = 0;
int fin = tableau.length - 1;
while (debut < fin) {
char temp = tableau[debut];
tableau[debut] = tableau[fin];
tableau[fin] = temp;
debut++;
fin--;
}
}
}
Méthode alternative avec opération bit à bit : L'opérateur XOR peut échanger deux valeurs sans variable temporaire, en exploitant les propriétés de l'algèbre booléenne : a = a ^ b, b = a ^ b, a = a ^ b.
public class InversionChaineBit {
public void inverserTableau(char[] tableau) {
int i = 0;
int j = tableau.length - 1;
while (i < j) {
tableau[i] ^= tableau[j];
tableau[j] ^= tableau[i];
tableau[i] ^= tableau[j];
i++;
j--;
}
}
}
- Inversion conditionnelle de sous-chaînes
Description : Étant donné une chaîne s et un entier k, inverser les premiers k caractères pour chaque bloc de 2k caractères, en gérant les cas où les caractères restants sont inférieurs à k.
Exemple : Entrée : s = "abcdefg", k = 2 → Sortie : "bacdfeg"
Approche : Parcourir la chaîne par pas de 2k, et pour chaque segment, déterminer la plage à inverser en limitant l'indice de fin à la longueur totale moins un.
Implémentation en Java :
public class InversionConditionnelle {
public String inverserSousChaines(String s, int k) {
char[] caracteres = s.toCharArray();
int n = caracteres.length;
for (int index = 0; index < n; index += 2 * k) {
int debutSegment = index;
int finSegment = Math.min(debutSegment + k - 1, n - 1);
int gauche = debutSegment;
int droite = finSegment;
while (gauche < droite) {
char temp = caracteres[gauche];
caracteres[gauche] = caracteres[droite];
caracteres[droite] = temp;
gauche++;
droite--;
}
}
return new String(caracteres);
}
}
- Transformation de chaîne avec inverison de mots et casse
Description : Pour une chaîne contenant des espaces, inverser l'ordre des mots et inverser la casse de chaque caractère (majuscule en minuscule et vice versa).
Exemple : Entrée : "This is a sample" → Sortie : "SAMPLE A IS tHIS"
Approche : Premièrement, inverser la casse de tous les caractères. Ensuite, inverser entièrement la chaîne. Enfin, inverser chaque mot individuellement en utilisant les espaces comme délimiteurs.
Implémentation en Java :
public class TransformationChaine {
public String transformerChaine(String s, int n) {
char[] tableau = s.toCharArray();
// Inversion de la casse
for (int i = 0; i < n; i++) {
if (Character.isUpperCase(tableau[i])) {
tableau[i] = Character.toLowerCase(tableau[i]);
} else if (Character.isLowerCase(tableau[i])) {
tableau[i] = Character.toUpperCase(tableau[i]);
}
}
// Inversion globale
inverserPlage(tableau, 0, n - 1);
// Inversion des mots individuels
int position = 0;
while (position < n) {
if (tableau[position] == ' ') {
position++;
continue;
}
int debutMot = position;
while (position < n && tableau[position] != ' ') {
position++;
}
inverserPlage(tableau, debutMot, position - 1);
}
return new String(tableau);
}
private void inverserPlage(char[] tableau, int debut, int fin) {
int gauche = debut;
int droite = fin;
while (gauche < droite) {
char temp = tableau[gauche];
tableau[gauche] = tableau[droite];
tableau[droite] = temp;
gauche++;
droite--;
}
}
}
- Validation d'adresses IP (IPv4 et IPv6)
Description : Écrire une fonction pour vérifier si une chaîne donnée est une adresse IPv4 ou IPv6 valide. Les adresses IPv4 sont composées de quatre nombres décimaux séparés par des points (0-255, sans zéros non significatifs), et les adresses IPv6 comprennent huit groupes hexadécimaux séparés par des deux-points (chaque groupe de 1 à 4 caractères).
Exemples : Entrée : "172.16.254.1" → Sortie : "IPv4" ; Entrée : "2001:0db8:85a3:0:0:8A2E:0370:7334" → Sortie : "IPv6"
Approche : Valider séparément les formats IPv4 et IPv6 en divisant la chaîne selon les séparateurs appropriés et en vérifiant les contraintes pour chaque segment.
Implémentation en Java :
public class ValidationIP {
public static String verifierIP(String adresseIP) {
if (estIPv4Valide(adresseIP)) {
return "IPv4";
} else if (estIPv6Valide(adresseIP)) {
return "IPv6";
} else {
return "Neither";
}
}
private static boolean estIPv4Valide(String ip) {
String[] segments = ip.split("\\.", -1);
if (segments.length != 4) {
return false;
}
for (String segment : segments) {
if (segment.isEmpty() || (segment.length() > 1 && segment.startsWith("0"))) {
return false;
}
try {
int valeur = Integer.parseInt(segment);
if (valeur < 0 || valeur > 255) {
return false;
}
} catch (NumberFormatException e) {
return false;
}
}
return true;
}
private static boolean estIPv6Valide(String ip) {
String[] groupes = ip.split(":", -1);
if (groupes.length != 8) {
return false;
}
for (String groupe : groupes) {
if (groupe.isEmpty() || groupe.length() > 4) {
return false;
}
try {
Integer.parseInt(groupe, 16);
} catch (NumberFormatException e) {
return false;
}
}
return true;
}
}