[Desafío PHP] Función reduce()

[pateketrueke]

Vallu

Código php:

function reduce($text){
    $arr_txt = str_split($text);
    $str='';
    $creciente=false;
    $max_creciente='';
    $decreciente=false;
    $max_decreciente='';
    $max_length=count($arr_txt);
    $contador_cre=0;
    $contador_de=0;
//recorro el array en el qual esta la cadena a compilar
    for($i=0;$i<$max_length;$i++){
        if($i==0){
            $str=$arr_txt[$i];
        }else{
            if($arr_txt[$i]==$arr_txt[$i-1]){ //si la letra la siguente de la anterior
                if($creciente){
                    if($contador_cre>1){ //y el contador dice que hay 2 o mas
                        $str.="-".$max_creciente; //se acorta con la forma a-c
                    }else{
                        $str.=$max_creciente;
                    }
                    $contador_cre=0;
                    $creciente=false;
                }elseif($decreciente){ //lo mismo pero en decreciente
                    if($contador_de>1){
                        $str.="-".$max_decreciente;
                    }else{
                        $str.=$max_decreciente;
                    }
                    $contador_de=0;
                    $decreciente=false;
                }
                $str.=$arr_txt[$i];
            }elseif((ord($arr_txt[$i])-1)==ord($arr_txt[$i-1])){ //La anterior letra es mas pequeña
                if($i==$max_length-1){ //Si es la ultima letra de la cadena
                    if($contador_cre>0){ //y el contador no es 0
                        $str.="-".$arr_txt[$i];
                    }else{
                        $str.=$arr_txt[$i-1].$arr_txt[$i];
                    }
                }else{
                    if($decreciente){ //si no es la ultima letra de la cadena
                        if($contador_de>1){ //y venimos de una cadena decreciente
                            $str.="-".$max_decreciente;
                        }else{
                            $str.=$max_decreciente;
                        }
                        $contador_de=0;
                    }
                    $contador_cre++;
                    $creciente=true;
                    $max_creciente=$arr_txt[$i];
                    $decreciente=false;
                    $max_decreciente='';
                }
            }elseif((ord($arr_txt[$i])+1)==ord($arr_txt[$i-1])){ //La anterior letra es mas grande
                if($i==$max_length-1){ //Si es la ultima letra de la cadena
                    if($contador_de>0){
                        $str.="-".$arr_txt[$i];
                    }else{
                        $str.=$arr_txt[$i-1].$arr_txt[$i];
                    }
                }else{ //si no es la utlima letra de la cadena
                    if($creciente){
                        if($contador_cre>1){
                            $str.="-".$max_creciente;
                        }else{
                            $str.=$max_creciente;
                        }
                        $contador_cre=0;
                    }
                    $contador_de++;
                    $decreciente=true;
                    $max_decreciente=$arr_txt[$i];
                    $creciente=false;
                    $max_creciente='';
                }
            }else{ //si la letra no viene de creciente o decreciente
                if($creciente){ //pero la anterior letra si es creciente
                    if($contador_cre>1){
                        $str.="-".$max_creciente;
                    }else{
                        $str.=$max_creciente;
                    }
                    $creciente=false;
                    $contador_cre=0;
                }elseif($decreciente){ //mismo per en decreciente
                    if($contador_de>1){
                        $str.="-".$max_decreciente;
                    }else{
                        $str.=$max_decreciente;
                    }
                    $decreciente=false;
                    $contador_de=0;
                }
                $str.=$arr_txt[$i];
            }
        }
    }
    return $str;
}
 

Les presento el código mas largo de la competencia, como pueden ver resulta muy claro si se lee poco a poco. Personalmente lo veo complicado con mucho if-then-else, y realmente no lo entiendo del todo.

Sin embargo cabe destacar el uso de arreglos a partir de una cadena, una técnica que veremos a lo largo de las siguientes participaciones.

[pateketrueke]

santris

Código PHP:

function reduce($texto){
$resultado = $nuevo_resultado = $sub_trozo = $trozo2 = $sub_trozo2 = '';
//creamos la cadena contra la que realizaremos las comparaciones
$cadena_comp="abcdefghijklmnopqrstuvwxyz";
//asignamos la longitudud de la cadena $texto a la variable $longitud_cadena
$longitud_cadena=strlen($texto);
$nuevo_texto=$texto.substr($texto,-1);//arreglo
//creamos un bucle en el cual el número de iteraciones es igual al valor de $longitud_cadena
$i=0;
for ($i=0; $i<=$longitud_cadena; $i++){
    $sub_trozo.=substr($nuevo_texto,$i,1);
    //comparamos al valor de la variable $sub_trozo con la cadena de comparación $cadena_comp, si es cierto asignamos el valor de $sub_trozo a la variable $trozo
    if(preg_match("/$sub_trozo/",$cadena_comp))
        $trozo=$sub_trozo;
    //en caso contrario evaluamos las variables $trozo y sub_trozo
    else{
        if(strlen($trozo)>0){
            if(strlen($trozo)>2){
                $str_reducido=substr($trozo,0,1)."-".substr($trozo,-1);
                $resultado.=$str_reducido;
            }
            else
                $resultado.=$trozo;
        $sub_trozo = '';//vaciamos
        $trozo = '';//vaciamos
        $i=$i-1;//descontamos un incremento por la letra que ocasionó la comparación negativa
        }
        else{
            if(strlen($sub_trozo)>2){
                $str_reducido=substr($sub_trozo,0,1)."-".substr($sub_trozo,-1);
                $resultado.=$str_reducido;
            }
            else
                $resultado.=$sub_trozo;
        $sub_trozo = '';
        $trozo = '';
        $i=$i-1;
        }
    }
}
//invertimos la cadena de comparación y realizamos el mismo procedimiento anterior
$nueva_cadena_comp=strrev($cadena_comp);
$longitud_cadena2=strlen($resultado);
$nuevo_texto2=$resultado.substr($resultado,-1);
$i=0;
for ($i=0; $i<=$longitud_cadena2; $i++){
    $sub_trozo2.=substr($nuevo_texto2,$i,1);
    if(preg_match("/$sub_trozo2/",$nueva_cadena_comp))
        $trozo2=$sub_trozo2;
    else{
        if(strlen($trozo2)>0){
            if(strlen($trozo2)>2){
                $str_reducido2=substr($trozo2,0,1)."-".substr($trozo2,-1);
                $nuevo_resultado.=$str_reducido2;
            }
            else
                $nuevo_resultado.=$trozo2;
        if($trozo2!="-")
            $i=$i-1;
        $sub_trozo2 ='';
        $trozo2 = '';
        }
        else{
            if(strlen($sub_trozo2)>2){
                $str_reducido2=substr($sub_trozo2,0,1)."-".substr($sub_trozo2,-1);
                $nuevo_resultado.=$str_reducido2;
            }
            else
                $nuevo_resultado.=$sub_trozo2;
        if($sub_trozo2!="-")
            $i=$i-1;
        $sub_trozo2 = '';
        $trozo2 = '';
        }
    }
}
return $nuevo_resultado;
}
 

