Estoy tratando de encontrar la posición de una subcadena dentro de una cadena sin usar ninguna función strpos () o strlen (). ¿Cómo voy a hacer esto?

Answer 1

$ haystack = “asdfgh jklaswera xcbgt”;
$ aguja = “wer”;

puede hacer esto con stristr () o strstr (), el primero no distingue entre mayúsculas y minúsculas y el segundo. No está claro por qué querrías hacerlo.

Si se trata de algún tipo de prueba de tarea y no puede usar ninguna función str, puede hacerlo con bastante facilidad con las matrices, aunque obtener la cadena en una matriz generalmente requiere una función de cadena como str_split () porque explotar no funciona con una cadena vacía “” como delimitador.

Una vez que tenga el “pajar en una matriz, lo clasificará recursivamente buscando el primer personaje en aguja. Cada vez que encuentre el primer carácter, verificará el segundo carácter y así sucesivamente hasta llegar al final de la aguja.

También puede hacer esto como una expresión regular con preg_match ().

Tan pronto como presioné enter pensé en otra forma.

$ haystack = “asderfgh jklaswera xcwwebgt”;
$ aguja = “wer”;
$ i = 0;
while ($ haystack [$ i]! = “”) {// recorre el pajar
$ p = 0;
if ($ haystack [$ i] == $ needle [$ p]) {// si el primer carácter de la aguja está presente compare
while ($ aguja [$ p]! = “”) {
$ temp = $ i + $ p;
if ($ aguja [$ p] == $ haystack [$ temp]) {
$ prueba = “sí”; // verifica cada carácter de subcadena
} más {
$ prueba = “no”; // no coincide, probablemente debería escapar aquí
}
$ p ++;

}
if ($ test == “yes”) echo “subcadena en la posición”. $ i. “y longitud”. $ p. “
“;
}
$ i ++;
}

Answer 2

Aquí hay una manera de hacerlo sin usar ninguna función de cadena:

int substrpos (char * string; char * substring) {
char * p;
int i;
for (p = string; * p! = NULL; ++ p) {
para (i = 0; subcadena [i]! = NULL; ++ i)
if (p [i]! = subcadena [i]) {
descanso;
}
}
if (subcadena [i] == NULL) {
return (int) (p – cadena);
}
}
volver -1;
}

Answer 3

#include
#include
int strpos (char * str, char * sub_str)
{
char * sub_str_address = strstr (str, sub_str);
// encuentra la primera aparición de la subcadena en la cadena

return sub_str_address == NULL? -1: (sub_str_address – str);
// si es nulo, devuelve -1; de lo contrario, devuelve la dirección de la subcadena: dirección base

// este caso asume la dirección base 100, luego la dirección base “mundial” será // 106 (106-100) = 6
}
int main ()
{
char * str = “Hello_world”, * sub_str = “mundo”;
int ret = strpos (str, sub_str);

ret == -1? printf (“Subcadena no encontrada”): printf (“% d”, ret);
devuelve 0;
}

Answer 4

Use el algoritmo Knuth – Morris – Pratt.

Answer 5

Navaja de Occam: usa strpos. Si no se encuentra la cadena, obtendrá un resultado de error (generalmente -1 o falso según el idioma). Esto es más rápido que rodar el tuyo.

Answer 6

Conozca sus datos. puede optimizar sus búsquedas según el tipo de datos que esté utilizando.

obtén el primer y el último carácter de tu subcadena con su longitud. Lea la cadena para el primer carácter de su subcadena. si lo encuentra, avance la longitud de su subcadena hasta el último carácter. si es lo mismo que el último carácter de su subcadena, pruebe esa longitud de la cadena contra su subcadena. Si no es una coincidencia, o el último personaje no fue una coincidencia, comience a leer hacia adelante nuevamente. Si su subcadena siempre será lo suficientemente única, puede comenzar a leer hacia adelante desde el final de la subcadena, pero no lo recomiendo (Algunas optimizaciones son útiles si la subcadena es como una página, o un tamaño fijo, o donde está la subcadena altamente único o tiene puntos iniciales y finales únicos que no se superponen entre sí, pero este tipo de optimizaciones no son útiles para procesar cosas como caracteres aleatorios).

puede dividir este problema en varias partes para que sea más rápido a través de bloques de tamaño arbitrario y procesamiento múltiple. Pero debe probar si la subcadena divide bloques. pruebe el frente de cada bloque para el último carácter dentro de la longitud de la subcadena. si lo encuentra, vuelve a leer la longitud de la subcadena y la compara con la sección del mismo tamaño de la subcadena. si eso coincide, lea el final del bloque anterior para ver si coincide con el frente de la subcadena. También puede hacer esto dando a cada bloque un encabezado que no se procese en el bloque, el tamaño de la subcadena, y simplemente leer de nuevo por la misma regla sin tener que acceder a la sección anterior de la cadena original. en ambos escenarios solo te importa la cabeza de los bloques, no las colas. cada bloque de proceso informa sus hallazgos al proceso principal para finalizar el programa.

vea también la clasificación rápida para obtener un índice que luego lee para encontrar coincidencias en los valores de posición inicial y final (pero este enfoque es sensible al tamaño de los datos). Además, si la longitud de su subcadena es muy larga, puede verificar las secciones de cadena seleccionadas en subprocesos como una forma de acelerar el código.

Answer 7

Con un uso inteligente de un bucle for anidado y, si no, condiciones.

Dado que una cadena es solo una matriz de caracteres, puede analizar cada índice con un ciclo for normal.