Longitud del anagrama de prefijo más largo que son comunes en dos strings dadas

Posted on by Rudeus Greyrat

Dadas dos strings str1 y str2 de las longitudes de N y M respectivamente, la tarea es encontrar la longitud de la string de anagrama más larga que es la substring de prefijo de ambas strings.

Ejemplos:

Entrada: str1 = “abaabcdezzwer”, str2 = “caaabbttyh”
Salida: 6
Explicación: 
Los prefijos de longitud 1 de la string str1 y str2 son “a” y “c”.
Los prefijos de longitud 2 de la string str1 y str2 son «ab» y «ca».
Los prefijos de longitud 3 de la string str1 y str2 son «aba» y «caa».
Los prefijos de longitud 4 de la string str1 y str2 son «abaa» y «caaa».
Los prefijos de longitud 5 de la string str1 y str2 son «abaab» y «caaab».
Los prefijos de longitud 6 de la string str1 y str2 son «abaabc» y «caaabb».
Los prefijos de longitud 7 de la string str1 y str2 son «abaabcd» y «caaabbt».
Los prefijos de longitud 8 de la string str1 y str2 son «abaabcde» y «caaabbtt».
Los prefijos de longitud 9 de la string str1 y str2 son «abaabcdez» y «caaabbtty».
Los prefijos de longitud 10 de la string str1 y str2 son «abaabcdezz» y «caaabbttyh».
Los prefijos de longitud 6 son anagramas entre sí solamente.

Entrada: str1 = «abcdef», str2 = «tuvwxyz»
Salida: 0

Enfoque: La idea es usar Hashing para resolver el problema anterior. Siga los pasos a continuación para resolver el problema:

  • Inicialice dos arrays de enteros freq1[] y freq2[] , cada una de tamaño 26 , para almacenar el recuento de caracteres en las strings str1 y str2 respectivamente.
  • Inicialice una variable, digamos ans , para almacenar el resultado.
  • Iterar sobre los caracteres de la string presente en los índices [0, mínimo (N – 1, M – 1)] y realizar lo siguiente:
    • Incremente el recuento de str1[i] en la array freq1[] y el recuento de str2[i] en la array freq2[] en 1 .
    • Compruebe si la array de frecuencias freq1[] es la misma que la array de frecuencias freq2[], asigne ans = i + 1 .
  • Después de los pasos anteriores, imprima el valor de ans como resultado.

A continuación se muestra la implementación del enfoque anterior:

C++

// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
#define SIZE 26
 
// Function to check if two arrays
// are identical or not
bool longHelper(int freq1[], int freq2[])
{
    // Iterate over the range [0, SIZE]
    for (int i = 0; i < SIZE; ++i) {
 
        // If frequency any character is
        // not same in both the strings
        if (freq1[i] != freq2[i]) {
            return false;
        }
    }
 
    // Otherwise
    return true;
}
 
// Function to find the maximum
// length of the required string
int longCommomPrefixAnagram(
    string s1, string s2, int n1, int n2)
{
    // Store the count of
    // characters in string str1
    int freq1[26] = { 0 };
 
    // Store the count of
    // characters in string str2
    int freq2[26] = { 0 };
 
    // Stores the maximum length
    int ans = 0;
 
    // Minimum length of str1 and str2
    int mini_len = min(n1, n2);
 
    for (int i = 0; i < mini_len; ++i) {
 
        // Increment the count of
        // characters of str1[i] in
        // freq1[] by one
        freq1[s1[i] - 'a']++;
 
        // Increment the count of
        // characters of str2[i] in
        // freq2[] by one
        freq2[s2[i] - 'a']++;
 
        // Checks if prefixes are
        // anagram or not
        if (longHelper(freq1, freq2)) {
            ans = i + 1;
        }
    }
 
    // Finally print the ans
    cout << ans;
}
 
// Driver Code
int main()
{
    string str1 = "abaabcdezzwer";
    string str2 = "caaabbttyh";
    int N = str1.length();
    int M = str2.length();
 
    // Function Call
    longCommomPrefixAnagram(str1, str2,
                            N, M);
 
    return 0;
}

Java

// Java program for the above approach
public class Main
{
  static int SIZE = 26;
 
  // Function to check if two arrays
  // are identical or not
  static boolean longHelper(int[] freq1, int[] freq2)
  {
 
    // Iterate over the range [0, SIZE]
    for (int i = 0; i < SIZE; ++i)
    {
 
      // If frequency any character is
      // not same in both the strings
      if (freq1[i] != freq2[i])
      {
        return false;
      }
    }
 
    // Otherwise
    return true;
  }
 
  // Function to find the maximum
  // length of the required string
  static void longCommomPrefixAnagram(
    String s1, String s2, int n1, int n2)
  {
    // Store the count of
    // characters in string str1
    int[] freq1 = new int[26];
 
    // Store the count of
    // characters in string str2
    int[] freq2 = new int[26];
 
    // Stores the maximum length
    int ans = 0;
 
    // Minimum length of str1 and str2
    int mini_len = Math.min(n1, n2);
 
    for (int i = 0; i < mini_len; ++i) {
 
      // Increment the count of
      // characters of str1[i] in
      // freq1[] by one
      freq1[s1.charAt(i) - 'a']++;
 
      // Increment the count of
      // characters of str2[i] in
      // freq2[] by one
      freq2[s2.charAt(i) - 'a']++;
 
      // Checks if prefixes are
      // anagram or not
      if (longHelper(freq1, freq2)) {
        ans = i + 1;
      }
    }
 
    // Finally print the ans
    System.out.print(ans);
  }
 
