So prüfen Sie, ob zwei Strings in Java Anagramme sind

Das Wort Anagramme bezieht sich auf zwei Zeichenfolgen, sodass durch Anordnen der Buchstaben einer Zeichenfolge eine andere Zeichenfolge entsteht. Normalerweise werden alle Buchstaben der Zeichenfolge nur einmal verwendet. Um zu verstehen, was Anagramme eigentlich sind, müssen wir uns ein Beispiel ansehen. Die Buchstaben des Wortes Netz kann geschrieben werden als zehn. Die beiden Wörter sind Anagramme.

Die detaillierte Implementierung wird in diesem Artikel dargestellt, ob es sich bei den eingegebenen Zeichenfolgen um Anagramme handelt.

Wie kann man in Java nach Anagrammen suchen/überprüfen?

In Java das Anagramm for strings wird so implementiert, dass zwei Strings als Eingabe deklariert werden und der Code wird so gestaltet, dass zwei Strings getestet werden, ob die eingegebenen Strings vorhanden sind Anagramme oder nicht. Da Java als Programmiersprache gilt, bei der die Groß-/Kleinschreibung beachtet wird, ist die Konvertierung sehr wichtig, um korrekte Ergebnisse zu erhalten.

Der Code zur Suche nach Anagrammen in Java enthält die folgenden drei wichtigen Techniken:

  • Zeichenfolge zu einem Zeichen
  • arrays.sort
  • arrays.equals

Beispiel 1: Zwei Strings auf Anagramme prüfen

Unter Verwendung der oben genannten Parameter wird unten der Code dargestellt, um zu überprüfen, ob zwei Zeichenfolgen Anagramme sind oder nicht.

import java.util.*;
class Anagram {
  public static void main(String[] args) {
    String stri1 = "Lamb";
    String stri2 = "Balm";
    stri1 = stri1.toLowerCase();
    stri2 = stri2.toLowerCase();
    if(stri1.length() == stri2.length()) {
      char[] ca1 = stri1.toCharArray();
      char[] ca2 = stri2.toCharArray();
      Arrays.sort(ca1);
      Arrays.sort(ca2);
      boolean output = Arrays.equals(ca1, ca2);
      if(output) {
        System.out.println(stri1 + " and " + stri2 + " are strings that are anagrams.");
      }
      else {
        System.out.println(stri1 + " and " + stri2 + " are strings that are  not anagrams.");
      }
    }
    else {
      System.out.println(stri1 + " and " + stri2 + " are the strings that are not anagrams.");
    }
  }
}

Im obigen Code:

  • Wir haben zwei Strings deklariert.
  • Die Zeichenfolgen werden in Kleinbuchstaben umgewandelt, da in Java die Groß-/Kleinschreibung beachtet wird.
  • Die Länge der Zeichenfolge wurde verglichen. Wenn sich herausstellt, dass die Länge dieselbe ist, wird die Schleife weiter ausgeführt, oder die Zeichenfolgen werden als Nicht-Anagramme voneinander deklariert.
  • Bei gleicher Länge muss die eingegebene Zeichenfolge in das Zeichenarray umgewandelt werden.
  • Das char-Array wird mit sortiert Sortieren Befehl.
  • Wenn die sortiert Arrays sind die gleichen wie die deklarierten Strings Anagramme.

Ausgabe

In der obigen Ausgabe sind die beiden Zeichenfolgen Anagramme. Da in Java die Groß- und Kleinschreibung beachtet wird, wurden zwei Zeichenfolgen aus Kleinbuchstaben erstellt und dann verglichen.

Beispiel 2: Überprüfen von zwei Zeichenfolgen auf Anagramme mithilfe von Benutzereingaben

In diesem Code besteht der einzige Unterschied darin, dass die Eingabe für die beiden Zeichenfolgen vom Benutzer übernommen wird, um zu überprüfen, ob es sich bei den Zeichenfolgen um Anagramme handelt.

import java.util.Arrays;
import java.util.Scanner;

