Newsgroup: it.comp.programmare
Titolo: Programma di Sillabazione

Premessa una distinzione delle lettere in 3 categorie:
  V) --> Vocali: a, e, i, o, u, y
  C) --> Consonanti dure: b, c, d, f, g, j, p, q, s, t, v, w, x, z
  L) --> Consonanti liquide: h, l, m, n, r
Visto che:
  C + C uguali: ------> si sillaba
  "S" + qualsiasi lettera: ------> NON si sillaba
  V oppure L + "S": ------> si sillaba
  V oppure L + C + V oppure L: ------> si sillaba
  V oppure L + L + V: ------> si sillaba
vorrei fare spelling usando un trattino "-" divisorio:
"Nati non foste per viver come bruti, ma per seguir virtute e canoscenza"
 diventa:
"Na-ti non fo-ste per vi-ver co-me bru-ti, ma per se-guir vir-tu-te e
ca-no-scen-za"
Grazie.
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

 Grazie.
Non credo di aver capito la domanda: vorresti una RE che ti separi le
sillabe?
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 sillabe?
un codice che sappia dividere, apuunto, le sillabe con un "-".


un codice che sappia dividere, apuunto, le sillabe con un "-".
La richiesta č quanto mai generica. Abbastanza da consentirmi di citare due
moduli Perl: Lingua::IT::Hyphenate e Tex::Hyphen. Il primo si basa su
regole analoghe a quelle che proponevi, il secondo usa l'algoritmo di TeX,
piů complesso ma piů preciso (non c'č la versione per l'italiano, ma č
possibile costruirla sulla base appunto dei pattern TeX (Naturalmente, puoi
anche guardarti l'originale in TeX, se proprio hai voglia di farti del
male).
Ciao.

 un codice che sappia dividere, apuunto, le sillabe con un "-".
Potrei fare lo sforzo di scrivere una RE che soddisfi la tua grammatica, 
ma poi riesci a utilizzare la RE nel tuo contesto ?

   C + C uguali: ------> si sillaba
Questa regola va completata, altrimenti in un programma puoi avere una
sillaba tipo "bb"
Ciao
Oreste


Grazie Oreste delle delucidazioni.


 ma poi riesci a utilizzare la RE nel tuo contesto ?
Sarebbe assai arduo e improbo, cmq, se ti volessi cimentare in tale
cimento non potrei che prenderne atto e ringraziarti.
P.S. Scusa la mia incompetenza ma "RE" sta per...?






 male).
-- 


 P.S. Scusa la mia incompetenza ma "RE" sta per...?
RE = Regular Expression 
trattasi di una funzionalita' utilizzata in ambito Perl e in tutti
programmi di trattamento testi.
mi sembra la cosa piu' ovvia da utilizzare per dividere una parola in
sillabe.


 "incomplete" vedi es. tecnico, che, cmq, dovrebbe essere sillabato come è


Non č + semplice censire le sillabe valide ?


 Non č + semplice censire le sillabe valide ?
Non funzionerebbe.
Se tu definisci la coppia BA come sillaba, funziona in BANANA ma non 
funziona in BANCA.

 > "incomplete" vedi es. tecnico, che, cmq, dovrebbe essere sillabato come è


