Алгоритм анаграммы в Java
Я хотел бы сделать алгоритм анаграммы, но этот код не работает. Где моя вина? Например, des и sed - это анаграмма, но вывод не является анаграммой. Тем временем я должен использовать строковый метод. не массив.:)
public static boolean isAnagram(String s1 , String s2)
{
String delStr="";
String newStr="";
for(int i=0;i<s1.length();i++)
{
for(int j=0 ; j < s2.length() ; j++)
{
if(s1.charAt(i)==s2.charAt(j))
{
delStr=s1.substring(i,i+1);
newStr=s2.replace(delStr,"");
}
}
}
if(newStr.equals(""))
return true;
else
return false;
}
40 ответов
Более простой способ - просто отсортировать символы в обеих строках и сравнить, равны ли они:
public static boolean isAnagram(String s1, String s2){
// Early termination check, if strings are of unequal lengths,
// then they cannot be anagrams
if ( s1.length() != s2.length() ) {
return false;
}
s1=s1.toLowerCase();
s2=s2.toLowerCase();
char[] c1 = s1.toCharArray();
char[] c2 = s2.toCharArray();
Arrays.sort(c1);
Arrays.sort(c2);
String sc1 = new String(c1);
String sc2 = new String(c2);
return sc1.equals(sc2);
}
Лично я думаю, что это более читабельно, чем вложенные for-loop =p
Это имеет O(n log n) сложность во время выполнения, где n длина более длинной строки
Изменить: это не оптимальное решение. Смотрите ответ @aam1r для наиболее эффективного подхода (то есть, что вы должны сказать в интервью)
Это можно сделать за линейное время с использованием постоянного пространства. Вот псевдокод, который поможет вам начать:
// Create new hashtable/hashmap to keep track of how many times each character
// is being used
character_map -> new hash map
// Initial check. If lengths are not the same, they can't be anagrams.
if s1.length != s2.length:
throw exception "Not anagrams"
// Add all characters from s1 to hashmap. Increment the value to keep track of
// number of occurences
foreach character c1 in s1:
character_map[c1]++
// Iterate through all character in s2 and decrement count of each character.
foreach character c2 in s2:
character_map[c2]--
// If they are anagrams, each character should be at "0" count at the point.
// If we come across a character that is not, it means that they are not anagrams
foreach key k, value v in character_map:
if v != 0:
throw exception "Not anagrams"
Этот код не сортируется и, следовательно, может быть выполнен с использованием простых циклов. Общее время выполнения равно O(n), а общее пространство равно O(1), что является самым быстрым решением. Количество элементов, которые вы можете иметь в хэш-карте, является постоянным (т.е. вы знаете, сколько элементов содержится в вашем наборе алфавита).
if(s1.charAt(i)==s2.charAt(j))
delStr=s1.substring(i,i+1);
newStr=s2.replace(delStr,"");
Этот код является хорошей демонстрацией того, почему вы должны всегда иметь curly braces вокруг вашего if, даже если есть только одно утверждение. Ваше второе задание на самом деле находится за пределами if-conditionи всегда будет происходить.
Лучший способ проверить наличие двух строк Anagram чтобы преобразовать их в массив символов (String#toCharArray), Затем сортируйте их, используя Arrays.sort метод. И сделайте сравнение по ним.
Обновлено: -
Если вы просто хотите использовать String методы, тогда вам на самом деле не нужен вложенный цикл. Вы можете сделать это только с одним.
Вот ваш модифицированный код: -
public static boolean isAnagram(String s1 , String s2){
if (s1.length() != s2.length()) {
return false;
}
for(int i = 0; i < s2.length(); i++) {
if( !s1.contains("" + s2.charAt(i))) {
return false;
}
s1 = s1.replaceFirst("" + s2.charAt(i), "");
s2 = s2.replaceFirst("" + s2.charAt(i), "");
}
return true;
}
Что было бы более эффективно, так это сравнить строки в отсортированном порядке.
public static boolean isAnagram(String s1 , String s2) {
return s1.length() == s2.length()
&& checkSum(s1) == checkSum(s2)
&& Arrays.equals(lettersSorted(s1), lettersSorted(s2));
}
static long checkSum(String s) {
long sqrSum = 0;
for(int i = 0; i < s.length(); s++) {
char ch = s.charAt(i);
sqrSum += ch + (1L << ch);
}
}
static char[] lettersSorted(String s) {
char[] chars = s.toCharArray();
Arrays.sort(chars);
return chars;
}
Это алгоритм O(N ln N), но в среднем он будет равен O(N), если строки обычно не являются анаграммами.
Я не уверен, что вы пытаетесь сделать, но я уверен, что это не сработает (и это работает в O(n^2), Попробуйте это (который работает в O(n log n)) вместо:
public static boolean isAnagram(String s1, String s2){
if (s1.length() != s2.length()) return false;
char[] c1 = s1.toCharArray();
char[] c2 = s2.toCharArray();
Arrays.sort(c1);
Arrays.sort(c2);
for(int i = 0; i < c1.length; i++) {
if(c1[i] != c2[i]) return false;
}
return true;
}
Существует множество возможных решений для определения, является ли строка анаграммой или нет.
1. используя Array.sort() предопределенный метод
String string1 = "abc";
String string2 = "bca";
char[] chars = string1.toCharArray();
char[] chars2 = string2.toCharArray();
Arrays.sort(chars);
Arrays.sort(chars2);
string1 = new String(chars);
string2 = new String(chars2);
if (string1.equalsIgnoreCase(string2)) {
System.out.println("Anagram");
} else {
System.out.println("Not Anagram");
}
Сложность времени: Ω(n log n)2. Итерационным методом
char [] charArray = str.toCharArray();
if(str.length() == str1.length()){
for(char ch : charArray){
if(str1.indexOf(ch) == -1){
System.out.println("Not Anagram");
}
}
System.out.println("Anagram");
} else {
System.out.println("Not Anagram");
}
Сложность времени: Ω(n)
Хотя первый алгоритм более читабелен, второй алгоритм действительно выполняется быстрее.
Причина, по которой это не работает:
Используя "des" и "sed" в качестве примера.
На последней итерации, для которой он соответствует, он оценит:
if(s1.charAt(i)==s2.charAt(j))
{
delStr=s1.substring(i,i+1);
newStr=s2.replace(delStr,"");
}
Который будет: if( "s" == "s")
Затем он войдет в блок if и оценит
newStr = "sed".replace("s","");
который даст вам "ed" вместо пустой строки.
Мораль этой истории заключается в том, что вы всегда заменяете персонажей из s2 менее одним персонажем, который никогда не будет пустым.
Использование String.replace() в любом случае плохо, потому что по умолчанию оно заменит все экземпляры персонажа. С String.replace() он будет считать "sed" анаграммой "seeeeeeed". Вы бы лучше использовать String.replaceFirst().
В любом случае, отправной точкой является внесение следующих изменений:
String newStr = s2;
...
// inside if block
newStr = newStr.replaceFirst( delStr, "" );
import java.util.Scanner;
public class Anagrams {
static boolean isAnagram(String a, String b) {
a = a.toLowerCase();
b = b.toLowerCase();
if (a.length() != b.length()) {
return false;
}
char[] chars = a.toCharArray();
for (char c : chars) {
int index = b.indexOf(c);
if (index != -1) {
b = b.substring(0, index) + b.substring(index + 1, b.length());
} else {
return false;
}
}
return b.isEmpty();
}
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
String a = scan.next();
String b = scan.next();
scan.close();
boolean ret = isAnagram(a, b);
System.out.println((ret) ? "Anagrams" : "Not Anagrams");
}
}
Ниже приведен краткий фрагмент кода, который определяет, являются ли две строки анаграммами в одной итерации обеих строк, плюс заключительная итерация массива из 256 элементов. Этот подход позволяет избежать сортировки символов в строках и преобразования в / из массивов Strings/char путем записи количества символов в массиве отображения.
static boolean isAnagram(String s1, String s2) {
if (s1.length() != s2.length()) return false;
int n = s1.length();
int[] charMap = new int[256];
for (int i = 0; i < n; i++) {
char c1 = s1.charAt(i);
charMap[c1]++;
char c2 = s2.charAt(i);
charMap[c2]--;
}
for (int i = 0; i < charMap.length; i++) {
if (charMap[i] != 0) return false;
}
return true;
}
Этот код в основном увеличивает и уменьшает положение индекса в массиве, соответствующем символу. Если какой-либо из элементов массива отличен от нуля в конце итерации, количество приращений и уменьшений было неодинаковым, и поэтому строки содержат разные символы и не могут быть анаграммами друг друга.
Учитывая, что этот алгоритм повторяет две строки одинакового размера, время выполнения равно O(n). Сложность пространства равна O(1), поскольку charMap всегда постоянен в зависимости от требований кодировки.
public boolean checkAnagram(String s, String t) {
s = s.toLowerCase();
t = t.toLowerCase();
// We can ignore blanks
char[] word1 = s.replaceAll("\\s","").toCharArray();
char[] word2 = t.replaceAll("\\s","").toCharArray();
// Anagrams length should be the same
if (word1.length != word2.length) {
return false;
}
// Sorting arrays is pretty fast, it can be O(logn)
Arrays.sort(word1);
Arrays.sort(word2);
if (Arrays.equals(word1, word2)) {
return true;
}
return false;
}
Using HashMap
public boolean isAnagram(String word, String anagram) {
if (word.length() != anagram.length())
return false;
int count = 0;
Map<Character, Integer> map = new HashMap<>();
for (int i = 0; i < word.length(); i++) {
if (!map.containsKey(word.charAt(i)))
map.put(word.charAt(i), 1);
else
map.put(word.charAt(i), map.get(word.charAt(i)) + 1);
}
for (int i = 0; i < anagram.length(); i++) {
if (!map.containsKey(anagram.charAt(i)))
return false;
else if (map.get(anagram.charAt(i)) >= 1)
map.put(anagram.charAt(i), map.get(anagram.charAt(i)) - 1);
else
return false;
}
return true;
}
Это реализация Java, которую я написал для использования массива вместо HashMap. Это экономит место, плюс массивы действительно быстрые.
public static boolean anagram(String s, String t) {
if (s.length() != t.length()) return false;
int[] arr = new int[123];
for (char c : s.toCharArray())
arr[c]++;
for (char c : t.toCharArray())
arr[c]--;
for (int i : arr)
if (i != 0)
return false;
return true;
}
O(n) решение без какой-либо сортировки и использования только одной карты. Также добавлена правильная нулевая проверка, отсутствующая в других решениях.
public boolean isAnagram(String leftString, String rightString) {
if (leftString == null || rightString == null) {
return false;
} else if (leftString.length() != rightString.length()) {
return false;
}
Map<Character, Integer> occurrencesMap = new HashMap<>();
for(int i = 0; i < leftString.length(); i++){
char charFromLeft = leftString.charAt(i);
int nrOfCharsInLeft = occurrencesMap.containsKey(charFromLeft) ? occurrencesMap.get(charFromLeft) : 0;
occurrencesMap.put(charFromLeft, ++nrOfCharsInLeft);
char charFromRight = rightString.charAt(i);
int nrOfCharsInRight = occurrencesMap.containsKey(charFromRight) ? occurrencesMap.get(charFromRight) : 0;
occurrencesMap.put(charFromRight, --nrOfCharsInRight);
}
for(int occurrencesNr : occurrencesMap.values()){
if(occurrencesNr != 0){
return false;
}
}
return true;
}
и менее универсальное решение, но чуть более быстрое:
public boolean isAnagram(String leftString, String rightString) {
if (leftString == null || rightString == null) {
return false;
} else if (leftString.length() != rightString.length()) {
return false;
}
char letters[] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
Map<Character, Integer> occurrencesMap = new HashMap<>();
for (char l : letters) {
occurrencesMap.put(l, 0);
}
for(int i = 0; i < leftString.length(); i++){
char charFromLeft = leftString.charAt(i);
Integer nrOfCharsInLeft = occurrencesMap.get(charFromLeft);
occurrencesMap.put(charFromLeft, ++nrOfCharsInLeft);
char charFromRight = rightString.charAt(i);
Integer nrOfCharsInRight = occurrencesMap.get(charFromRight);
occurrencesMap.put(charFromRight, --nrOfCharsInRight);
}
for(Integer occurrencesNr : occurrencesMap.values()){
if(occurrencesNr != 0){
return false;
}
}
return true;
}
Вот еще одно предложение без инициализации int[256], но int[26] для английского алфавита.
public static void main(String[] args) {
System.out.println(isAnagram("restful", "fluster"));
}
static boolean isAnagram(String s1, String s2) {
if (s1.length() != s2.length()) {
return false;
}
int[] countArray = new int[26];
for (int i = 0; i < s1.length(); i++) {
countArray[getIndex(i, s1)]++;
countArray[getIndex(i, s2)]--;
}
for (int i = 0; i < countArray.length; i++) {
if (countArray[i] != 0) {
return false;
}
}
return true;
}
public static int getIndex(int position, String value) {
return value.charAt(position) - 'a';
}
Лучший Георгий Цопуридис
Я думаю, что это работает со сложностью O(2n)
public static boolean isAnagram(String str1, String str2){
if(str1.length() != str2.length()){ return false;}
int[] buffer = new int[256];
for(char ch : str1.toCharArray()){
buffer[ch]++;
}
for(char ch : str2.toCharArray()){
if(buffer[ch]==0) return false;
buffer[ch] = (buffer[ch] > 0)?(buffer[ch] - 1 ): -1 ;
}
return true;
}
Вы можете использовать комбинацию потоков и математических вычислений, как в:
public static boolean isAnagram(String s1, String s2){
if ( s1.length() != s2.length() ) {
return false;
}
int s1Sum = s1.chars().sum();
int s2Sum = s2.chars().sum();
return s1Sum == s2Sum;
}
Более быстрая версия с использованием подхода битового вектора для подстрок анаграммы
public boolean isAnagram(String _source1, String _source2)
{
int flag = 0, char_index = 0, counter = 0;
if(_source2.length() < _source1.length()){
return false;
}
char[] _stringchar = _source1.toCharArray();
char[] _tocheck = _source2.toCharArray();
for(char character : _stringchar)
{
char_index = character - 'a';
if((flag & (1 << char_index)) == 0)
flag |= (1 << char_index);
}
for(char toCheckcChar : _tocheck)
{
char_index = toCheckcChar - 'a';
if((flag & (1 << char_index)) > 0)
counter++;
else
counter = 0;
if(counter == _source1.length())
return true;
}
return false;
}
Используя потоки Java, это можно упростить всего за 5 строк кода ( https://github.com/vspiliop/java-puzzles/blob/master/src/gy/etiolo/puzzles/streams/Anagrams.java):
/**
* Are two strings anagrams.
*/
public class Anagrams {
public static void main(String ... args) {
String word1 = "abcdefg";
String word2 = "gfedabc";
System.out.println("Are they anagrams: " + isAnagram(word1, word2));
}
private static boolean isAnagram(String word1, String word2) {
int [] mask = new int[26];
Arrays.fill(mask, 0);
word1.toLowerCase().chars().forEach(c -> mask['z' - c]++);
word2.toLowerCase().chars().forEach(c -> mask['z' - c]--);
return Arrays.stream(mask).sum() == 0;
}
}
Проверьте таблицу ascii здесь: http://www.asciitable.com/
public static void arrang(String s, String str){
char a[] = new char[s.length()];
char b[] = new char[str.length()];
int arr1[] = new int[s.length()];
int arr2[] = new int[str.length()];
if( a.length == b.length ) {
System.out.println("two numbers can't be anagrams");
return;
}
for( int i = 0 ; i < str.length() ; i++ ) {
a[i] = s.toLowerCase().charAt(i);
b[i] = str.toLowerCase().charAt(i);
}
// casting
for( int i = 0 ; i < s.length() ; i++ ) {
arr1[i]=(int)a[i];
arr2[i]=(int)b[i];
}
for( int i = 0 ; i < s.length() ; i++ ) {
for( int j = 1 ; j < s.length() ; j++ ) {
if( arr1[j-1] > arr1[j] ) {
int temp = arr1[j];
arr1[j] = arr1[j-1];
arr1[j-1] = temp;
}
}
}
for( int i = 0 ; i < s.length() ; i++ ) {
for( int j = 1 ; j < s.length() ; j++ ) {
if( arr2[j-1] > arr2[j] ) {
int temp = arr2[j];
arr2[j] = arr2[j-1];
arr2[j-1] = temp;
}
}
}
for( int i = 0 ; i < s.length() ; i++ ) {
a[i] = (char)arr1[i];
b[i] = (char)arr2[i];
}
int count = 0;
for( int i = 0 ; i < s.length() ; i++ ) {
if( a[i] == b[i] ) {
count++;
}
}
if( count == s.length() ) {
System.out.println("two strings are anagrams");
}
else{
System.out.println("not anagrams");
}
}
Я потратил некоторое время на то, чтобы на самом деле описать логику и написать код для проверки двух строк, являются ли они анаграммами или нет. Конечно, с помощью приведенных выше ответов! XD
public static void main(String[] args) {
Map<Character, Integer> char_map = new HashMap<Character, Integer>();
Map<Character, Integer> empty_map = new HashMap<Character, Integer>();
String a = "HelloP";
String b = "HePlol";
if (a.length() != b.length()) {
System.out.println("false");
System.exit(0);
}
for (char c : a.toLowerCase().toCharArray()) {
empty_map.put(c, 0);
if (char_map.containsKey(c))
char_map.put(c, 1 + char_map.get(c));
else
char_map.put(c, 1);
}
for (char c : b.toLowerCase().toCharArray())
if (char_map.containsKey(c))
char_map.put(c, char_map.get(c) - 1);
System.out.println(char_map.equals(empty_map));
}
public static boolean isAnagram(String s1, String s2) {
if (s1.length() != s2.length()) {
return false;
}
Map<Character, Integer> frequencies = new HashMap<>();
for (int i = 0; i < s1.length(); i++) {
if (frequencies.containsKey(s1.charAt(i))) {
frequencies.put(s1.charAt(i), frequencies.get(s1.charAt(i)) + 1);
} else {
frequencies.put(s1.charAt(i), 1);
}
}
for (int i = 0; i < s2.length(); i++) {
if (frequencies.containsKey(s2.charAt(i))) {
int frequency = frequencies.get(s2.charAt(i));
if (--frequency == 0) {
frequencies.remove(s2.charAt(i));
} else {
frequencies.put(s2.charAt(i), frequencies.get(s2.charAt(i)) - 1);
}
}
}
return frequencies.isEmpty();
}
- Сравните длины обеих строк, если они равны
- Преобразуйте обе строки в нижний регистр, чтобы вы могли эффективно сравнивать
- Цикл, чтобы проверить, содержит ли String1 символ в String2.
Установите счетчик на длину одной из строк и уменьшите -1 при совпадении
public boolean isAnagram(String s1, String s2) { if(s1.length() != s2.length()) { return false; } int counter= s1.length(); s1 = s1.toLowerCase(); s2= s2.toLowerCase(); for (int i=0; i<s1.length();i++ ) { if (s2.contains(s1.charAt(i)+"")) { counter--; } } if (counter<=0) { return true; } return false; }
Решение, оптимизированное для повышения производительности.
Чем отличается от других решений:
- Только в самом худшем случае он повторяется один раз через text1 и один раз через text2.
- Сбой быстро : возвращает false, как только встречает символ в text1, который не является частью text2
- Сохраняет гистограмму как
int[], что намного быстрее, чем HashMaps или аналогичный - Может обрабатывать строки с любым символом (даже смайликами 😉)
Пример кода:
public static boolean check(String text1, String text2) {
requireNonNull(text1, "text1 must not be null");
requireNonNull(text2, "text2 must not be null");
if (text1 == text2) return true;
var text1Chars = text1.toCharArray();
var text2Chars = text2.toCharArray();
if (text1Chars.length != text2Chars.length) return false;
var text2Counts = new int[Character.MAX_CODE_POINT];
var text2Index = 0;
loopThroughText1:
for (char charOfText1 : text1Chars) {
if (text2Counts[charOfText1] > 0) {
text2Counts[charOfText1]--;
} else {
while (text2Index < text2Chars.length) {
var charOfText2 = text2Chars[text2Index++];
if (charOfText1 == charOfText2) {
continue loopThroughText1;
}
text2Counts[charOfText2]++;
}
return false;
}
}
return text2Index >= text2Chars.length;
}
Соответствующий метод испытаний:
@ParameterizedTest
@CsvSource({
"a,a,true",
"a,b,false",
"aa,a,false",
"a,aa,false",
"aa,aa,true",
"vhjsd682ahjsvdi7861rUZVFD/Ias6srf871r23,vhjsd682ahjsvdi7861rUZVFD/Ias6srf871r23,true",
"A,a,false",
"🎈,🎈,true",
"🎈,💣,false",
})
public void check(String text1, String text2, boolean expected) {
assertEquals(AnagramChecker.check(text1, text2), expected);
}
Я думаю, что здесь более читаемый и простой способ решить эту проблему. Сложность O(n) и только две карты
public static boolean isAnagram(String word, String word2) {
if (word.equals(word2)) return true;
if (word == null || word2 == null) return false;
if (word.length() != word2.length()) return false;
Map<Character, Integer> map = new HashMap<>();
Map<Character, Integer> map2 = new HashMap<>();
for (int i = 0; i < word.length(); i++) {
map.merge(word.charAt(i), 1, (oldVal, value) -> oldVal++);
}
for (int i = 0; i < word2.length(); i++) {
map2.merge(word2.charAt(i), 1, (oldVal, value) -> oldVal++);
}
return map.equals(map2);
}
Я добавляю это как уникальный подход O(n), хотя, как и сравнение хэшей, он на самом деле только определяет, является ли высокая вероятность того, что две строки являются анаграммами друг друга, а не обеспечивает полную уверенность.
public static boolean isAnagram(String s1, String s2) {
if (s1.length()!=s2.length()) return false;
int sum1=0, sum2=0;
int xor1=0, xor2=0;
int prod1=1, prod2=1;
for (int i=0; i<s1.length(); i++) {
char c1=s1.charAt(i);
char c2=s2.charAt(i);
sum1 += c1;
sum2 += c2;
xor1 ^= c1;
xor2 ^= c2;
prod1 *= c1;
prod2 *= c2;
}
return sum1==sum2 && xor1==xor2 && prod1==prod2;
}
Однажды я сделал тест на собеседование по поводу анаграмм. Я загрузил его в свой аккаунт на github. Код Java проверяет, является ли текстовый файл (с несколькими строками) стихотворением анаграммы или текстом анаграммы.
https://github.com/javocsoft/anagram_poem_checker
Надеюсь, поможет!
До свидания.
String str1="Mother In Law";
String str2="Hitler Woman";
char[] anag1=str1.replaceAll("\\s", "").toLowerCase().toCharArray();
char[] anag2=str2.replaceAll("\\s", "").toLowerCase().toCharArray();
Arrays.sort(anag1);
Arrays.sort(anag2);
System.out.println(Arrays.equals(anag1, anag2)? "words are anagrams":"words are not anagrams");
Вот мое решение с вашей стороны
private static boolean isAnagram(String s1, String s2){
int count = 0;
boolean flag = false;
if(s1.length() != s2.length()){
return false;
}
//checks whether both word's letters are the same
for (int i = 0; i < s1.length(); i++){
for (int j = 0; j < s2.length(); j++){
if(s1.charAt(i) == s2.charAt(j)){
count++;
break;
}
}
}
//if count equals to one of the Strings length then it is an anagram
if(count == s2.length() ){
flag = true;
}
return flag;
}
public static boolean isAnagram(String str1, String str2){
if(str1.length() != str2.length())
return false;
int lengthStr1 = str1.length();
for(char c : str2.toCharArray()) {
str1 = str1.replaceFirst(c+"", "");
if(str1.length() == lengthStr1--)
return false;
}
return true;
}
import java.util.Scanner;
public class JavaProgram
{
public static void main(String[] input)
{
String str1, str2;
int len, len1, len2, i, j, found=0, not_found=0;
Scanner scan = new Scanner(System.in);
System.out.print("Enter First String : ");
str1 = scan.nextLine();
System.out.print("Enter Second String : ");
str2 = scan.nextLine();
len1 = str1.length();
len2 = str2.length();
if(len1 == len2)
{
len = len1;
for(i=0; i<len; i++)
{
found = 0;
for(j=0; j<len; j++)
{
if(str1.charAt(i) == str2.charAt(j))
{
found = 1;
break;
}
}
if(found == 0)
{
not_found = 1;
break;
}
}
if(not_found == 1)
{
System.out.print("Strings are not Anagram to Each Other..!!");
}
else
{
System.out.print("Strings are Anagram");
}
}
else
{
System.out.print("Both Strings Must have the same number of Character to be an Anagram");
}
}
}