Programme Anagramme en Java

Un Anagramme est un mot formé en remaniant ou en réorganisant les lettres d'un mot différent ; le point essentiel d’une anagramme est que les lettres ne peuvent être utilisées qu’une seule fois et ne doivent pas être répétées dans le nouveau mot. Un Anagramme est un mot ayant le même nombre de lettres. Le décompte ici compte beaucoup. Le programme Anagram en Java peut être utilisé des manières ci-dessus en triant et en comparant les deux chaînes. Si cela réussit, cela signifie que la chaîne est une anagramme.

Commencez votre cours de développement de logiciels libres

Développement Web, langages de programmation, tests de logiciels et autres

Algorithme :

Jetons un coup d'œil à l'algorithme permettant d'obtenir une anagramme à partir d'un mot spécifique. Il existe trois manières de découvrir une anagramme. Nous expliquerons les trois manières, une par une. L'algorithme de base consiste à vérifier la longueur des chaînes. Une fois que la longueur est la même, elle peut être triée ou comptée et vérifiée pour une anagramme.

Exemples de programme Anagram en Java

La première chose que nous pouvons faire pour les chaînes données est de trier les deux chaînes données qui doivent être vérifiées si ce sont des anagrammes. Une fois le tri effectué, il peut alors être comparé dans les commandes triées. La complexité temporelle de cette méthode est O (n Logn). Le code Java pour cela peut être écrit comme ci-dessous :

Exemple n°1

Code :

// JAVA program to validate if two strings are anagrams
import java.io.*;
import java.util.Arrays;
import java.util.Collections;
class Main {
/* Below is a function which checks if the strings are anagram */
static boolean checkAnagram(char[] strana1, char[] strana2)
{
// Finding lengths of strings
int len1 = strana1.length;
int len2 = strana2.length;
// If lengths do not match then they cannot be anagrams
if (len1 != len2)
return false;
// Sort both strings
Arrays.sort(strana1);
Arrays.sort(strana2);
// Comparing the strings which are sorted earlier
for (int i = 0; i < len1; i++)
if (strana1[i] != strana2[i])
return false;
return true;
}
/* Main program to test Anagram*/
public static void main (String args[])
{
char strana1[] = { 't', 'e', 's', 't' };
char strana2[] = { 't', 't', 'e', 'w' };
if (checkAnagram(strana1, strana2))
System.out.println("The strings to be checked are" + " anagram of each other");
else
System.out.println("The strings to be checked are not" + " anagram of each other");
}
}

Le programme ci-dessus vérifie d'abord les longueurs des deux chaînes données. Si les chaînes n’ont pas la même longueur, la méthode renvoie false. Ce n'est que si la longueur des deux chaînes est la même que le programme progressera davantage. En utilisant la fonction de tri de tableau, il triera les chaînes dans deux tableaux. Une fois que la fonction de tri de tableau est utilisée sur les deux chaînes, les chaînes sont comparées et chaque lettre est comparée pour former une boucle. Si la boucle for réussit et que toutes les lettres des deux chaînes sont identiques, le résultat sera une anagramme. Même si une lettre ne correspond pas, elle renverra false. Le programme principal vérifie ici les chaînes et affiche si la chaîne est une anagramme ou non en fonction du résultat renvoyé par la fonction checkAnagram.

Sortie :

Si nous changeons l'entrée en « t », « t », « e », « s » au lieu de w, le résultat sera comme ci-dessous.

Sortie :

Exemple n°2

Cette méthode peut être utilisée lorsque les chaînes en cours de validation sont petites. Cette méthode considère que les caractères stockés sont de 8 bits et peuvent stocker éventuellement 256 caractères. Dans cette méthode, vous pouvez d'abord compter les chaînes en utilisant les tableaux de comptage de taille 256 et initialiser toutes les valeurs nécessaires dans le tableau de comptage à 0. Parcourez ce tableau et incrémentez le compte pendant le parcours. Une fois cela fait, vous pouvez comparer les tableaux de comptage. Si le décompte est le même, alors le résultat renvoyé sera vrai.

Code :

import java.io.*;
import java.util.*;
class ANA {
static int NO_CHARS = 256;
/* Below is a function which checks if the strings are anagram */
static boolean isAnagram(char strana1[], char strana2[])
{
// Here we create two arrays and initialize it to 0
int cnt1[] = new int[NO_CHARS];
Arrays.fill(cnt1, 0);
int cnt2[] = new int[NO_CHARS];
Arrays.fill(cnt2, 0);
int i;
// For every character in input strings, increment the count
for (i = 0; i < strana1.length && i < strana2.length;
i++) {
cnt1[strana1[i]]++;
cnt2[strana2[i]]++;
}
// Checking If both strings are of different length
if (strana1.length != strana2.length)
return false;
// Compare count arrays
for (i = 0; i < NO_CHARS; i++)
if (cnt1[i] != cnt2[i])
return false;
return true;
}
/* Main program to test to check if string is Anagram or not*/
public static void main(String args[])
{
char strana1[] = ("silent").toCharArray();
char strana2[] = ("lisent").toCharArray();
if (isAnagram(strana1, strana2))
System.out.println("The strings to be checked are" + " anagram of each other");
else
System.out.println("The strings to be checked are not" + " anagram of each other");
}
}

Sortie :

Exemple #3

Anagram peut être vérifié en utilisant la fonction StringBuilder en Java. Nous pouvons utiliser la méthode deletechartAt() afin de supprimer tous les caractères présents dans la deuxième chaîne.

Code :

public class Main
{
static void findAnagram(String str1, String str2)
{
String copystr1 = str1.replaceAll( " ", "").toLowerCase();
String copystr2 = str2.replaceAll(" ", "").toLowerCase();
//Setting the initial status to true
boolean flag = true;
if(copystr1.length() != copystr2.length())
{
//If copystr1 and copystr2 do not have same length then set the flag to false
flag = false;
}
else
{
//changing copystr1 to char array
char[] str1Array = copystr1.toCharArray();
//Creating StringBuilder from copystr2
StringBuilder sb = new StringBuilder(copystr2);
//Validating if  each character of str1Array is present in string builder
for (char c : str1Array)
{
int index = sb.indexOf(""+c);
if (index != -1)
{
sb = sb.deleteCharAt(index);
}
else
{
//If each character is not present, setting flag to false and breaking the loop
flag = false;
break;
}
}
}
if(flag)
{
System.out.println(str1+" and "+str2+" are anagrams");
}
else
{
System.out.println(str1+" and "+str2+" are not anagrams");
}
}
public static void main(String[] args)
{
findAnagram("Silent", "Listen");
}
}

Le programme ici utilise le drapeau et utilise un module de création de chaînes qui permet de supprimer les caractères supplémentaires.

Sortie :

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!