Anagrama válido

Anagrama válido (Java, Python, PHP, C++, Javascript).

Introducción
Este es un ejercicio que realiza facebook en sus pruebas técnicas.

En este artículo, cubriremos los siguientes temas:

✅ Una explicación del problema
✅ Una solución eficiente
✅ Implementaciones en Java, Python, PHP, C++ y JavaScript

           

Problema
Dadas dos palabras o strings , devolver true si son anagramas y falso en caso contrario.

Un anagrama es una palabra o frase formada reorganizando las letras de otra palabra o frase diferente.
        


        
Pasos para realizar el ejercicio:
1.- Se verifica si el tamaño de las palabras son diferentes. Si es así, entonces no pueden ser anagramas y se devuelve false, en caso contrario, se continúa.

2.- Se crean dos arrays vacíos cantidad_pablras_uno y cantidad_pablras_dos para almacenar la cantidad de veces que aparece cada letra en las palabras respectivamente.

3.- Se recorre cada letra de las palabras. En cada iteración, se guarda la letra  evaluada como índice e incrementa su valor correspondiente en los arrays cantidad_palabras_uno y cantidad_palabras_dos.

4.- Se verifican que ambos arrays tengan las mismas letras como índices y la misma cantidad de elementos, en caso contrario, se devuelve false, porque significa que las palabras no son anagramas.

5.- Si no se ha devuelto false en ningún paso anterior, entonces las palabras son anagramas y se devuelve true.

Presentación

Código en Java

class Solution {
    public boolean isAnagram(String palabra_uno, String palabra_dos) {
 
        // Paso 1
        if (palabra_uno.length() != palabra_dos.length()) {
            return false;
        }
 
        // Paso 2
        Map<Character, Integer> cantidad_palabras_uno = new HashMap<>();
        Map<Character, Integer> cantidad_palabras_dos = new HashMap<>();
 
        // Paso 3
        for (int i = 0; i < palabra_uno.length(); i++) {
            char letra_uno = palabra_uno.charAt(i);
            char letra_dos = palabra_dos.charAt(i);
 
            cantidad_palabras_uno.put(letra_uno, cantidad_palabras_uno.getOrDefault(letra_uno, 0) + 1);
            cantidad_palabras_dos.put(letra_dos, cantidad_palabras_dos.getOrDefault(letra_dos, 0) + 1);
        }
 
        // Paso 4
        for (Map.Entry<Character, Integer> entrada : cantidad_palabras_uno.entrySet()) {
            if (!cantidad_palabras_dos.containsKey(entrada.getKey())) return false;
            if (!cantidad_palabras_dos.get(entrada.getKey()).equals(entrada.getValue())) return false;
 
        }
 
        // Paso 5
        return true;
    }
}

Código en php

class Solution {
 
    /**
     * @param String $palabra_uno 
     * @param String $palabra_dos
     * @return Boolean
     */
    function isAnagram($palabra_uno , $palabra_dos) {
        //paso#1
        if(strlen($palabra_uno ) !== strlen($palabra_dos)) return false;
 
        //paso#2
        $cantidad_palabras_uno=array();
        $cantidad_palabras_dos=array();
 
        //paso#3
        for($i = 0;$i < strlen($palabra_uno);$i++){
            $indice_palabra_uno=$palabra_uno[$i];
            $indice_palabra_dos=$palabra_dos[$i];
 
            $cantidad_palabras_uno[$indice_palabra_uno]++;
            $cantidad_palabras_dos[$indice_palabra_dos]++;
        }
 
        //paso#4
        foreach ($cantidad_palabras_uno as $letra => $cantidad) {
            if(!isset($cantidad_palabras_dos[$letra])) return false;
            if($cantidad_palabras_dos[$letra]!= $cantidad) return false;
        }
 
        //paso#5
        return true;
 
    }
}

Código en Python

class Solution:
    def isAnagram(self, palabra_uno, palabra_dos):
        # Paso 1
        if len(palabra_uno) != len(palabra_dos):
            return False
 
        # Paso 2
        cantidad_palabras_uno = {}
        cantidad_palabras_dos = {}
 
        # Paso 3
        for i in range(len(palabra_uno)):
            letra_uno = palabra_uno[i]
            letra_dos = palabra_dos[i]
 
            cantidad_palabras_uno[letra_uno] = cantidad_palabras_uno.get(letra_uno, 0) + 1
            cantidad_palabras_dos[letra_dos] = cantidad_palabras_dos.get(letra_dos, 0) + 1
 
        # Paso 4
        for letra, cantidad in cantidad_palabras_uno.items():
            if letra not in cantidad_palabras_dos:
                return False
            if cantidad != cantidad_palabras_dos[letra]:
                return False
 
        # Paso 5
        return True

        
    
Conclusión
En este artículo, hemos aprendido a resolver el ejercicio Anagrama Válido, uno de los ejercicios más populares de la plataforma LeetCode. Este ejercicio es un buen punto inicio para aprender a resolver problemas de sobre hash maps.