Siguiendo el sendero de los scripts largos les presento este código. Aquí, lo curioso es el uso de cadenas auxiliares para comprobar la pertenencia del conjunto a-z

También debo mencionar un detalle que me encontré en la etapa de evaluación: el uso de unset(), en algunas secuencias de código hacía uso de unset($foo); en lugar de solo $foo='';

El problema radicaba en que a la siguiente vuelta del bucle, si antes fue unseteada alguna variable esta ya no existe -realmente- en el contexto, además del proceso de concatenación por variables indefinidas, etc...

Es un buen trabajo no lo dudo, y da los resultados esperados. Un ejemplo interesante es la reversa que aplica en el código, para el análisis contrario de secuencias z-a. La implementación dejó varia cháchara de que hablar, muchas gracias...

[pateketrueke]

Triby

Código PHP:

function reduce ($str) {
    // Patrón para comparación
    $letters = 'abcdefghijklmnopqrstuvwxyz';
    // Dirección actual
    $dir = 'no';
    // Longitud  de la cadena original
    $strlen = strlen($str) - 1;
     // Primer caracter directo
    $reduce = $str[0];
    // Iniciamos desde el segundo
    for ($i = 1; $i <= $strlen; $i++):
        // Caracter actual y su posición en el patrón
        $char = $str[$i];
        $pos = strpos($letters, $char);
        // Caracter anterior en $str y su posición
        $lastchar = $str[$i - 1];
        $lastpos = strpos($letters, $lastchar);
 
        // Secuencia y dirección?
        if ($pos == ($lastpos + 1)  && ($dir == 'left' || $dir == 'no')):
            // Secuencia izq
            $dir = 'left';
            if ($i < $strlen):
                // Si no es el último caracter
                continue;
            endif;
        elseif ($pos == ($lastpos - 1) && ($dir == 'right' || $dir == 'no')):
            // Secuencia der
            $dir = 'right';
            if ($i < $strlen):
                // Si no es el último caracter
                continue;
            endif;
        elseif ($dir == 'no'):
            // No hay secuencia
            $reduce .= $char;
            continue;
        endif;
        // Por default
        $reverse = false;
        // Cambio de sentido?
        if ($i < $strlen):
            // Siguiente caracter y posición para verificar
            $newchar = $str[$i + 1];
            $newpos = strpos($letters, $newchar);
            // Cambio de dirección?
            $reverse = (($dir == 'left' && $pos == ($newpos + 1) && $lastpos == ($newpos + 2))
                || ($dir == 'right' && $pos == ($newpos - 1) && $lastpos == ($newpos - 2)));
            if ($reverse):
                // Aplicamos la nueva dirección
                $dir = ($pos == ($newpos - 1)) ? 'left' : 'right';
            else:
                // Cancelamos dirección anterior
                $dir = 'no';
            endif;
        else:
            $dir = 'no';
        endif;
        // Fin de secuencia y/o cambio de dirección
 
        // Posición del último caracter de $reduce
        $redpos = strpos($letters, $reduce[strlen($reduce) - 1]);
        // Verificamos cantidad caracteres
        $abs = abs($redpos - $lastpos);
 
        // Último caracter de $str
        if ($i == $strlen):
            if ($abs == 0):
                // No hay secuencia
                $reduce .= $char;
            elseif (abs($pos - $lastpos) != 1):
                // No hay secuencia, quedaba pendiente caracter anterior
                $reduce .= "-{$lastchar}{$char}";
            else:
                // Sí hay secuencia
                $reduce .= "-{$char}";
            endif;
        elseif ($abs > 1):
            // Secuencia más de 2 caracteres
            // ? - Cambio, omite el caracter actual
            // : - No cambio, se agregan guión, último y caracter actual
            $reduce .= ($reverse) ? "-{$lastchar}" : "-{$lastchar}{$char}";
        else:
            // Secuencia es de sólo dos caracteres   ab
            // ? - Cambio, se omite el caracter actual
            // : - No cambio, se agregan último y caracter actual
            $reduce .= ($reverse) ? $lastchar : "{$lastchar}{$char}";
        endif;
    endfor;
    return $reduce;
}
 

