Script inteligente que aplique tildes

[derkenuke]

Bueno, en principio creo que me contentare con separar las silabas de una palabra, que ya lo veo demasiado complicado por si mismo.

He realizado un esbozo, que todavia tiene fallos, pero bueno, puede resultar comodo para guiar el proyecto. De momento solo me he basado en dos reglas:

two consecutive consonants are assigned to separate syllables (e.g. [al.go] algo ‘something’,
[ven.ta] venta ‘sale’, [lis.to] listo ‘clever’), except in the case of /p, t, k, b, d, g, f/ + liquid
(e.g. [ha.blo] hablo ‘I speak’, [sue.gra] suegra ‘mother-in-law’).

a single consonant between vowels is syllable-initial (e.g. [pa.ta.ta] patata ‘potato’)

pero el script esta dando resultados.

Esta mas o menos comentado, y he hecho uso de las expresiones regulares porque me gusta su potencia, y ya las controlo un poquito.

He aqui el codigo:

Código PHP:

  var palabras=[ "gallo", "feo", "triangulo", "suegra", "hablo", "lombriz", "helicoptero", "patata", "palabra"];
 
String.prototype.esVocal=function() {
    return this.match(/^[aeiou]$/i)!=null;
}
 
function silabear(pal) {
    /* 
     un argumento de dos letras o de tres letras sera siempre monosilabo
    */
    if(pal.length==2 || pal.length==3) {
        return pal;
    }
    
    //inicializamos _v y _c que nos serviran para formar las expresiones regulares de vocal y consonante
    // a partir de aqui a una vocal se le llamara "v" y a una consonante "c"
    var _v="[aeiou]"; var _c="[^aeiou]";
    var v=new RegExp(_v,"gi"); var c=new RegExp(_c,"gi");
    
    
    /*
     two consecutive consonants are assigned to separate syllables (e.g. [al.go] algo ‘something’, 
     [ven.ta] venta ‘sale’, [lis.to] listo ‘clever’), except in the case of /p, t, k, b, d, g, f/ + liquid 
     (e.g. [ha.blo] hablo ‘I speak’, [sue.gra] suegra ‘mother-in-law’).
    */
    // a las consonantes excepciones (/p, t, k, b, d, g, f/) las llamaremos cexcep
    var c_c=new RegExp("([^aeiouptkbdgf])([^aeiou])","i");        // c+c (pero que la primera c no sea excepcion )
    if( p=pal.match( c_c ) ) {    // cumple c_c, y p[1] y p[2] guardaran las dos consonantes matcheadas
        q=pal.search(c_c);            // posicion exacta del matching de c_c
        if(p[1]!=p[2]) {                    // la c no es doble (rr,ll..)
            parte1=pal.substring(0,q+1);
            parte2=pal.substring(q+1);
        }
        else {                                // la c es doble (rr,ll);
            parte1=pal.substring(0,q);
            parte2=pal.substring(q);
        }
        return [ silabear(parte1) , silabear(parte2) ];
    }
    else {                            // no cumple c_c, pero puede que sea por la excepcion
        var c_cexcep=new RegExp("([ptkbdgf])([^aeiou])","i");
        // aqui no hace falta hacer un match, no nos interesan las consonantes en si, solo su posicion
        var p=pal.search(c_cexcep);
        if( p>0 ) {
            parte1=pal.substring(0,p);
            parte2=pal.substring(p);
            return [ silabear(parte1) , silabear(parte2) ];
        }
    }
    
    
    /*
     a single consonant between vowels is syllable-initial (e.g. [pa.ta.ta] patata ‘potato’)
    */
    //asi que miraremos cada consonante de la palabra, una por una
    var consonantes=pal.match(c);
    //miramos si se cumple el esquema v+c+v, por cada c que encontremos
    //la primera c no la miramos, porque no puede estar rodeada de vocales
    for(var a=1;a<consonantes.length;a++) {
        q=pal.search( consonantes[a] );            //posicion exacta de la consonante
        if( pal.charAt(q-1).esVocal() && pal.charAt(q+1).esVocal() ) {        //rodeada de vocales
            parte1=pal.substring(0,q);
            parte2=pal.substring(q);
            return [ silabear(parte1), silabear(parte2) ];
        }
    }
    
    /*
     devolver el resto de la palabra si no ha de ser procesada
    */
    return pal;
    
}
 
for(a=0;a<palabras.length;a++) {
    document.write( palabras[a]+" >>> "+silabear(palabras[a]) +"<br/>");
} 
   

Es una funcion recursiva, que coge una palabra y va mirando la primera regla y la segunda, a ver si tiene la oportunidad de "diseccionar" la palabra. Si consigue hacerlo, coge las dos partes (no dividira en más partes por cada pasada) y volvera a llamar a la funcion silabear con cada fragmento.

Quizas sea un poco complicado, lo he identado y puesto "bonito" para que asuste menos. El resultado imprimido es:

gallo >>> ga,llo
feo >>> feo
triangulo >>> trian,gu,lo
suegra >>> sue,gra
hablo >>> ha,blo
lombriz >>> lom,briz
helicoptero >>> he,li,co,co
patata >>> pa,tata
palabra >>> pa,la,la

Vemos que todo funciona segun lo previsto, excepto para las tres ultimas palabras. La verdad esque no he encontrado exactamente el error, osea que si alguien lo ve, por favor que lo comente. "Helicoptero" y "palabra" comparten los mismos fallos. "Patata" no, y no se qué le ocurre.

Voy a hacer un debug del codigo a ver si consigo dar con ello.

En cuanto tenga esta base firme, podre ponerme con palabra mas complejas con diptongos, triptongos, y esas cosas.

Iniciado por Hereje

es conveniente escribir bien.

El proyecto en sí no lo presento como método industrial de corrección, si no mas bien de investigación y con fines didacticos.

Iniciado por occiso

De todas maneras hay palabras que se acentuan según su significado en la frase (por ejemplo más y mas) y eso si que es imposible controlar por el lenguaje: el significado de la frase.

Por eso por mucho que lo intenten es imposible que se haga algo que sea minimamente fiable.

A lo que respondo

Iniciado por derkeNuke

(exceptuando claro, las diferencias entre este y éste , y esas reglas semánticas)

Lo de hacer un programa que entienda... enfin... quizas en otra vida :D



Saludos a los dos y gracias por responder!