En este post pondré la función para ver si una cadena es anagrama de otra usando C.

Las cosas con C son más complicadas, pero a su vez más interesantes. Todo esto es porque C es un lenguaje de programación que es fuertemente tipado y que no tiene un recolector de basura ni esas cosas que otros tienen.

Personalmente me gusta resolver ejercicios con C, pues siempre suponen un reto. Por eso es que hoy veremos cómo saber si dos cadenas o palabras son anagramas utilizando el lenguaje de programación C.

El algoritmo para determinar si una palabra es anagrama de otra

Los pasos son pocos, pero cada uno lleva su determinado tiempo. Lo primero que se hace es quitar signos de puntuación, espacios y cosas que no cuentan en los anagramas; para ello usamos esta función que remueve caracteres de una cadena en C.

Más tarde convertimos ambas palabras a mayúsculas o minúsculas; porque los anagramas no toman en cuenta la notación de las letras, así que ambas deben estar en la misma notación.

Finalmente ordenamos las cadenas alfabéticamente y si después de todo esto son iguales, entonces se dice que son anagramas.

Ejemplo del funcionamiento del algoritmo

Veamos un ejemplo rápido con una referencia a Harry Potter y el que no debe ser nombrado. Las cadenas son:

‘I am Lord Voldemort‘ y ‘Tom Marvolo Riddle‘

Les quitamos los espacios y ahora son:

‘IamLordVoldemort‘ y ‘TomMarvoloRiddle‘

Se convierten a minúsculas y ahora se ven así:

‘iamlordvoldemort‘ y ‘tommarvoloriddle‘

Finalmente se ordenan alfabéticamente así:

‘addeillmmooorrtv‘ y ‘addeillmmooorrtv‘

Si ambas son iguales (tanto en contenido como longitud) entonces se dice que son anagramas. El ejemplo de arriba es un anagrama.

Función en C que dice si una cadena es anagrama de otra

Después de tanta charla, es hora de presentar la función. La misma recibe dos cadenas y devuelve un booleano indicando si son o no anagramas.

Nota: la función va a modificar a las cadenas, así que si quieres mantenerlas intactas haz una copia de ellas.

/*
        Comprobar si dos palabras son anagramas, o si una palabra es anagrama
        de otra usando el lenguaje de programación C

        @author parzibyte
*/#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>

#define MAXIMA_LONGITUD_CADENA 100

// Prototipos de funciones

// Función tomada de:
// https://parzibyte.me/blog/2019/01/16/remover-caracteres-de-cadena-c/
void removerCaracteres(char *cadena, char *caracteres);

// La función para ordenar cadenas, una simple envoltura de strcmp
int comparar(const void *a, const void *b);

// La función que nos interesa
int esAnagrama(char *cadena, char *otraCadena);

int main() {
  // Un arreglo de arreglos de cadenas, sólo es para ejemplificar
  // https://parzibyte.me/blog/2018/11/08/arreglos-de-cadenas-en-c/
  char palabras[5][2][MAXIMA_LONGITUD_CADENA] = {
      {"I am Lord Voldemort", "Tom Marvolo Riddle"},
      {"Amor", "Roma"},
      {"Luis", "Parzibyte"},
      {"Esto no es", "un anagrama"},
      {"Frase", "Fresa"}};
  for (int x = 0; x < 5; x++) {
    printf("\n\nProbando con '%s' y '%s'\n", palabras[x][0], palabras[x][1]);
    int resultado = esAnagrama(palabras[x][0], palabras[x][1]);
    if (resultado) {
      printf("SON anagramas");
    } else {
      printf("NO SON anagramas");
    }
  }
  return EXIT_SUCCESS;
}

int comparar(const void *a, const void *b) {
  // Castear a char y regresar lo que regresaría strcmp ;)
  return strcmp((char *)a, (char *)b);
}

void removerCaracteres(char *cadena, char *caracteres) {
  int indiceCadena = 0, indiceCadenaLimpia = 0;
  int deberiaAgregarCaracter = 1;
  // Recorrer cadena carácter por carácter
  while (cadena[indiceCadena]) {
    // Primero suponemos que la letra sí debe permanecer
    deberiaAgregarCaracter = 1;
    int indiceCaracteres = 0;
    // Recorrer los caracteres prohibidos
    while (caracteres[indiceCaracteres]) {
      // Y si la letra actual es uno de los caracteres, ya no se agrega
      if (cadena[indiceCadena] == caracteres[indiceCaracteres]) {
        deberiaAgregarCaracter = 0;
      }
      indiceCaracteres++;
    }
    // Dependiendo de la variable de arriba, la letra se agrega a la "nueva
    // cadena"
    if (deberiaAgregarCaracter) {
      cadena[indiceCadenaLimpia] = cadena[indiceCadena];
      indiceCadenaLimpia++;
    }
    indiceCadena++;
  }
  // Al final se agrega el carácter NULL para terminar la cadena
  cadena[indiceCadenaLimpia] = 0;
}

int esAnagrama(char *palabra, char *otraPalabra) {

  // Quitar caracteres como signos de puntuación o espacios
  removerCaracteres(palabra, " ,.!");
  removerCaracteres(otraPalabra, " ,.!");

  // Convertir a minúsculas a ambas palabras
  // https://parzibyte.me/blog/2018/09/20/convertir-cadena-a-mayuscula-y-minuscula-en-c/
  int contador = 0;
  while (palabra[contador]) {
    palabra[contador] = tolower(palabra[contador]);
    contador++;
  }
  contador = 0;
  while (otraPalabra[contador]) {
    otraPalabra[contador] = tolower(otraPalabra[contador]);
    contador++;
  }

  // Ordenar las letras de ambas palabras
  qsort(otraPalabra, strlen(otraPalabra), sizeof(char), comparar);
  qsort(palabra, strlen(palabra), sizeof(char), comparar);

  // Si al ordenarlas y ponerlas en minúsculas son iguales, entonces son
  // anagramas
  return strcmp(palabra, otraPalabra) == 0;
}

Para probar, declaré un arreglo de arreglos de cadenas y fui probando cada grupo de palabras. Para ordenar se usa qsort usando a strcmp que devuelve 1, 0 o -1 dependiendo de la comparación de las cadenas.

Los métodos para eliminar caracteres de una cadena o convertir a minúsculas están en el código.

Eso es todo. Recuerda que puedes ver más cosas sobre C aquí.