  // Driver code
  public static void main(String[] args)
  {
    String str1 = "abaabcdezzwer";
    String str2 = "caaabbttyh";
    int N = str1.length();
    int M = str2.length();
 
    // Function Call
    longCommomPrefixAnagram(str1, str2, N, M);
  }
}
 
// This code is contributed by divyeshrrabadiya07.

Python3

# Python3 program for the above approach
SIZE = 26
 
# Function to check if two arrays
# are identical or not
def longHelper(freq1, freq2):
     
    # Iterate over the range [0, SIZE]
    for i in range(26):
 
        # If frequency any character is
        # not same in both the strings
        if (freq1[i] != freq2[i]):
            return False
 
    # Otherwise
    return True
 
# Function to find the maximum
# length of the required string
def longCommomPrefixAnagram(s1, s2, n1, n2):
   
    # Store the count of
    # characters in str1
    freq1 = [0]*26
 
    # Store the count of
    # characters in str2
    freq2 = [0]*26
 
    # Stores the maximum length
    ans = 0
 
    # Minimum length of str1 and str2
    mini_len = min(n1, n2)
    for i in range(mini_len):
 
        # Increment the count of
        # characters of str1[i] in
        # freq1[] by one
        freq1[ord(s1[i]) - ord('a')] += 1
 
        # Increment the count of
        # characters of stord(r2[i]) in
        # freq2[] by one
        freq2[ord(s2[i]) - ord('a')] += 1
 
        # Checks if prefixes are
        # anagram or not
        if (longHelper(freq1, freq2)):
            ans = i + 1
 
    # Finally print the ans
    print (ans)
 
# Driver Code
if __name__ == '__main__':
    str1 = "abaabcdezzwer"
    str2 = "caaabbttyh"
    N = len(str1)
    M = len(str2)
 
    # Function Call
    longCommomPrefixAnagram(str1, str2, N, M)
     
    # This code is contributed by mohit kumar 29.

C#

// C# program for the above approach
using System;
class GFG
{   
    static int SIZE = 26;
     
    // Function to check if two arrays
    // are identical or not
    static bool longHelper(int[] freq1, int[] freq2)
    {
       
        // Iterate over the range [0, SIZE]
        for (int i = 0; i < SIZE; ++i)
        {
      
            // If frequency any character is
            // not same in both the strings
            if (freq1[i] != freq2[i])
            {
                return false;
            }
        }
      
        // Otherwise
        return true;
    }
     
    // Function to find the maximum
    // length of the required string
    static void longCommomPrefixAnagram(
        string s1, string s2, int n1, int n2)
    {
        // Store the count of
        // characters in string str1
        int[] freq1 = new int[26];
      
        // Store the count of
        // characters in string str2
        int[] freq2 = new int[26];
      
        // Stores the maximum length
        int ans = 0;
      
        // Minimum length of str1 and str2
        int mini_len = Math.Min(n1, n2);
      
        for (int i = 0; i < mini_len; ++i) {
      
            // Increment the count of
            // characters of str1[i] in
            // freq1[] by one
            freq1[s1[i] - 'a']++;
      
            // Increment the count of
            // characters of str2[i] in
            // freq2[] by one
            freq2[s2[i] - 'a']++;
      
            // Checks if prefixes are
            // anagram or not
            if (longHelper(freq1, freq2)) {
                ans = i + 1;
            }
        }
      
        // Finally print the ans
        Console.Write(ans);
    }
 
  // Driver code
  static void Main() {
    string str1 = "abaabcdezzwer";
    string str2 = "caaabbttyh";
    int N = str1.Length;
    int M = str2.Length;
  
    // Function Call
    longCommomPrefixAnagram(str1, str2, N, M);
  }
}
 
// This code is contributed by divyesh072019.

Javascript

<script>
 
// Javascript program for the above approach
 
let SIZE = 26;
  
// Function to check if two arrays
// are identical or not
function longHelper(freq1, freq2)
{
     
    // Iterate over the range [0, SIZE]
    for(let i = 0; i < SIZE; ++i)
    {
         
        // If frequency any character is
        // not same in both the strings
        if (freq1[i] != freq2[i])
        {
            return false;
        }
    }
     
    // Otherwise
    return true;
}
  
// Function to find the maximum
// length of the required string
function longCommomPrefixAnagram(s1, s2, n1, n2)
{
     
    // Store the count of
    // characters in string str1
    let freq1 = new Array(26);
    freq1.fill(0);
   
    // Store the count of
    // characters in string str2
    let freq2 = new Array(26);
    freq2.fill(0);
   
    // Stores the maximum length
    let ans = 0;
   
    // Minimum length of str1 and str2
    let mini_len = Math.min(n1, n2);
   
    for(let i = 0; i < mini_len; ++i)
    {
         
        // Increment the count of
        // characters of str1[i] in
        // freq1[] by one
        freq1[s1[i].charCodeAt() -
                'a'.charCodeAt()]++;
   
        // Increment the count of
        // characters of str2[i] in
        // freq2[] by one
        freq2[s2[i].charCodeAt() -
                'a'.charCodeAt()]++;
   
        // Checks if prefixes are
        // anagram or not
        if (longHelper(freq1, freq2))
        {
            ans = i + 1;
        }
    }
   
    // Finally print the ans
    document.write(ans);
}
 
// Driver code
let str1 = "abaabcdezzwer";
let str2 = "caaabbttyh";
let N = str1.length;
let M = str2.length;
 
// Function Call
longCommomPrefixAnagram(str1, str2, N, M);
 
// This code is contributed by rameshtravel07
 
</script>
Producción: 

6

 

Complejidad de Tiempo: O(N*26)
Espacio Auxiliar: O(26)

Publicación traducida automáticamente

Artículo escrito por sk9209767 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *