Solución Enicial

Se toma la primera cadena como referencia y se construye un prefijo tentativo incrementando caracteres uno a uno, verificando si cada cadena comienza con este prefijo.

function encontrarPrefijo(cadenas) {
    let prefijo = '';
    for (let i = 0; i < cadenas[0].length; i++) {
        let esComun = true;
        let prefTentativo = cadenas[0].substring(0, i + 1);
        for (let j = 1; j < cadenas.length; j++) {
            if (!cadenas[j].startsWith(prefTentativo)) {
                esComun = false;
                break;
            }
        }
        if (!esComun) break;
        else prefijo = prefTentativo;
    }
    return prefijo;
}

Método 1: Escaneo Horizontal

Utiliza recursión para reducir el problema mediante comparaciones sucesivas entre pares de cadenas.

function hallarPrefijoHorizontal(cadenas) {
    if (cadenas.length === 0) return '';
    let prefijo = cadenas[0];
    for (let i = 1; i < cadenas.length; i++) {
        prefijo = calcularLCP(prefijo, cadenas[i]);
        if (!prefijo) break;
    }
    return prefijo;
}

function calcularLCP(s1, s2) {
    let longitudMin = Math.min(s1.length, s2.length);
    let res = '';
    for (let i = 0; i < longitudMin; i++) {
        if (s1[i] === s2[i]) res += s1[i];
        else break;
    }
    return res;
}

Método 2: Escaneo Vertical

Verifica columnas verticalmente comparando los caracteres correspondientes en todas las cadenas.

function obtenerPrefijoVertical(cadenas) {
    if (cadenas.length === 0) return '';
    let prefijo = '';
    for (let i = 0; i < cadenas[0].length; i++) {
        let char = cadenas[0][i];
        let comun = true;
        for (let j = 0; j < cadenas.length; j++) {
            if (cadenas[j][i] !== char) {
                comun = false;
                break;
            }
        }
        if (comun) prefijo += char;
        else break;
    }
    return prefijo;
}

Método 3: Dividir y Conquistar

Divide el arreglo en mitades y compara las partes resultantes.

function dividirConquistar(cadenas) {
    if (cadenas.length === 0) return '';
    return lcpRecursivo(0, cadenas.length - 1, cadenas);
}

function lcpRecursivo(inicio, fin, cadenas) {
    if (inicio === fin) return cadenas[inicio];
    const medio = Math.floor((inicio + fin) / 2);
    const izquierda = lcpRecursivo(inicio, medio, cadenas);
    const derecha = lcpRecursivo(medio + 1, fin, cadenas);
    const minLong = Math.min(izquierda.length, derecha.length);
    for (let i = 0; i < minLong; i++) {
        if (izquierda[i] !== derecha[i]) return izquierda.substring(0, i);
    }
    return izquierda.substring(0, minLong);
}

Método 4: Búsqueda Binaria

Usa búsqueda binaria para determinar el tamaño del prefijo común.

function buscarBinarioPrefijo(cadenas) {
    if (!cadenas.length) return '';

    const validarPrefijo = (tamano) => {
        const ref = cadenas[0].substring(0, tamano);
        for (let i = 1; i < cadenas.length; i++) {
            if (cadenas[i].substring(0, tamano) !== ref) return false;
        }
        return true;
    };
    let tamMin = cadenas[0].length;
    for (let i = 1; i < cadenas.length; i++) tamMin = Math.min(tamMin, cadenas[i].length);
    let bajo = 0, alto = tamMin;
    while (bajo < alto) {
        let medio = Math.floor((alto - bajo + 1) / 2) + bajo;
        if (validarPrefijo(medio)) bajo = medio;
        else alto = medio - 1;
    }
    return cadenas[0].substring(0, bajo);
}

Método 5: Ordenar y Comparar Extremos

Ordena las cadenas y compara solo el primer y último elemento.

function ordenarYComparar(cadenas) {
    if (!cadenas.length) return '';
    const ordenadas = cadenas.sort();
    const primero = ordenadas[0], ultimo = ordenadas[ordenadas.length - 1];
    let resultado = '';
    for (let i = 0; i < primero.length; i++) {
        if (primero[i] === ultimo[i]) resultado += primero[i];
        else break;
    }
    return resultado;
}