class Main {
  public static void main(String[] args) {
    Scanner i = new Scanner(System.in);
    System.out.print("Enter first String: ");
    String stri1 = i.nextLine();
    System.out.print("Enter second String: ");
    String stri2 = i.nextLine();    stri1 = stri1.toLowerCase();
    stri2 = stri2.toLowerCase();
    if(stri1.length() == stri2.length()) {
      char[] ca1 = stri1.toCharArray();
      char[] ca2 = stri2.toCharArray();
      Arrays.sort(ca1);
      Arrays.sort(ca2);
      boolean output = Arrays.equals(ca1, ca2);
      if(output) {
        System.out.println(stri1 + " and " + stri2 + " are the strings that are anagrams.");
      }
      else {
        System.out.println(stri1 + " and " + stri2 + " are the strings that are not anagrams.");
      }
    }
    else {
      System.out.println(stri1 + " and " + stri2 + " are not anagram.");
    }

    i.close();
  }
}

Ausgabe

Die in der Ausgabe unten erwähnten Zeichenfolgen wurden als Anagramme voneinander deklariert.

Beispiel 3: Anagramme mithilfe von Hashmap implementieren

Mit einer Java-Hashmap können wir ein Schlüssel-Wert-Paar speichern, auf das über den Index zugegriffen werden kann. In diesem Beispiel erfahren Sie, wie Sie mithilfe der Hashmap in Java nach Anagrammen suchen:

import java.io.*;
import java.util.*;

class hashanagram {
  public static void main(String args[]) {

    String str1 = "lamb";
    String str2 = "Balm";    str1 = str1.toLowerCase();
    str2 = str2.toLowerCase();
    HashMap < Character,Integer > hashmap1 = new HashMap < Character, Integer > ();
    HashMap < Character,Integer > hashmap2 = new HashMap < Character, Integer > ();
    char array1[] = str1.toCharArray();
    char array2[] = str2.toCharArray();
    for (int x = 0; x < array1.length; x++) {
      if (hashmap1.get(array1[x]) == null) {

        hashmap1.put(array1[x], 1);
      } else {
        Integer h = (int) hashmap1.get(array1[x]);
        hashmap1.put(array1[x], ++h);
      }
    }
    for (int y = 0; y < array2.length; y++) {

      if (hashmap2.get(array2[y]) == null)
        hashmap2.put(array2[y], 1);
      else {

        Integer h = (int) hashmap2.get(array2[y]);
        hashmap2.put(array2[y], ++h);
      }
    }
    if (hashmap1.equals(hashmap2))
      System.out.println("The two strings are anagrams");
    else
      System.out.println("The two strings aren’t anagrams");

  }
}

Im Code oben:

  • Es wurden zwei Zeichenfolgen deklariert.
  • Erstellen Sie zwei Hashmaps und behalten Sie eine Hashmap mit Zeichenfolge 1 und die zweite Hashmap mit Zeichenfolge 2 bei.
  • Es wird eine For-Schleife erstellt, um jedes Zeichen in der Zeichenfolge zu überprüfen. Wenn das Zeichen nicht vorhanden ist, fügen Sie es der Hashmap hinzu. andernfalls, wenn es bereits vorhanden ist, erhöhen Sie die Anzahl.
  • Überprüfen Sie nun mit der if-else-Anweisung, ob die beiden Hashmaps gleich sind oder nicht.
  • Die Zeichenfolgen schienen identisch zu sein. Deklarieren Sie diese Zeichenfolgen als Anagramme. Die Zeichenfolgen, die sich voneinander unterscheiden, wurden als „keine Anagramme“ deklariert.

Ausgabe

Die Ausgabe unter Verwendung der Hashmap ist unten angehängt:

Dabei geht es um die Suche nach Anagrammen in Java mit verschiedenen Methoden.

Abschluss

In Java können die Anagramme mit verschiedenen Techniken wie arrays.sort(), arrays.equals() usw. überprüft werden. Anagramme sind Zeichenfolgen, die gleiche und gleiche Zeichen enthalten, die normalerweise einmal aus einer der Zeichenfolgen verwendet werden, um eine andere Zeichenfolge zu bilden . In diesem Java-Beitrag wurden verschiedene Methoden zur Suche nach Anagrammen in Java erläutert.

Kommentar verfassen

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert

Nach oben scrollen