¿Qué es el algoritmo de Wagner y Fischer y cuál es su código de muestra en C ++?

#include

int main ()
{
/ * El (char) es una conversión tipográfica, que le dice a la computadora que interprete el 65 como un
carácter, no como un número. Va a dar la salida de caracteres de
el equivalente del número 65 (debe ser la letra A para ASCII).
Tenga en cuenta que% c a continuación es el código de formato para imprimir un solo carácter
* /
printf (“% c \ n”, (char) 65);
getchar ();
}

Un uso para la conversión de tipos es cuando desea utilizar los caracteres ASCII. Por ejemplo, ¿qué pasa si desea crear su propio gráfico de los 128 caracteres ASCII? Para hacer esto, necesitará usar para escribir a máquina para permitirle imprimir el entero como su equivalente de caracteres.

#include

int main ()
{
para (int x = 0; x <128; x ++) {
/ * Tenga en cuenta el uso de la versión int de x para generar un número y el uso
* de (char) para escribir la x en un carácter que genera el
* Carácter ASCII que corresponde al número actual
* /
printf (“% d =% c \ n”, x, (char) x);
}
getchar ();

}

Si prestaba mucha atención, podría haber notado algo extraño: cuando pasamos el valor de x a printf como un carácter, ya le habíamos dicho al compilador que teníamos la intención de que el valor fuera tratado como un personaje cuando escribimos la cadena de formato como% c. Dado que el tipo char es solo un número entero pequeño, ¡agregar este tipo de letra en realidad no agrega ningún valor!

Entonces, ¿cuándo sería útil una conversión tipográfica? Un uso de los tipos de letra es forzar a que tenga lugar el tipo correcto de operación matemática. Resulta que en C (y otros lenguajes de programación), el resultado de la división de enteros se trata como un entero: por ejemplo, ¡3/5 se convierte en 0! ¿Por qué? Bueno, 3/5 es menor que 1, y la división entera ignora el resto.

Por otro lado, resulta que la división entre números de coma flotante, o incluso entre un número de coma flotante y un número entero, es suficiente para mantener el resultado como un número de coma flotante. Entonces, si estuviéramos realizando algún tipo de división elegante donde no quisiéramos valores truncados, tendríamos que convertir una de las variables a un tipo de punto flotante. Por ejemplo, (float) 3/5 sale a .6, ¡como es de esperar!

¿Cuándo podría surgir esto? A menudo es razonable almacenar dos valores en enteros. Por ejemplo, si estaba rastreando pacientes cardíacos, podría tener una función para calcular su edad en años y la cantidad de veces que acudirían por dolor cardíaco. Una operación que posiblemente desee realizar es calcular la cantidad de veces por año de vida que alguien ha visitado para ver a su médico sobre el dolor cardíaco. ¿A qué se parecería?

/ * la función mágica devuelve la edad en años * /
int edad = getAge ();
/ * la función mágica devuelve el número de visitas * /
int pain_visits = getVisits ();

flotador visitas_por_año = dolor_visitas / edad;

El problema es que cuando se ejecuta este programa, las visitas por año serán cero, a menos que el paciente haya recibido muchas visitas al médico. La forma de solucionar este problema es convertir uno de los valores que se dividen para que se trate como un número de coma flotante, lo que hará que el compilador trate la expresión como si fuera a dar como resultado un número de coma flotante:

float visitas_por_año = pain_visits / (float) age;
/ * o * /
float visitas_por_año = (flotante) pain_visits / age;

El algoritmo Wagner-Fischer es un algoritmo de programación dinámico que mide la distancia de Levenshtein entre dos cadenas de caracteres.
Por ejemplo, la distancia de Levenshtein entre “gatito” y “sentado” es 3, ya que las siguientes tres ediciones cambian de una a otra, y no hay forma de hacerlo con menos de tres ediciones.

Aquí está el código fuente del programa C ++ para implementar el algoritmo Wagner y Fisher para la coincidencia de cadenas en línea. El programa C ++ se compila y ejecuta con éxito en un sistema Linux. La salida del programa también se muestra a continuación.

Este es un programa de C ++ para implementar la búsqueda en línea.

#include
#include
#include
int d [100] [100];
#definir MIN (x, y) ((x) <(y)? (x): (y))
int main ()
{
int i, j, m, n, temp, rastreador;
char s [] = “Sanfoundry”;
char t [] = “Educación”;
m = strlen (s);
n = strlen (t);

para (i = 0; i <= m; i ++)
d [0] [i] = i;
para (j = 0; j <= n; j ++)
d [j] [0] = j;

para (j = 1; j <= m; j ++)
{
para (i = 1; i <= n; i ++)
{
if (s [i-1] == t [j-1])
{
rastreador = 0;
}
más
{
rastreador = 1;
}
temp = MIN ((d [i-1] [j] +1), (d [i] [j-1] +1));
d [i] [j] = MIN (temp, (d [i-1] [j-1] + rastreador));
}
}
printf (“la distancia de Levinstein es% d \ n”, d [n] [m]);
devuelve 0;
}

Salida:

$ g ++ WagnerFischer.cpp
$ a.out

la distancia de Levinstein es de 9

——————
(programa salido con código: 0)
Presione regresar para continuar