Otro script que usa cadenas auxiliares para comprobar el rango, y que tampoco entiendo del todo.

Cabe mencionar que realmente es complicado traducir un algoritmo mental en código claro, esto es cierto también pero comprender el proceso inverso es realmente complicado, sino hasta difícil. (:

Es interesante la sintaxis que se utiliza en este script, desde versiones alternativas de keywords para control de flujo, aka. endif, endfor, etc.. así como también un uso correcto y casi magistral de variables, comparaciones, comillas y comentarios.

[pateketrueke]

gary_qwerty

Código PHP:

function reduce($string){
 
    if( strlen($string) < 3 ){
        return $string;
    }
 
    $abc = array("a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z");
 
    $str_arr = array();
    $c = 0;
    while( $c < strlen($string) ){
        $str_arr[] = substr($string, $c, 1);
        $c++;
    }
 
    $str_replace = $str_arr;
    foreach($str_arr as $k=>$letter){
        $val = array_search($letter, $abc);
        if( isset( $str_arr[$k+1] ) ){
            if( isset($abc[$val+1]) && $str_arr[$k+1] ==  $abc[$val+1] ){
                if( isset($str_arr[$k+2])  && isset($abc[$val+2]) && $str_arr[$k+2] == $abc[$val+2] ){
                    unset($str_replace[$k+1]);
                }
            }
            else if( isset($abc[$val-1]) && $str_arr[$k+1] ==  $abc[$val-1] ){
                if( isset($str_arr[$k+2]) && isset($abc[$val-2]) &&  $str_arr[$k+2] == $abc[$val-2]  ){
                    unset($str_replace[$k+1]);
                }
            }
        }
    }
 
    $keys = array();
    $letters = array();
    foreach($str_replace as $k=>$l){
        $keys[] = $k;
        $letters[] = $l;
    }
 
    $ret = "";
 
    foreach($keys as $k=>$l){
        if( isset($keys[$k+1]) ){
            if( $l+1 == $keys[$k+1] ){
                $ret .= $letters[$k];
            }
            else{
                $ret .= $letters[$k]."-";
            }
        }
        else{
            $ret .= $letters[$k]."-";
        }
    }
 
    $ret = substr($ret, 0, strlen($ret)-1 );
    return $ret;
}
 

Un script de mas de 1000B, y que siendo aún mas corto que otros no es mas veloz.

Haciendo una bella combinación de cadenas, arreglos y bucles consigue pasar las pruebas y aquí lo tenemos. Según se cuenta, una simple corrección y ya tenemos listo todo el algoritmo.

Sin duda códigos como esto demuestra la flexibilidad no del lenguaje, sino de la mente humana. ;)

[pateketrueke]

oso96_2000

Código PHP:

function reduce ($text = null) {
    // Revisamos que exista un texto y que sean caracteres permitidos
    if (empty($text) || (bool) preg_match('/[^a-z]+/', $text)) {
        trigger_error('Debes especificar una cadena consistente en caracteres de la "a" a la "z". Cadena enviada: ' . $text, E_USER_ERROR);
    }
 
    // Creamos un arreglo a partir del texto
    $characters = function_exists('str_split') ? str_split($text) : preg_split('@([a-z]{1})@', $text, -1, PREG_SPLIT_DELIM_CAPTURE|PREG_SPLIT_NO_EMPTY) ;
 
    // Declaramos variables
    $total  = count($characters);
    $result = '';
    $now    = '';
    $prev   = false;
    $next   = false;
 
    //Comenzamos el loop
    for ($i = 0; $i < $total; $i++) {
        // Obtenemos el caracter siguiente
        $next   = isset($characters[$i + 1]) ? $characters[$i + 1] : false ;
 
        //
        if ($characters[$i] == $next || $characters[$i] == $prev) {
            $now = $characters[$i];
        }else{
            $now = '-';
        }
 
        // Si estamos en medio de una secuencia y hay que romperla
        if ($now == '-' && (ord($characters[$i]) + 1 != ord($next) || ord($characters[$i]) - 1 != ord($prev))) {
            $now = $characters[$i];
        }
 
        // Secuencia de reversa
        if (ord($characters[$i]) + 1 == ord($prev) && ord($characters[$i]) - 1 == ord($next)) {
            $now = '-';
        }
 
        // Si es el primero o ultimo
        if ($i == 0 || $i == ($total - 1)) {
            $now = $characters[$i];
        }
 
        // Asignamos el caracter actual
        $result .= $now;
 
        // Guardamos para saber cual era el caracter anterior
        $prev   = $characters[$i];
    }
 
    // Quitamos guiones innecesarios
    $result = preg_replace('/-{2,}/', '-', $result);
    $result = trim($result, '- ');
 
    return $result;
}
 

Y de ultimo momento nos llegó este otro código para la competición. Sin duda un código claro y controlado, que sin embargo no consigue superar a la mayoría de otros códigos cual fideos parecieran.

Me gusto el uso de un solo bucle e if-then-else especifico y breve.

[pateketrueke]

De_la_Cuesta_13

Código PHP:

function reduce($str){
 
    $str = strtolower($str);
    $abc = "abcdefghijklmnopqrstuvwxyz";
 
    $a = str_split($abc);
    $s = str_split($str);
    $l_str = strlen($str);
    $ult_str = $l_str - 1;
    $ult_abc = strlen($abc) - 1;
    $salida = "";
    $m = 0;
    $t = 0;
 
    for($i=0;$i<$l_str;$i++){
 
        if($m==1)
            $i--;
 
        /*
            $j me indica en que posición del abecedario ($abc) se encuentra el caracter actual ($i), así:
            1. Si el caracter que sigue en $abc ($j+1) es igual al que sigue en $str ($i+1), se busca reducir en orden.
            2. Si el caracter anterior en $abc ($j-1) es igual al que sigue en $str ($i+1), se busca reducir en reversa.
        */
        $j = strpos($abc, $str{$i});
 
        //busco en orden
        if($i<$ult_str && $j<$ult_abc && $abc{$j+1}==$str{$i+1}){
            if($m==1)
                $m=0;
            else
                $salida .= $str{$i};
            $j++;
            $k = $i;
            $i++;
            //busco hasta que posición $str es igual a $abc, en orden
            for($p=$i;$p<$l_str;$p++){
                if($j<=$ult_abc && $a[$j]==$s[$p]){
                    $j++;
                    continue;
                }
                else
                    break;
            }
 
            $p--;
            $i = $p;
            // se debe reducir porque hay 3 o más caracteres en orden
            if(($i-$k)>=2)
                $salida .= "-".$str{$i};
            else
                $salida .= $str{$i};
            /*
                reviso si después del último caracter en order se debe reducir en reversa.
                $t = 1, sí
                NOTA: Si $t = 1, no se agrega el caracter a la salida en la posición $i, puesto
                que ya se ha agregado en orden.
            */
            $t=1;
        }
 
        if($t==1)
            $j = strpos($abc, $str{$i});
 
        //busco en reversa
        if($i<$ult_str && $j>0 && $a{$j-1}==$str{$i+1}){
            if($t!=1)
                $salida .= $str{$i};
            $j--;
            $k = $i;
            $i++;
            //busco hasta que posición $str es igual a $abc, en reversa
            for($p=$i;$p<$l_str;$p++){
                if($j>=0 && $a[$j]==$s[$p]){
                    $j--;
                    continue;
                }
                else
                    break;
            }
 
            $p--;
            $i = $p;
            // se debe reducir porque hay 3 o más caracteres en reversa
            if(($i-$k)>=2)
                $salida .= "-".$str{$i};
            else
                $salida .= $str{$i};
            /*
                reviso si después del último caracter en reversa se debe reducir en orden.
                $m = 1, sí
                NOTA: Si $m = 1, no se agrega el siguiente caracter en la posición $i, puesto
                que ya se ha agregado en reversa.
            */
            $j = strpos($abc, $str{$i});
            if($i<$ult_str && $abc{$j+1}==$str{$i+1})
                $m=1;
        }
 
        else{
            if($t!=1)
                $salida .= $str{$i};
        }
        $t=0;
    }
 
    return $salida;
}
 

Esta es la viva imagen de que un código largo no necesariamente es lento, sino todo lo contrario.

El código ganador en velocidad bajo las pruebas actuales, el mas rápido, si... sin duda. Que al igual que otros scripts usa cadenas, arreglos auxiliares, y casi imposible de creer mas de un solo bucle.

Excelente.

[pateketrueke]

Definitivamente los códigos largos son impactantes, y hasta entendibles... ¿pero que sucede con los códigos menores a 1000B?

¿serán igual de claros? ¿precisos? ¿rápidos?

Pues precisamente no mas rápidos... en la mayoría de los casos nada claros, pero el ingenio hace reducir incluso nuestras participaciones, llegando a un niveles tan abstractos que si valen la pena divulgar!!

Ya teniendo un código más rápido, y a sabiendas de a quien le pertenece el mas corto continuemos con la pasarela de mini-faldas.... (;

[pateketrueke]

GatorV

Código PHP:

function reduce($cadena)
{
    if (strlen($cadena) < 3) {
        return $cadena;
    }
 
    $chars = preg_split('//', $cadena, -1, PREG_SPLIT_NO_EMPTY);
    $size = count($chars);
    $out = array();
    $pos = 0;
 
    while($pos < $size) {
        $current = ord($chars[$pos]);
        $next = (isset($chars[($pos + 1)])) ? ord($chars[($pos + 1)]) : 0;
        $onext = (isset($chars[($pos + 2)])) ? ord($chars[($pos + 2)]) : 0;
        $out[] = $chars[$pos];
 
        if (($current + 1) == $next && (($current + 2) == $onext)) {
            $out[] = '-';
            do {
                $pos++;
                $current = ord($chars[$pos]);
                $next = (isset($chars[($pos + 1)])) ? ord($chars[($pos + 1)]) : 0;
                if (($current + 1) != $next) {
                    break;
                }
            } while(true);
        } elseif ((($current - 1) == $next) && (($current - 2) == $onext)) {
            $out[] = '-';
            do {
                $pos++;
                $current = ord($chars[$pos]);
                $next = (isset($chars[($pos + 1)])) ? ord($chars[($pos + 1)]) : false;
                if (($current - 1) != $next) {
                    break;
                }
            } while(true);
        } else {
            $pos++;
        }
    }
 
    return implode('', $out);
}
 

He aquí el primer código de un moderador del foro de PHP, que como pueden observar hace un serie de elegantes bucles, muy interesante y sin comentarios. Pero es entendible, y bien, no es lo mas corto... pero que bueno se pone esto!!

La comparación lógica de los números ordinales en la secuencia de caracteres es solo una parte del problema, que como pocos supo resolver de manera efectiva y breve. Además coloca su código dentro de los mas rápidos cerca de la media 0.0050

[pateketrueke]

pateketrueke

Código PHP:

function reduce($text)
{
    $key = 0;
    $str = array();
 
    $test = addcslashes($text, $text);
    $array = explode('\\', trim($test, '\\'));
 
    do
    {
        if (empty($str))
        {
            if (strlen($text) < 3) return $text;
            $str []= $array[$key++];
            continue;
        }
        elseif ( ! isset($array[$key]))
        {
            if (end($str) != $current) $str []= $current;
            return join('', $str);
        }
 
        $left = ord($prev = $array[$key -1]);
        $right = ord($current = $array[$key++]);
 
        if (($factor = abs($left - $right)) == 0 OR $factor > 1)
        {
            if (end($str) == '-') $str []= $prev;
            $str []= $current;
        }
        elseif ($factor == 1)
        {
            $next = isset($array[$key])? $array[$key]: '';
            switch (1)
            {
                default: break;
                case ($left < $right && $right > ord($next));
                case ($left > $right && $right < ord($next));
                    $str []= $current;
                break;
                case (end($str) != '-');
                    if (abs(ord($next) - $right) != 1) $str []= $current;
                    else $str []= '-';
                break;
            }
 
        }
    } while (1);
}
 

Yo. Igualmente sin comentarios, que les puedo decir: me gustan muchos los arreglos, y sabiendo que muchos usarían algún método split quise hacer algo distinto. Me agrada usar bucles lógicos, condicionales y asignaciones extrañas, etc.

Eso lo digo yo, porque nadie puede juzgar mi código mas que el jurado electo para el reto.

Por debajo de la mayoría, mi participación no resultó la mas veloz, mucho menos más la mas corta... pero que entretenido fue escribir la trivial función.

[pateketrueke]

abimaelrc

Código PHP:

function reduce($text)
{
/*
    Variables
 
    $lastChar = número ascii de caracter anterior
    $chars = array temporal que contiene los caracteres posibles a reducir
    $n = número de la llave de la variable $chars
    $tries = número para verificar si es mayor a 3 reducir caracteres
            indicados en la variable chars
    $boolPos = boolean para caracteres que van aumentando
    $boolNeg = boolean para caracteres que van disminuyendo
*/
    $lastChar = 1;
    $chars = array();
    $n = 0;
    $tries = 1;
    $boolPos = false;
    $boolNeg = false;
 
    for($i=0; $i<strlen($text); $i++){
        // Obtener el valor ASCII
        $asciiVal = ord($text[$i]);
 
        /*
        Verifica si el valor ASCII corriente es menor al valor ASCII del caracter
        anterior (caracteres de mayor a menor) y si es consecutivo. Si se cumple
        entonces verifica si se había ejecutado anteriormente la segunda condición
        para resetear la variable $tries o continuarla. Si la variable $tries es
        mayor o igual a tres, coloca el guión sino lo contrario y se añade el
        caracter corriente. La variable $chars se sobre-escribe cuando hay más
        de tres caracteres consecutivos. Se verifica si el próximo caracter existe
        y si cambia el proceso (es decir verifica si cambia de mayor -> menor,
        a menor -> mayor el caracter) para aumentar la variable $n y añadir el
        siguiente caracter en un nuevo espacio en la variable $chars. Se
        modifican los valores booleanos para el siguiente caracter.
        */
        if($asciiVal < $lastChar && ($lastChar % $asciiVal) == 1){
            $tries = $boolPos ? 2 : ++$tries;
            $chars[$n] = ($tries >= 3 ? '-' : '') . $text[$i];
            if(!empty($text[$i + 1]) && ord($text[$i + 1]) > $asciiVal){
                ++$n;
            }
            $boolNeg = true;
            $boolPos = false;
        }
 
        /*
        Es el mismo proceso de la condición anterior pero de menor a mayor
        los caracteres.
        */
        elseif($asciiVal > $lastChar && ($asciiVal % $lastChar) == 1){
            $tries = $boolNeg ? 2 : ++$tries;
            $chars[$n] = ($tries >= 3 ? '-' : '') . $text[$i];
            if(!empty($text[$i + 1]) && ord($text[$i + 1]) < $asciiVal){
                ++$n;
            }
            $boolPos = true;
            $boolNeg = false;
        }
 
        // Es para los resultados que no son consecutivos y el primer caracter.
        else{
            $chars[$n] = (!empty($chars[$n]) ? $chars[$n] : '') . $text[$i];
            ++$n;
            $tries = 1;
        }
 
        // Almacenar el caracter corriente para usarlo en la siguiente vuelta
        $lastChar = $asciiVal;
    }
 
    // Retornar el valor y unir los caracteres almacenados en la variable $chars
    return implode('',$chars);
}
 

Es un código corto, los comentarios no se cuenta lo aseguro. Esta es la primera participación en la que me encuentro una comparación con módulos.

Bastante claro y muy bien expresado, felicitaciones!!

[pateketrueke]

maycolalvarez

Código PHP:

function reduce($str)
 {
     $charSequence       = null; // contiene el carácter que inicia una  secuencia:
     $charSequenceDiff   = 0;    // contiene la diferencia con la cual se  identifica la secuencia (+1 ó -1)
     $result             = '';   // cadena donde se vuelcan los  resultados
 
     for ($i = 0; $i < strlen($str); $i++) {
         // extrae el carácter actual y el proximo:
         $current        = $str[$i];
         $next           = isset($str[$i + 1]) ? $str[$i + 1] : null;
         // obtiene su valor ASCII para comparar:
         $currentChar    = ord($current);
         $nextChar       = ord($next);
         // obtiene el valor absoluto para determinar si están en  secuencia
         $absoluteDiff   = abs($currentChar - $nextChar);
 
         if (($absoluteDiff == 0) || ($absoluteDiff > 1)) {
             if (($charSequence != null) &&  (abs(ord($charSequence) - $currentChar) > 1)) {
                 $result .= '-';
             }
             $result.= $current;
             $charSequence   =  null;
         } else {
             // diferencia entre los caracteres consecutivos (-1  incremento, +1 decremento)
             $diff = ($currentChar - $nextChar);
 
             if(($charSequence == null) || ($charSequenceDiff != $diff)) {
                 if(($charSequence != null) &&  (abs(ord($charSequence) - $currentChar) > 1)) {
                     $result .= '-';
                 }
                 $result.= $current;
                 $charSequence       = $current;
                 $charSequenceDiff   = $diff;
             }
         }
     }
     return $result;
 }
 

Si bien recuerdo, este fue el primer código que recibí.

El comparar un valor absoluto en cuanto a la diferencia en la secuencia a-z es crucial, al momento de implementar la comparación normal e invertida. Si, ya se que no se entiende lo que digo... pero juro que otra clave se encuentra ahí.

[pateketrueke]

Gustavo72

Código PHP:

function reduce($text) {
    //La función recorre la cadena comparando cada caracter con el anterior.
    //Los caracteres solo se agregan al resultado final si no hay secuencia.
    //Cuando una secuencia termina se agrega el caracter anterior al resultado; si la secuencia es de más de dos letras se agrega antes un guión.
    $res=""; //En esta cadena construyo el resultado.
    $carAnt=""; //Esta variable guardará el caracter anterior.
    $codAnt=0; //Esta variable guardará el código ASCII del caracter anterior.
    $secuencia=0; //Esta variable contará la cantidad de caracteres en secuencia menos 1. Su signo indicará el sentido ascendente (+) o descendente (-).
    $text.=" ";
    for ($a=0; $a<strlen($text); $a++) { //Recorro la cadena:
        $sinSecuencia=true;
        $nuevaSecuencia=0;
        if (ord($text[$a])==$codAnt+1) { //Compara caracter con el anterior y detecta secuencia ascendente:
            if ($secuencia<0)
                $nuevaSecuencia=1; //Se inicia secuencia ascendente en sentido contrario al actual
            else {
                $secuencia++;
                $sinSecuencia=false;
            }
        }
        elseif (ord($text[$a])==$codAnt-1) { //Compara caracter con el anterior y detecta secuencia descendente:
            if ($secuencia>0)
                $nuevaSecuencia=-1; //Se inicia secuencia descendente en sentido contrario al actual
            else {
                $secuencia--;
                $sinSecuencia=false;
            }
        }
 
        if ($sinSecuencia) { //No hay secuencia o se inició una en sentido opuesto:
            if (abs($secuencia)==1)
                $res.=$carAnt; //Secuencia rota de solo dos letras. Agrego caracter anterior sin guión
            elseif (abs($secuencia)>1)
                $res.="-$carAnt"; // Cierro secuencia de más de dos letras con guión y caracter anterior
 
            if (!$nuevaSecuencia) { //No se inicio nueva secuencia:
                $res.=$text[$a]; //Agrega el aactual
                $secuencia=0; //No secuencia
            }
            else
                $secuencia=$nuevaSecuencia; //Seteo secuencia en sentido contrario
        }
        $carAnt=$text[$a];
        $codAnt=ord($text[$a]);
    }
    return trim($res);
}
 

Otro lindo y corto script.

A diferencia de otras implementaciones, este código no hace uso de comparaciones con el siguiente carácter, o el siguiente del siguiente, etc..

Sabiendo la lógica impuesta, el uso razonable tan solo del carácter anterior de la secuencia actual es importante. Así, de una buena ves se evitan errores de undefined offset, etc..

[pateketrueke]

eZakto

Código PHP:

function reduce($string)
{
    // Compruebo que es posible que haya al menos un rango de 3 caracteres
    if(strlen($string) < 3)
    {
        return $string;
    }
 
    // Lista de carácteres permitidos
    $charset = array_flip(array('a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'));
 
    // Guarda los cambios que se realicen
    $cache   = $string;
 
    // Indica si la posición actual es dentro de un rango (false) o no (true)
    $start   = true;
 
    // $position es la posición actual dentro de la cadena,
    // $i = -1 hará que se parseen los rangos en orden alfabético, $i = 1 hará que sea al revés
    for ($position = 1, $i = -1; $i < 2; ++$position)
    {
        // Almacena el último carácter tras la posición actual
        $last = $string[$position-1];
 
        // Verifico en $charset si $last está inmediatamente antes/después que el carácter actual
        // En caso contrario, en la próxima iteración comenzará a buscar un nuevo rango
        if ($charset[$last] == ($charset[$string[$position]]+$i))
        {
            if ($start == true)
            {
                // Estoy dentro de un rango
                $start = false;
            }
            else
            {
                // Reemplazo el carácter anterior en $cache
                $cache[$position-1] = '-';
            }
        }
        else
        {
            $start = true;
        }
 
        // Una vez completado el recorrido de la cadena, reestabilizo $string, $position e $i
        // para comenzar el recorrido nuevamente, pero parseando los rangos en orden inverso
        if ($position >= strlen($string)-1)
        {
            $position = 0;
            $i        = $i + 2;
        }
    }
 
    // Finalmente reemplazo los '-----' por '-'
    return preg_replace('/-+/', '-', $cache);
}
 

Con un bucle un tanto extraño, y también haciendo uso de arreglos auxiliares tenemos este otro script.

Omitiendo comentarios se nota que es realmente reducido, y bueno... la implementación si es de las mas atrevidas, un tanto por su bizarres y otro tanto por su precisión, quedando igualmente cerca de la media en tiempo de ejecución.

[pateketrueke]

AlvaroG

Código PHP:

function reduce($cadena) {
    $continuar = true;
    $pos = 0;
    $nueva = "";
    $max_pos = strlen($cadena)-1;
 
    // si la cadena es vacía o de largo 1, no continuar
    if ($max_pos < 1) {
        return $cadena;
    }
 
    while ($continuar) {
        // agrego a $nueva el caracter actual
        $nueva .= $cadena{$pos};
        $diferencia = ord($cadena{$pos}) - ord($cadena{$pos+1});
 
        // con esto se determina si el intervalo es creciente o decreciente (abc o cba)
        if (abs($diferencia) == 1 ) {
            $signo_diferencia = ($diferencia > 0) ? 1 : -1;
 
            $i = 2;
            // busco el último caracter del intervalo
            while( ($pos+$i <= $max_pos) && ((ord($cadena{$pos}) - ord($cadena{$pos+$i})) == $signo_diferencia*$i) ) {
                $i++;
            }
            // si el intervalo es de más de 2 caracteres (abc en vez de ab), agrego el - para separar
            if ($i > 2) {
                $nueva .= '-';
            }
            // para la vuelta siguiente, empiezo a buscar un intervalo después del que acabo de encontrar
            $pos += $i-1;
 
        } else {
            $pos++;
        }
 
        // si no llegué al final de $cadena, seguir recorriéndola
        $continuar = ($pos < $max_pos);
    }
    // el último caracter de la cadena nunca es procesado por el while anterior. Devolver entonces lo que había
    // juntado en $nueva + el último caracter
    return $nueva.$cadena{$max_pos};
}
 

Un código con dos bucles, y también dos diferencias notables.

Al menos, el problema nos indicaba un parte de la solución... el primer y último carácter permanecen intactos, además de que me fascinan los bucles lógicos.

¿ya se los había dicho?

[pateketrueke]

Para finalizar esta parte de la competencia solo falta mostrar ĺos tres códigos mas cortos, que no quiere decir rápidos por supuesto...

La elegancia de los códigos cortos me atrae mucho, y siendo scripter de antaño me recuerda el gran trabajo que suele haber detrás de un código pequeño, la mente de susodichos creadores es algo que me resulta perturbador si me dejan opinar algo...

Antes de, quiero agradecer de nuevo su participación y deseo con gran afán participar en algún otro reto que se proponga la comunidad. Gracias!!

[pateketrueke]

fran86

Código PHP:

function reduce($cadena)
{
    // Solo aplica a cadenas de 3 o mas caracteres
    if (strlen($cadena) >= 3) {
        // Agrega el extremo izquierdo
        $cadenaReducida = $cadena[0];
        // Recorre la cadena omitiendo el primer y ultimo caracter
        for ($i=1; $i<strlen($cadena)-1; $i++) {
            $iInicial = $i;
            // Avanza la posicion del caracter si es el medio de un rango
            while (   ($i+1 < strlen($cadena))
                   && ($cadena[$i-1] != $cadena[$i+1])
                   && ((ord($cadena[$i-1])+ord($cadena[$i+1]))/2 == ord($cadena[$i]))
            ) {
                $i++;
            }
            // Agrega en $cadenaReducida de acuerdo a si se omitieron o no caracteres
            if ($iInicial != $i) {
                $cadenaReducida .= "-";
                $i--;
            } else {
                $cadenaReducida .= $cadena[$i];
            }
        }
        // Agrega el extremo derecho
        $cadenaReducida .= $cadena[strlen($cadena)-1];
        return $cadenaReducida;
    } else {
        return $cadena;
    }
}
 

Un código honesto y magnifico, resulta muy halagador a la lectura la participación de este usuario.

Aunque claro, no supera con creces el tiempo de ejecución de sus oponentes si cumple su cometido, y lo realiza de manera ejemplar. Ya aquí se pone en practica el descarte del primer y último carácter, luego un bucle como scanner... presto!!

[pateketrueke]

Hidek1

Código PHP:

function reduce($text)
{
    $reduced = "";
    $text = str_split($text);
    foreach($text as $key => $value) {
        $num1 = isset($text{$key+1}) ? ord($text{$key+1}) : 0;
        $num2 = ord($value) + 1;
        $reduced .= $value;
        if($num1 == $num2) {
            $reduced .= '##';
            continue;
        } 
        elseif($num1 == ($num2 - 2)) {
            $reduced .= '@@';
            continue;
        }
    }
    $reduced = preg_replace('/(#[a-z]#|@[a-z]@)+/', '-', $reduced);
    return str_replace(array('@', '#'), '', $reduced);
}
 

¿Que se creen?

Pues este no es el código mas corto, lamentablemente. Curioso realmente, la implementación resulta correcta y extraña.

Que mas les puedo decir... segundo lugar en tamaño del script, y segundo lugar en ejecución de código... ¿pues que le pasa a este muchacho??

[pateketrueke]

quike88

Código PHP:

function reduce($string)
{
    $res=$string[0]; //cadena donde se guardara el resultado, le asigno inicialmente el 1er caracter de la cadena
    $flag=0; //en el caso de que exista la secuencia se pone en 1, para que asi, si es de mas 3 letras, no se repita el '-'
    $longitud=strlen($string)-1; //longitud de la cadena -1, ya que el 1ro caracter y el ultimo los pongo directamente
    for($i=1;$i<$longitud;$i++)
    {
    //verifico si el valor ascii - 1 es igual al del caracter anterior, y sumando 1 si es igual al proximo, y luego al revez por si la secuencia es reversa.
        if( (ord($string[$i])-1==ord($string[$i-1]) and ord($string[$i])+1==ord($string[$i+1])) or (ord($string[$i])+1==ord($string[$i-1]) and ord($string[$i])-1==ord($string[$i+1])) ) {
            if($flag==0){
                $res.='-';
                $flag=1;
            }
        }
        else {
            $res.=$string[$i];
            $flag=0;
        }
    }
    $res.=$string[$i];
    return $res;
}
 

Bingo!!

Este si es el código mas breve, sin embargo falla en cadenas menores a tres caracteres... ;)

Ahora, tomando en cuenta algunos factores para resumir la abstracción de la solución... este código pudo ser aún mas reducido, igual que el nombre de la función... reduce()

[Nisrokh]

Pucha llegue tarde

Solo para saber como me fue... @pateketrueke ¿Me tomarías el tiempo de mi reduce()? :D Lo haría yo, pero no se como lo has echo...

Aca dejo mi código, no lo mando por PM porque ya termino el desafío...

Lo hagas o no, gracias de todas formas :D

Utilize: strlen() y ord()

Código PHP:

<?php
 
function reduce($text) {
    
    // Tamaño de la cadena
    $length = strlen($text);
    
    // Devolver la misma cadena si hay menos de 3 carácteres
    if ($length < 3)
        return $text;
    
    // Arreglo con el valor ASCII de cada carácter
    $chars = array();
    
    for ($i = 0; $i < $length; $i++)
        $chars[] = ord($text[$i]);
    
    $char = 0; // Carácter a verificar
    $output = ''; // Salida
    $previous = $current = $next = $range_start = $num_range_chars = $order = 0;
    
    do {
        
        $previous = $chars[$char - 1]; // Carácter anterior
        $current = $chars[$char]; // Carácter actual
        $next = $chars[$char + 1]; // Carácter siguiente
        
        // Verificar si ya estamos dentro de un rango
        if ($range_start) {
            
            // Si el carácter anterior es mayor o menor
            // (De acuerdo al orden de los carácteres)
            // es igual al actual, marcar que el carácter actual
            // está dentro de un rango de carácteres
            if (($previous + $order) == $current) {
                ++$num_range_chars;
            } else {
                
                // Si hemos encontrado un carácter que no pertenece
                // al rango que estamos analizando, y el rango actual
                // tiene menos de 3 carácteres, agregamos el carácter anterior
                // a salida y continuamos (Ya que si estamos analizando un rango,
                // y solo encontramos 2 carácteres, el segundo nunca se agregó)
                if ($num_range_chars == 2)
                    $output.= $text[$char - 1];
                
                // Si el carácter actual, no esta dentro del rango,
                // pero pudimos terminar de analizar el rango actual,
                // agregamos el último carácter a salida
                if ($num_range_chars > 2)
                    $output.= '-' .$text[$char - 1];
                
                // Reseteamos las variables de rango
                $range_start = $num_range_chars = 0;
            }
        }
        
        // Si entre el carácter anterior, actual y el siguiente forman una cadena casi palíndromo
        // Ej.: aba, oao, bab (Pero NO aaa, bbb, ccc, etc.)
        // Nos aseguramos de terminar el rango que estamos analizando correctamente
        // para seguir con el siguiente y detectamos el nuevo orden: decreciente o ascendente
        if ($previous != $current && $next != $current && $previous == $next) {
            
            // Señalar final del rango actual, si estamos en uno
            if ($num_range_chars > 2)
                $output.= '-';
            
            // Agregar carácter a salida
            $output.= $text[$char];
            
            // Marcar comienzo de nuevo rango
            $range_start = $current;
            $num_range_chars = 1;
            
            // Lo mísmo que en la línea 101
            if ($current < $next)
                $order = 1;
            if ($current > $next)
                $order = -1;
            if ($current == $next)
                $range_start = $num_range_chars = 0;
        }
        
        // Comenzar a analizar un rango de carácteres
        if (!$range_start) {
            
            // Agregar carácter a salida
            $output.= $text[$char];
            
            // Fijar comienzo del rango de carácteres
            $range_start = $current;
            
            // Marcar carácter que comienza el rango
            ++$num_range_chars;
            
            // Si hay un carácter despues del actual,
            // verificamos si es mayor o menor al actual
            // para fijar el orden: decreciente o ascendente
            // Si el siguiente carácter es el mismo,
            // Reseteamos las variables que marcan un rango
            if ($next) {
                if ($current < $next)
                    $order = 1;
                if ($current > $next)
                    $order = -1;
                if ($current == $next)
                    $range_start = $num_range_chars = 0;
            }
        }
        
        // Pasamos al carácter siguiente
        ++$char;
        
        // Si hemos llegado al final de la cadena,
        // completamos la salida correctamente
        if ($char == $length && $num_range_chars > 2)
            $output.= '-' .$text[$char - 1];
        
    } while ($char < $length);
    
    // Devolver salida de carácteres
    return $output;
}
 
?>
 

¡Saludos!

[Hidek1]

Gracias a todos los que concursaron... ( Y por los que votaron por mi código claro esta )
Espero que se entusiasmen de igual forma para el próximo reto... Porque ahí le pondré más empeño aun...

Saludos y gracias en especial a pateketrueke y a los que organizaron todo esto

[pateketrueke]

Finalmente la encuesta ha cerrado, y los resultados parecen apuntar a Hidek1 como el código mas favorecido...

Esta fue una competencia corta, divertida y realmente educativa. Lo único que me resta decir es: gracias a todos, y por favor... discutamos al respecto para así poder en marcha otros desafíos para la comunidad, que como saben, siempre esta dispuesta a colaborar.

Gracias.

[GatorV]

En efecto fue un buen reto, ahora a ir por el siguiente y buscar lo mejor.

Reto Cerrado