Espressione regolare per cercare Gadaffi

Sto cercando di cercare la parola Gadaffi. Qual è la migliore espressione regolare per cercarla?

Il mio miglior tentativo finora è:

\b[KG]h?add?af?fi$\b

Ma mi sembrano ancora mancare alcune riviste. Eventuali suggerimenti?

Aggiornamento: ho trovato un elenco piuttosto ampio qui: http://blogs.abcnews.com/theworldnewser/2009/09/how-many-different-ways-can-you-spell-gaddafi.html

La risposta di seguito corrisponde a tutte le 30 varianti:

Gheddafi
Gheddafi
Gheddafi
Gheddafi
Gaddafy
Gaddhafi
Gheddafi
Gheddafi
Gheddafi
Gheddafi
Gheddafi
Ghaddafy
Gheddafi
Kadaffi
Kadafi
Gheddafi
Gheddafi
Kazzafi
Khadaffy
Gheddafi
Gheddafi
Qadafi
Gheddafi
Gheddafi
Gheddafi
Qadthafi
Qathafi
Quathafi
Qudhafi
Kad'afi

\b[KGQ]h?add?h?af?fi\b

La trascrizione araba è (dice Wiki) "Qaḏḏāfī", quindi forse aggiungendo una Q. E una H ("Gheddafi", come menziona l'articolo (vedi sotto)).

A proposito, perché c'è un $alla fine della regex?

A proposito, bell'articolo sull'argomento:

Gheddafi, Gheddafi o Gheddafi? Perché il nome del leader libico è scritto in così tanti modi diversi? .

MODIFICARE

Per abbinare tutti i nomi nell'articolo che hai citato in seguito , questo dovrebbe corrispondere a tutti. Speriamo solo che non corrisponda a molte altre cose: D

\b(Kh?|Gh?|Qu?)[aeu](d['dt]?|t|zz|dhd)h?aff?[iy]\b

Facile ... (Qadaffi|Khadafy|Qadafi|... )... è auto-documentato, gestibile e supponendo che il tuo motore regexp compili effettivamente espressioni regolari (piuttosto che interpretarle), verrà compilato nello stesso DFA che una soluzione più offuscata.

Scrivere espressioni regolari compatte è come usare nomi di variabili brevi per velocizzare un programma. Aiuta solo se il tuo compilatore è morto nel cervello.

Una cosa interessante da notare dal tuo elenco di potenziali ortografia è che ci sono solo 3 valori Soundex per l'elenco contenuto (se ignori il 'Kazzafi' anomalo)

G310, K310, Q310

Ora, ci sono falsi positivi lì dentro ('Godby' è anche G310), ma combinando anche i colpi limitati del metafono, puoi eliminarli.

<?
$soundexMatch = array('G310','K310','Q310');
$metaphoneMatch = array('KTF','KTHF','FTF','KHTF','K0F');

$text = "This is a big glob of text about Mr. Gaddafi. Even using compound-Khadafy terms in here, then we might find Mr Qudhafi to be matched fairly well. For example even with apostrophes sprinkled randomly like in Kad'afi, you won't find false positives matched like godfrey, or godby, or even kabbadi";

$wordArray = preg_split('/[\s,.;-]+/',$text);
foreach ($wordArray as $item){
    $rate = in_array(soundex($item),$soundexMatch) + in_array(metaphone($item),$metaphoneMatch);
    if ($rate > 1){
        $matches[] = $item;
    }
}
$pattern = implode("|",$matches);
$text = preg_replace("/($pattern)/","<b>$1</b>",$text);
echo $text;
?>

Alcune modifiche, e diciamo un po 'di traslitterazione cirillica, e avrai una soluzione abbastanza robusta.

Utilizzando il modulo CPAN Regexp :: Assemble :

#!/usr/bin/env perl

use Regexp::Assemble;

my $ra = Regexp::Assemble->new;
$ra->add($_) for qw(Gadaffi Gadafi Gadafy Gaddafi Gaddafy
                    Gaddhafi Gadhafi Gathafi Ghadaffi Ghadafi
                    Ghaddafi Ghaddafy Gheddafi Kadaffi Kadafi
                    Kaddafi Kadhafi Kazzafi Khadaffy Khadafy
                    Khaddafi Qadafi Qaddafi Qadhafi Qadhdhafi
                    Qadthafi Qathafi Quathafi Qudhafi Kad'afi);
say $ra->re;

Questo produce la seguente espressione regolare:

(?-xism:(?:G(?:a(?:d(?:d(?:af[iy]|hafi)|af(?:f?i|y)|hafi)|thafi)|h(?:ad(?:daf[iy]|af?fi)|eddafi))|K(?:a(?:d(?:['dh]a|af?)|zza)fi|had(?:af?fy|dafi))|Q(?:a(?:d(?:(?:(?:hd)?|t)h|d)?|th)|u(?:at|d)h)afi))

Penso che tu stia complicando le cose qui. Il regex corretto è semplice come:

\u0627\u0644\u0642\u0630\u0627\u0641\u064a

Corrisponde alla concatenazione dei sette punti del codice Unicode arabo che formano la parola القذافي (cioè Gadaffi).

Se vuoi evitare di abbinare cose che nessuno ha usato (cioè evitare di tendere verso ". +") Il tuo approccio migliore sarebbe quello di creare un'espressione regolare che sia solo tutte le alternative (es. (Qadafi | Kadafi | ...) ) quindi compilarlo in un DFA, quindi riconvertire il DFA in un'espressione regolare. Supponendo un'implementazione moderatamente ragionevole che ti darebbe un'espressione regolare "compressa" che è garantita per non contenere varianti impreviste.

Se hai un elenco concreto di tutte e 30 le possibilità, concatenale tutte insieme con un gruppo di "ors". Quindi puoi essere sicuro che corrisponde solo alle cose esatte che hai elencato e non di più. Il tuo motore RE sarà probabilmente in grado di ottimizzare ulteriormente, e, beh, con 30 scelte anche se non lo è, non è ancora un grosso problema. Cercare di armeggiare trasformandolo manualmente in un RE "intelligente" non può andare meglio e può andare peggio.

(G|Gh|K|Kh|Q|Qh|Q|Qu)(a|au|e|u)(dh|zz|th|d|dd)(dh|th|a|ha|)(\x27|)(a|)(ff|f)(i|y)

Certamente non la versione più ottimizzata, divisa in sillabe per massimizzare le partite mentre proviamo ad assicurarci di non avere falsi positivi.

Bene, poiché stai abbinando le parole piccole, perché non provi un motore di ricerca di somiglianza con la distanza di Levenshtein ? Puoi consentire al massimo k inserimenti o eliminazioni. In questo modo è possibile modificare la funzione di distanza su altre cose che funzionano meglio per il problema specifico. Ci sono molte funzioni disponibili nella libreria simMetrics.

Una possibile alternativa è lo strumento online per generare espressioni regolari dagli esempi http://regex.inginf.units.it . Dagli Una possibilità!

Perché non seguire un approccio misto? Qualcosa tra un elenco di tutte le possibilità e un complicato Regex che corrisponde troppo.

Regex riguarda la corrispondenza dei motivi e non riesco a vedere un motivo per tutte le varianti nell'elenco. Provando a farlo, troverai anche cose come "Gazzafy" o "Quud'haffi" che molto probabilmente non sono una variante usata e sicuramente non nella lista.

Ma posso vedere modelli per alcune delle varianti, e così ho finito con questo:

\b(?:Gheddafi|Gathafi|Kazzafi|Kad'afi|Qadhdhafi|Qadthafi|Qudhafi|Qu?athafi|[KG]h?add?h?aff?[iy]|Qad[dh]?afi)\b

All'inizio elencherò quelli in cui non riesco a vedere uno schema, quindi seguo alcune varianti in cui ci sono schemi.

Guardalo qui su www.rubular.com

So che questa è una vecchia domanda, ma ...

Nessuna di queste due regex è la più bella, ma sono ottimizzate ed entrambe corrispondono a TUTTE le varianti del post originale.

"Little Beauty" # 1

(?:G(?:a(?:d(?:d(?:af[iy]|hafi)|af(?:f?i|y)|hafi)|thafi)|h(?:ad(?:daf[iy]|af?fi)|eddafi))|K(?:a(?:d(?:['dh]a|af?)|zza)fi|had(?:af?fy|dafi))|Q(?:a(?:d(?:(?:(?:hd)?|t)h|d)?|th)|u(?:at|d)h)afi)

"Little Beauty" # 2

(?:(?:Gh|[GK])adaff|(?:(?:Gh|[GKQ])ad|(?:Ghe|(?:[GK]h|[GKQ])a)dd|(?:Gadd|(?:[GKQ]a|Q(?:adh|u))d|(?:Qad|(?:Qu|[GQ])a)t)h|Ka(?:zz|d'))af)i|(?:Khadaff|(?:(?:Kh|G)ad|Gh?add)af)y

Riposa in pace, Muammar.

Solo un addendum: dovresti aggiungere "Gheddafi" come ortografia alternativa. Quindi l'IR dovrebbe essere

\b[KG]h?[ae]dd?af?fi$\b

[GQK] [CTA] + [dtez] + \ '[adhz] + f {1,2} (i | y)?

In parti:

• [GQK]
• + [Ahu]
• + [Dtez]
• \ '?
• [Adhz] +
• f {1,2} (i | y)

_{Nota: volevo solo provare.}

Cos'altro inizia con Q, G o K, ha annuncio, z o t nel mezzo e termina in "fi" che le persone effettivamente cercano?

/\b[GQK].+[dzt].+fi\b/i

Fatto.

>>> print re.search(a, "Gadasadasfiasdas") != None
False
>>> print re.search(a, "Gadasadasfi") != None
True
>>> print re.search(a, "Qa'dafi") != None
True

Interessante il fatto che mi sto sottovalutando. Qualcuno può lasciare alcuni falsi positivi nei commenti?