Tetris-ing una matriz

Considere la siguiente matriz:

/www/htdocs/1/sites/lib/abcdedd
/www/htdocs/1/sites/conf/xyz
/www/htdocs/1/sites/conf/abc/def
/www/htdocs/1/sites/htdocs/xyz
/www/htdocs/1/sites/lib2/abcdedd

¿Cuál es la forma más corta y elegante de detectar el ruta base común – en este caso

/www/htdocs/1/sites/

y eliminarlo de todos los elementos de la matriz?

lib/abcdedd
conf/xyz
conf/abc/def
htdocs/xyz
lib2/abcdedd

escribir una función longest_common_prefix que toma dos cadenas como entrada. Luego aplíquelo a las cadenas en cualquier orden para reducirlas a su prefijo común. Como es asociativo y conmutativo, el orden no importa para el resultado.

Esto es lo mismo que para otras operaciones binarias como, por ejemplo, la suma o el máximo común divisor.

Cárguelos en una estructura de datos trie. Comenzando desde el nodo principal, vea cuál tiene un hijo que cuenta más que uno. Una vez que encuentre ese nodo mágico, simplemente desmantele la estructura del nodo principal y tenga el nodo actual como raíz.

$common = PHP_INT_MAX;
foreach ($a as $item) {
        $common = min($common, str_common($a[0], $item, $common));
}

$result = array();
foreach ($a as $item) {
        $result[] = substr($item, $common);
}
print_r($result);

function str_common($a, $b, $max)
{
        $pos = 0;
        $last_slash = 0;
        $len = min(strlen($a), strlen($b), $max + 1);
        while ($pos < $len) {
                if ($a{$pos} != $b{$pos}) return $last_slash;
                if ($a{$pos} == "https://stackoverflow.com/") $last_slash = $pos;
                $pos++;
        }
        return $last_slash;
}

Bueno, considerando que puedes usar XOR en esta situación para encontrar las partes comunes de la cadena. Cada vez que xor dos bytes que son iguales, obtiene un byte nulo como salida. Entonces podemos usar eso a nuestro favor:

$first = $array[0];
$length = strlen($first);
$count = count($array);
for ($i = 1; $i < $count; $i++) {
    $length = min($length, strspn($array[$i] ^ $first, chr(0)));
}

Después de ese bucle único, el $length variable será igual a la parte base común más larga entre la matriz de cadenas. Entonces, podemos extraer la parte común del primer elemento:

$common = substr($array[0], 0, $length);

Y ahí lo tienes. Como una función:

function commonPrefix(array $strings) {
    $first = $strings[0];
    $length = strlen($first);
    $count = count($strings);
    for ($i = 1; $i < $count; $i++) {
        $length = min($length, strspn($strings[$i] ^ $first, chr(0)));
    }
    return substr($first, 0, $length);
}

Tenga en cuenta que usa más de una iteración, pero esas iteraciones se realizan en bibliotecas, por lo que en lenguajes interpretados esto tendrá una gran ganancia de eficiencia…

Ahora, si solo desea rutas completas, debemos truncar hasta el último / personaje. Asi que:

$prefix = preg_replace('#/[^/]*$', '', commonPrefix($paths));

Ahora, puede cortar demasiado dos hilos como /foo/bar y /foo/bar/baz será cortado a /foo. Pero antes de agregar otra ronda de iteración para determinar si el siguiente carácter es / o final de cadena, no puedo ver una forma de evitar eso …

Un enfoque ingenuo sería explotar los caminos en el / y comparar sucesivamente cada elemento en las matrices. Entonces, por ejemplo, el primer elemento estaría vacío en todas las matrices, por lo que se eliminará, el siguiente elemento será wwwes el mismo en todas las matrices, por lo que se elimina, etc.

Algo como (no probado)

$exploded_paths = array();

foreach($paths as $path) {
    $exploded_paths[] = explode("https://stackoverflow.com/", $path);
}

$equal = true;
$ref = &$exploded_paths[0]; // compare against the first path for simplicity

while($equal) {   
    foreach($exploded_paths as $path_parts) {
        if($path_parts[0] !== $ref[0]) {
            $equal = false;
            break;
        }
    }
    if($equal) {
        foreach($exploded_paths as &$path_parts) {
            array_shift($path_parts); // remove the first element
        }
    }
}

Después solo tienes que implosionar los elementos en $exploded_paths otra vez:

function impl($arr) {
    return "https://stackoverflow.com/" . implode("https://stackoverflow.com/", $arr);
}
$paths = array_map('impl', $exploded_paths);

Lo que me da:

Array
(
    [0] => /lib/abcdedd
    [1] => /conf/xyz
    [2] => /conf/abc/def
    [3] => /htdocs/xyz
    [4] => /conf/xyz
)

Esto podría no escalar bien;)

Ok, no estoy seguro de que esto sea a prueba de balas, pero creo que funciona:

echo array_reduce($array, function($reducedValue, $arrayValue) {
    if($reducedValue === NULL) return $arrayValue;
    for($i = 0; $i < strlen($reducedValue); $i++) {
        if(!isset($arrayValue[$i]) || $arrayValue[$i] !== $reducedValue[$i]) {
            return substr($reducedValue, 0, $i);
        }
    }
    return $reducedValue;
});

Esto tomará el primer valor en la matriz como cadena de referencia. Luego iterará sobre la cadena de referencia y comparará cada carácter con el carácter de la segunda cadena en la misma posición. Si un carácter no coincide, la cadena de referencia se acortará a la posición del carácter y se comparará la siguiente cadena. La función devolverá la cadena coincidente más corta entonces.

El rendimiento depende de las cadenas dadas. Cuanto antes se acorte la cadena de referencia, más rápido terminará el código. Sin embargo, realmente no tengo ni idea de cómo poner eso en una fórmula.

Descubrí que el enfoque de Artefacto para ordenar las cadenas aumenta el rendimiento. agregando

asort($array);
$array = array(array_shift($array), array_pop($array));

antes de array_reduce aumentará significativamente el rendimiento.

También tenga en cuenta que esto devolverá el subcadena inicial coincidente más largaque es más versátil pero no te dará la camino común. tienes que correr

substr($result, 0, strrpos($result, "https://stackoverflow.com/"));

sobre el resultado Y luego puedes usar el resultado para eliminar los valores.

print_r(array_map(function($v) use ($path){
    return str_replace($path, '', $v);
}, $array));

que debe dar:

[0] => /lib/abcdedd
[1] => /conf/xyz/
[2] => /conf/abc/def
[3] => /htdocs/xyz
[4] => /lib2/abcdedd

Comentarios bienvenidos.

Puede eliminar el prefijo de la manera más rápida, leyendo cada carácter solo una vez:

function findLongestWord($lines, $delim = "https://stackoverflow.com/")
{
    $max = 0;
    $len = strlen($lines[0]); 

    // read first string once
    for($i = 0; $i < $len; $i++) {
        for($n = 1; $n < count($lines); $n++) {
            if($lines[0][$i] != $lines[$n][$i]) {
                // we've found a difference between current token
                // stop search:
                return $max;
            }
        }
        if($lines[0][$i] == $delim) {
            // we've found a complete token:
            $max = $i + 1;
        }
    }
    return $max;
}

$max = findLongestWord($lines);
// cut prefix of len "max"
for($n = 0; $n < count($lines); $n++) {
    $lines[$n] = substr(lines[$n], $max, $len);
}