contengono caratteri non appartenenti alla lingua italiana.
Mi permetto di pubblicare il codice di Lingua::IT:Hyphenate di Aldo
Calpini:
   $_V = "[aeiouàèéìòù]";
   $_C = "[b-df-hj-np-tv-z]";
   sub sillabe {
      my(@words) = split(/[^a-zA-Zàèéìòù'0-9]+/, join(" ", @_)); #'
      my @result = ();
      foreach $word (@words) {
   #DEBUG  print "word $word --> ";
         $word =~ s/($_V)([bcfgptv][lr])/$1=$2/gi;
         $word =~ s/($_V)([cg]h)/$1=$2/gi;     
         $word =~ s/($_V)(gn)/$1=$2/gi;     
         $word =~ s/($_C)\1/$1=$1/gi;
         $word =~ s/(s$_C)/=$1/gi;
         1 while $word =~ s/($_V*$_C+$_V+)($_C$_V)/$1=$2/gi;
         1 while $word =~ s/($_V*$_C+$_V+$_C)($_C)/$1=$2/gi;
         $word =~ s/^($_V+$_C)($_C)/$1=$2/gi;
         $word =~ s/^($_V+)($_C$_V)/$1=$2/gi;
         $word =~ s/^=//;
         $word =~ s/=$//;
         $word =~ s/=+/=/g;
   #DEBUG  print "$word\n";
         push(@result, split(/=/, $word));
      }
      return @result;
   }
(E' come gli stereogrammi: bisogna fissarlo a lungo, rilassati e senza
pensare a nulla, e pian piano l'immagine di quello che fa si forma da sé.)
L'approccio, come riconosciuto dallo stesso autore, è un po' semplicistico,
ma produce già una sillabazione abbastanza buona, cioè non completa, ma
sostanzialmente corretta.
Non conosco in dettaglio l'algoritmo utilizzato da TeX (adottato anche da
Lout), ma so che si tratta di un algoritmo generico, che utilizza una serie
di pattern (ed eccezioni) differenti per ogni lingua. Il pacchetto per
l'italiano, prodotto da Claudio Beccari, consiste in circa 400 pattern,
senza eccezioni.
Ciao.

Dopo aver letto il tuo post ho avuto qualche dubbio, ma poi ci ho
studiato sopra e posso dire che una regexp è sufficiente.
Di seguito il codice in javascript, ho effettuato dei test, ma se fate
qualche test anche voi sarebbe meglio.
Le regole sono esattamente quelle indicate dal post di apertura con i
limiti che quelle regole impongono, con buona volontà si possono
completare.
Attenzione! Valuta una parola per volta, quindi non inserite più di
una parola, dopo le prove preliminari si può sviluppare per testi
interi.
Se avete difficoltà lo inserisco una pagina web specifica nel mio
sito.
Ciao
Oreste
------------------------------------------------------------------------------------------------------------------
file html
------------------------------------------------------------------------------------------------------------------
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"
http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd
">
<html xmlns="
http://www.w3.org/1999/xhtml
" xml:lang="en" lang="en">
<head>
<title>Sillabe</title>
<meta name="Author" content="Oreste Parlatano 
www.oreste.parlatano.com
"
/>
<meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
<script language="JavaScript" src="sillabe.js"></script>
</head>
<body>
<button onClick="JavaScript:sillabe();">Sillabe</button>
&nbsp;&nbsp;&nbsp;&nbsp;
Entrata <input type="text" id="entrata" size="30" value="" />
</body>
</html>
------------------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------------------
file js
------------------------------------------------------------------------------------------------------------------
function funz(){
return arguments[0]+'-';
}
function sillabe(){
var pattern =
/[aeiouy](?=(s))|[hlmnr](?=(s))|[bcdfgjpqrstvwz](?=([bcdfgjpqrstvwz]))|[aeiouy](?=([bcdfgjpqrstvwz])([aeiouy]))|[hlmnr](?=([bcdfgjpqrstvwz])([aeiouy]))|[aeiouy](?=([bcdfgjpqrstvwz])([hlmnr]))|[hlmnr](?=([bcdfgjpqrstvwz])([hlmnr]))|[aeiouy](?=([hlmnr])([aeiouy]))|[hlmnr](?=([hlmnr])([aeiouy]))/gi;
var oparola = document.getElementById('entrata');
var parola = oparola.value;
alert(parola.replace(pattern,funz));
}
------------------------------------------------------------------------------------------------------------------


 qualche test anche voi sarebbe meglio.
C'è qualche problema con la 's'
pistola pi-s-to-la
stocastico s-to-ca-s-ti-co

l'unica regola che non ho inserito è "s + qualsiasi lettera: ------>
NON si sillaba"
se ho tempo la inserisco oggi stesso, quando si lavora con una regexp
ti va facilmente insieme la vista.
La regola non inserita è l'unica che prevede una negazione, ci devo
pensare qualche minuto.
Grazie
Oreste


Ho provato ma la regola "s + qualsiasi lettera: ------> NON si sillaba"
entra in contraddizione con le altre regole.
Se l'autore del post ha voglia di rivedere le regole possiamo risolvere
il problema, purtroppo non ho abbastanza tempo per l'impostazione delle
regole e i grafi, per il momento posso solo tradurre in codice regole
già stabilite.
Ciao
Oreste


completare.
In particolare sembra che ci sia qualcosa di strano nei gruppi di
consonanti.
Confrontandone il risultato su alcune parole con quello di
Lingua::IT::Hyphenate di Aldo Calpini:
                 sillabe.js        Lingua::IT::Hyphenate
    ------------ ----------------  ---------------------
    parliamone   pa-r-lia-mo-ne    par-lia-mo-ne
    discussione  di-s-cu-s-sio-ne  di-scus-sio-ne
    passaggio    pa-s-sag-gio      pas-sag-gio
    finestra     fi-ne-s-t-ra      fi-ne-stra
quest'ultimo sembra decisamente più prossimo alla sillabazione che
siamo abituati a considerare corretta.
Ciao.

entra in contraddizione con le altre regole.
Questo è uno dei motivi per cui ostinarsi ad usare un'unica
espressione regolare non è una grande idea. Le regole, più che essere
in contraddizione, hanno delle priorità reciproche, che si controllano
meglio con espressioni distinte.
La regola, comunque, è espressa meglio da "s + consonante va a capo:
$word =~ s/(s$_C)/=$1/gi;", piuttosto che da "s + qualsiasi lettera:
------> NON si sillaba".
Ciao.

Devi fare uno sforzo e scomporla, le espressioni regolari sono così.
Se non hai la capacità di riconoscerla come spressione regolare puoi
solo prendertela con te stesso.
Ti assicuro che nel lavoro a me non piace scommettere, lascio queste
pratiche ad altre persone.
Ci sono molti tutorial sulle regexp in rete, puoi aprofittarne.


Ci sono molti tutorial sulle regexp in rete, puoi aprofittarne.
Grazie, ma lavoro con le espressioni regolari da quasi quindici anni, e
ritengo di avere imparato al proposito tutto quello che mi serve.
Ciao.

,
scriveva:
Queste sottoespressione:
  [bcdfgjpqrstvwz](?=([bcdfgjpqrstvwz]))
NON traduce la regola "C + C UGUALI: ------> si sillaba".
Bisogna ricorrere semmai a qualcosa del genere:
   [b-df-hj-np-tv-z](?=\1)
Ciao.

Condivido il tuo ultimo intervento ed in effetti non avevo compreso a
pieno il tuo intervento precedente.
Senza nulla togliere a :IT:Hyphenate di Aldo Calpini che trovo oltre
che utile anche "bello" dal punto di vista stilistico del codice, lo
sforzo fatto nella ricerca di un'unica regexp è dovuto  al tempo
stesso ad una approfondita ricerca del funzionamento delle regexp e ad
un esercizio intellettuale. Lo stimolo da te dato, grazie al tuo post,
mi ha permette, entro certi limiti, di verificare l'idea di partenza
che con una sola regexp è possibile arrivare a dei risultati
interessanti, che poi possono essere sviluppati o no, dipende
dall'interesse specifico sull'argomento di chi interviene.
Solo a titolo di esempio, ricordo in un post interessante nel quale si
mostrava una sola regexp per calcolare le date tenendo conto dei giorni
del mese e degli anni bisestili.
In alcuni casi regexp per così dire "complicate" aiutano a risparmiare
parecchie righe di codice.
In pratica la ricerca di una routine di sillabazione diventa un punto
di partenza per lo studio delle regexp ma con un obiettivo preciso.
Fermo restando è consuetudine sviluppare un codice che non usa regexp.
Le discussioni accendono "scintille" che sono sempre utili perchè
obbligano a pensare.
Al fine di approfondire l'argomento ho aperto un post nel gruppo
it.cultura.linguistica.italiano ed ho ricevuto dei documenti
interessanti (
http://groups.google.com/group/it.cultura.linguistica.italiano/browse_thread/thread/c33aaf636260ad90/?hl=en#
) nei ritagli di tempo studierò bene la documentazione.
Perdona la mia risposta precedente un pò "acida"
Un caro saluto
Oreste


Le regole di partenza che ho usato sono le seguenti:
var V = '[aeiouy]';
var C = '[bcdfgjpqrstvwz]';
var L = '[hlmnr]';
var a01 = /[aeiouy](?=(s))/gi;						// V s
var a02 = /[hlmnr](?=(s))/gi;						// L s
var a03 = /[bcdfgjpqrstvwz](?=([bcdfgjpqrstvwz]))/gi;		// C C
var a04 = /[aeiouy](?=([bcdfgjpqrstvwz])([aeiouy]))/gi;		// VCV
var a05 = /[hlmnr](?=([bcdfgjpqrstvwz])([aeiouy]))/gi;		// LCV
var a06 = /[aeiouy](?=([bcdfgjpqrstvwz])([hlmnr]))/gi;		// VCL
var a07 = /[hlmnr](?=([bcdfgjpqrstvwz])([hlmnr]))/gi;		// LCL
var a08 = /[aeiouy](?=([hlmnr])([aeiouy]))/gi;			// VLV
var a09 = /[hlmnr](?=([hlmnr])([aeiouy]))/gi;			// LLV
nei commenti:
s = consonante "s"
LCV in accordo alle indicazioni del primo post con l'interpretazione
"si sillaba" = "è una sillaba"
dove però ci sono delle contraddizioni:
"S" + qualsiasi lettera: ------> NON si sillaba
contraddice
V oppure L + C + V oppure L: ------> si sillaba
non perchè sia errato, ma perchè la definizione è incompleta
inoltre
C + C uguali: ------> si sillaba
è incompleta perchè ci vuole anche una vocale
Nel tuo esempio l'indicazione speciale /1 si deve riferire all'ultima
parentesi tonda, cioè un elemento in memoria, ma non vedo
quest'ultima.
Ciao
Oreste










Un caro saluto
Oreste


quest'ultima.
Infatti dovrebbe essere "([b-df-hj-np-tv-z])(?=\1)", almeno cosě funziona
come espressione isolata, perň non so se possa avere effetti collaterali
sull'espressione complessiva, non ho avuto tempo di verificare.
La "var a03 = /[bcdfgjpqrstvwz](?=([bcdfgjpqrstvwz]))/gi;" sillaba tra due
consonanti qualsiasi, anche non uguali (sospetto sia questa regola che
produce la divisione scorretta fi-ne-s-t-ra, anche se non ho controllato).
Per dividere fra due consonanti uguali, bisogna necessariamente riferirsi
ad una sottostringa catturata dal match (backreference). Come farlo
correttamente, all'interno del sistema scelto, non saprei dire.
Ciao.

 correttamente, all'interno del sistema scelto, non saprei dire.
credo che sia la strada giusta, anche se sospetto che si debba avere un
insieme di consonanti senza la s che appare essere un caso a sè e
quindi trattarlo con regole separate rispetto alle altre consonanti,
vale a dire [bcdfgjpqrtvwz] invece di [bcdfgjpqrstvwz]
la regexp:
/[bcdfglmnpqrstvz](?=([bcdfglmnpqrstvz]))/gi;
da sola funziona
ma nel contesto si contraddice:
/[bcdfglmnpqrstvz](?=([bcdfglmnpqrstvz]))|[aeiouy](?=(s))|[hlmnr](?=(s))|[bcdfgjpqrstvwz](?=([bcdfgjpqrstvwz]))|[aeiouy](?=([bcdfgjpqrstvwz])([aeiouy]))|[hlmnr](?=([bcdfgjpqrstvwz])([aeiouy]))|[aeiouy](?=([bcdfgjpqrstvwz])([hlmnr]))|[hlmnr](?=([bcdfgjpqrstvwz])([hlmnr]))|[aeiouy](?=([hlmnr])([aeiouy]))|[hlmnr](?=([hlmnr])([aeiouy]))/gi;
qui sembra che vi voglia una seconda regexp :)
Ciao
Oreste

potete vedere un primo draft al seguente indirizzo:
www.oreste.parlatano.com/sillabe/sillabe.html
aiutatemi a capire se funziona, sembra di si, ma ho l'impressione che
manchi qualcosa.
Ciao 
Oreste