Bu cevaplayamadığım bir röportaj sorusuydu:
Düzenli ifadeler kullanan bir dizenin bir palindrom olup olmadığı nasıl kontrol edilir?
ps " Verilen dizenin palindrome olup olmadığı nasıl kontrol edilir? " sorusu zaten var ve farklı dillerde birçok yanıt veriyor, ancak normal ifadeleri kullanan bir yanıt yok.
Yanıtlar:
Bu sorunun cevabı "imkansız" dır. Daha spesifik olarak, görüşmeci hesaplama teorisi dersinize dikkat edip etmediğinizi merak ediyor.
Hesaplama teorisi sınıfınızda sonlu durum makinelerini öğrendiniz. Sonlu durum makinesi, düğümlerden ve kenarlardan oluşur. Her kenar, sonlu bir alfabeden bir harfle notlandırılmıştır. Bir veya daha fazla düğüm özel "kabul eden" düğümlerdir ve bir düğüm "başlangıç" düğümüdür. Her harf belirli bir kelimeden okundukça, makinede verilen kenarı geçiyoruz. Kabul etme durumuna gelirsek, makinenin bu kelimeyi "kabul ettiğini" söyleriz.
Normal bir ifade her zaman eşdeğer bir sonlu durum makinesine çevrilebilir. Yani, normal ifadeyle aynı kelimeleri kabul eden ve reddeden bir kelime (gerçek dünyada, bazı normal ifade dilleri rastgele işlevlere izin verir, bunlar sayılmaz).
Tüm palindromları kabul eden bir sonlu durum makinesi inşa etmek imkansızdır. Kanıt, keyfi olarak çok sayıda düğüm gerektiren bir dizeyi kolayca oluşturabileceğimiz gerçeklerine, yani dizeye dayanır.
a ^ xba ^ x (ör., aba, aabaa, aaabaaa, aaaabaaaa, ....)
burada a ^ x, x kez tekrarlanan bir sayıdır. Bu, en az x düğüm gerektirir, çünkü 'b'yi gördükten sonra, onun bir palindrom olduğundan emin olmak için x kez geri saymamız gerekir.
Son olarak, orijinal soruya geri dönersek, görüşmeciye bazı sabit uzunluklardan daha küçük olan tüm palindromları kabul eden normal bir ifade yazabileceğinizi söyleyebilirsiniz. Palindromların tanımlanmasını gerektiren bir gerçek dünya uygulaması varsa, o zaman neredeyse kesinlikle keyfi olarak uzun olanları içermeyecektir, bu nedenle bu cevap, teorik imkansızlıkları gerçek dünya uygulamalarından ayırt edebileceğinizi gösterecektir. Yine de, gerçek normal ifade, eşdeğer 4 satırlık programdan çok daha uzun olacaktır (okuyucu için kolay alıştırma: palindromları tanımlayan bir program yazın).
>=1.9) burada
İken PCRE motor desteği özyinelemeli düzenli ifadeler yapar (bkz Peter Krauss tarafından cevap üzerinde bir normal ifadeler kullanabilirsiniz edemez) YBÜ (Apple tarafından örneğin kullanıldığı gibi) ekstra kod olmadan bunu başarmak için motor. Bunun gibi bir şey yapmanız gerekecek:
Bu, herhangi bir palindromu algılar, ancak bir döngü gerektirir (normal ifadeler sayılamayacağı için gerekli olacaktır).
$a = "teststring";
while(length $a > 1)
{
$a =~ /(.)(.*)(.)/;
die "Not a palindrome: $a" unless $1 eq $3;
$a = $2;
}
print "Palindrome";
Bu mümkün değil. Palindromlar normal bir dille tanımlanmaz. (Bakın, hesaplama teorisinde bir şeyler öğrenmiştim)
Perl regex ile:
/^((.)(?1)\2|.?)$/
Yine de, birçok kişinin de belirttiği gibi, katı olmak istiyorsanız, bu normal bir ifade olarak kabul edilemez. Normal ifadeler özyinelemeyi desteklemez.
/udeğiştirici ekleyin ) veya birleştirici karakterler nedeniyle. ( kaçış dizisi. ile değiştirin ). \X
abababa. PCRE tabanlı regex motorlarını kullanırken her girdi için özyineleme ile çalışması mümkün değildir. Casimirs regex, yineleme ve değişken durumu kullanarak farklı bir yaklaşım kullanır ve oldukça etkileyicidir.
İşte karakterin her tür için: (senet örn) 4 harfli palindrom algılamak için: biri
\(.\)\(.\)\2\1
İşte 5 harfli palindromları (örneğin: radar) algılayarak yalnızca harfleri kontrol etmek için:
\([a-z]\)\([a-z]\)[a-z]\2\1
Bu nedenle, her olası kelime uzunluğu için farklı bir normal ifadeye ihtiyacımız var gibi görünüyor. Bir Python posta listesindeki bu gönderi , nedeniyle ilgili bazı ayrıntılar içerir (Sonlu Durum Otomatı ve pompalama lemması).
Kendine ne kadar güvendiğine bağlı olarak şu cevabı verirdim:
Bunu düzenli bir ifade ile yapmazdım. Normal ifadelerin uygun bir kullanımı değildir.
StackOverflow gibi cevaplar doludur "hayır, bunu desteklemez? Düzenli ifadeleri. Onlar olamaz destekliyorum.".
Gerçek şu ki, normal ifadelerin artık normal gramerlerle ilgisi yok. Modern düzenli ifadeler, özyineleme ve dengeleme grupları gibi işlevler içerir ve uygulamalarının kullanılabilirliği giderek artmaktadır (örneğin, buradaki Ruby örneklerine bakın). Benim fikrime göre, alanımızdaki düzenli ifadelerin bir programlama kavramından başka bir şey olmadığı şeklindeki eski inanca bağlı kalmak, sadece ters etki yapar. Artık en uygun olmayan seçim kelimesi için onlardan nefret etmek yerine, bir şeyleri kabul etme ve devam etme zamanı.
İşte Perl'in yaratıcısı Larry Wall'dan bir alıntı :
(…) Genel olarak, gerçek düzenli ifadelerle yalnızca marjinal olarak ilişkili olan "düzenli ifadeler" dediğimiz şeylerle ilgili olmak zorunda. Yine de terim, kalıp eşleştirme motorlarımızın yetenekleriyle büyüdü, bu yüzden burada dilsel gereklilikle savaşmaya çalışmayacağım. Ancak ben bunlara genellikle "normal ifadeler" (veya Anglo-Sakson modundayken "regexen") diyeceğim.
Ve burada bir var blog yazısı ile PHP'nin çekirdek geliştiricilerinden biri :
Makale oldukça uzun olduğu için, işte ana noktaların bir özeti:
- Programcılar tarafından kullanılan "düzenli ifadeler", biçimsel dil teorisi bağlamında orijinal düzenlilik kavramıyla çok az ortak noktaya sahiptir.
- Normal ifadeler (en azından PCRE) bağlamdan bağımsız tüm dillerle eşleşebilir. Bu nedenle, iyi biçimlendirilmiş HTML ve hemen hemen tüm diğer programlama dilleriyle eşleşebilirler.
- Normal ifadeler, en azından bazı bağlama duyarlı dillerle eşleşebilir.
- Normal ifadelerin eşleştirilmesi NP tamamlandı. Bu nedenle, normal ifadeleri kullanarak diğer herhangi bir NP problemini çözebilirsiniz.
Bununla birlikte, palindromları bunu kullanarak normal ifadelerle eşleştirebilirsiniz:
^(?'letter'[a-z])+[a-z]?(?:\k'letter'(?'-letter'))+(?(letter)(?!))$
... belli ki normal gramerlerle ilgisi yok.
Daha fazla bilgi burada: http://www.regular-expressions.info/balancing.html
Artık Perl'de yapılabilir. Özyinelemeli referans kullanma:
if($istr =~ /^((\w)(?1)\g{-1}|\w?)$/){
print $istr," is palindrome\n";
}
son kısma göre değiştirildi http://perldoc.perl.org/perlretut.html
Ruby'de adlandırılmış yakalama gruplarını kullanabilirsiniz. yani böyle bir şey işe yarayacak -
def palindrome?(string)
$1 if string =~ /\A(?<p>| \w | (?: (?<l>\w) \g<p> \k<l+0> ))\z/x
end
deneyin, işe yarıyor ...
1.9.2p290 :017 > palindrome?("racecar")
=> "racecar"
1.9.2p290 :018 > palindrome?("kayak")
=> "kayak"
1.9.2p290 :019 > palindrome?("woahitworks!")
=> nil
Normal ifadeler yerine dize manipülasyonu ile yapmak aslında daha kolaydır:
bool isPalindrome(String s1)
{
String s2 = s1.reverse;
return s2 == s1;
}
Bunun röportaj sorusuna gerçekten cevap vermediğini anlıyorum, ancak bunu bir görevi yerine getirmenin daha iyi bir yolunu nasıl bildiğinizi göstermek için kullanabilirsiniz ve her sorunu bir çivi olarak gören tipik "çekiçli" bir kişi değilsiniz . "
İşte Regex Golf'ün 5. seviyesi (Bir adam, bir plan) için cevabım . Tarayıcının Normal İfadesi ile 7 karaktere kadar çalışır (Chrome 36.0.1985.143 kullanıyorum).
^(.)(.)(?:(.).?\3?)?\2\1$
İşte 9 karaktere kadar bir tane
^(.)(.)(?:(.)(?:(.).?\4?)?\3?)?\2\1$
Çalışacağı maksimum karakter sayısını artırmak için, tekrar tekrar değiştirirsiniz . ile (?: (.).? \ n?)? .
Palindrom içeren bir dizeyi tespit etmek için çok basit ve apaçık bir algoritma:
(\w)(?:(?R)|\w?)\1
At rexegg.com/regex-recursion öğretici nasıl çalıştığını açıklar.
Herhangi bir dilde iyi çalışır, burada kavram kanıtı olarak aynı kaynaktan (bağlantı) uyarlanmış bir örnek, PHP kullanılarak:
$subjects=['dont','o','oo','kook','book','paper','kayak','okonoko','aaaaa','bbbb'];
$pattern='/(\w)(?:(?R)|\w?)\1/';
foreach ($subjects as $sub) {
echo $sub." ".str_repeat('-',15-strlen($sub))."-> ";
if (preg_match($pattern,$sub,$m))
echo $m[0].(($m[0]==$sub)? "! a palindrome!\n": "\n");
else
echo "sorry, no match\n";
}
çıktılar
dont ------------> sorry, no match
o ---------------> sorry, no match
oo --------------> oo! a palindrome!
kook ------------> kook! a palindrome!
book ------------> oo
paper -----------> pap
kayak -----------> kayak! a palindrome!
okonoko ---------> okonoko! a palindrome!
aaaaa -----------> aaaaa! a palindrome!
bbbb ------------> bbb
Normal ifade ^((\w)(?:(?1)|\w?)\2)$ aynı işi yapar, ancak evet / değil yerine "içerir" olarak.
Not: "o" nun bir palimbrom olmadığı, "mümkün-elba" tireli biçimin bir palindrom olmadığı, ancak "mümkünelba" nın olduğu bir tanım kullanıyor. Tanımın adlandırılması 1 .
"O" ve "olası-elba" palindron olduğunda, adlandırma tanımı2 .
Başka bir "palindrom normal ifadeleri" ile karşılaştırıldığında,
^((.)(?:(?1)|.?)\2)$yukarıdaki temel normal ifade, \wkısıtlama olmaksızın , "mümkün-elba" yı kabul eder.
^((.)(?1)?\2|.)$( @LilDevil ) kullanımı definition2 ( "o" ve bu yüzden "aaaaa" ve "BBB" şeritlerinin tanınmasında da farklı "güçlü-elba" kabul eder).
^((.)(?1)\2|.?)$( @Markus ) "kook" veya "bbbb" algılanmadı
NOT: karşılaştırmak $subjectsiçin, karşılaştırılan her normal ifade için için daha fazla kelime ve bir satır ekleyebilirsiniz.
if (preg_match('/^((.)(?:(?1)|.?)\2)$/',$sub)) echo " ...reg_base($sub)!\n";
if (preg_match('/^((.)(?1)?\2|.)$/',$sub)) echo " ...reg2($sub)!\n";
if (preg_match('/^((.)(?1)\2|.?)$/',$sub)) echo " ...reg3($sub)!\n";
if (preg_match('/^((.)(?1)*\2|.?)$/',$sub)) echo " ...reg4($sub)!\n";
^((.)(?:(?1)|.?)\2|(.)\3*)$
PCRE ifadesi ile ilgili olarak (MizardX'ten):
/ ^((.)(?1)\2|.?)$/
Test ettin mi? Win XP Pro altında PHP 5.3'ümde şu hata veriyor: aaaba Aslında, ifade ifadesini okumak için biraz değiştirdim:
/ ^((.)(?1)*\2|.?)$/
Bence dışarıdaki karakter çifti tutturulmuşken, kalan iç karakterlerin değil. Bu tam bir cevap değildir çünkü "aaaba" ve "aabaacaa" 'dan yanlış bir şekilde geçerken, "aabaaca" da doğru şekilde başarısız olur.
Bunun için bir düzeltme olup olmadığını merak ediyorum ve ayrıca Perl örneği (JF Sebastian / Zsolt tarafından) testlerimi doğru bir şekilde geçiyor mu?
Viyana'dan Csaba Gabor
/\A(?<a>|.|(?:(?<b>.)\g<a>\k<b+0>))\z/
Oniguruma motoru için geçerlidir (Ruby'de kullanılır)
Pragmatic Bookshelf'den alındı
Perl'de (ayrıca Zsolt Botykai'nin cevabına bakınız ):
$re = qr/
. # single letter is a palindrome
|
(.) # first letter
(??{ $re })?? # apply recursivly (not interpolated yet)
\1 # last letter
/x;
while(<>) {
chomp;
say if /^$re$/; # print palindromes
}
Bu normal ifade, boşlukları, sekmeleri, virgülleri ve tırnakları yok sayarak 22 karaktere kadar palindromları algılar.
\b(\w)[ \t,'"]*(?:(\w)[ \t,'"]*(?:(\w)[ \t,'"]*(?:(\w)[ \t,'"]*(?:(\w)[ \t,'"]*(?:(\w)[ \t,'"]*(?:(\w)[ \t,'"]*(?:(\w)[ \t,'"]*(?:(\w)[ \t,'"]*(?:(\w)[ \t,'"]*(?:(\w)[ \t,'"]*\11?[ \t,'"]*\10|\10?)[ \t,'"]*\9|\9?)[ \t,'"]*\8|\8?)[ \t,'"]*\7|\7?)[ \t,'"]*\6|\6?)[ \t,'"]*\5|\5?)[ \t,'"]*\4|\4?)[ \t,'"]*\3|\3?)[ \t,'"]*\2|\2?))?[ \t,'"]*\1\b
Onunla burada oynayın: https://regexr.com/4tmui
ZCHudson'un belirttiği gibi, palindrom kümesi normal bir dil olmadığından, bir şeyin palindrom olup olmadığını belirlemek, normal bir regexp ile yapılamaz.
Airsource Ltd'ye , görüşmecinin aradığı türden bir cevap "bu mümkün değil" olduğunu söylediğinde kesinlikle katılmıyorum . Görüşmem sırasında, iyi bir adayla karşılaştığımda, ona yanlış bir şey yapmasını önerdiğimizde doğru argümanı bulup bulamayacağını kontrol etmek için bu tür bir soruya geliyorum. Daha iyisini biliyorsa, bir şeyi yanlış şekilde yapmaya çalışacak birini işe almak istemiyorum.
perl ile yapabileceğiniz bir şey: http://www.perlmonks.org/?node_id=577368
Görüşmeciye, palindromlardan oluşan dilin normal bir dil olmadığını, bunun yerine bağlamdan bağımsız olduğunu açıklardım.
Tüm palindromlarla eşleşen normal ifade sonsuz olacaktır . Bunun yerine, kendisini kabul etmek için maksimum boyutta palindromla sınırlamasını öneririm; veya tüm palindromlara ihtiyaç duyuluyorsa, minimum bir tür NDPA kullanın veya sadece basit dizi ters çevirme / eşittir tekniğini kullanın.
Yakalama grupları tükenmeden önce normal ifadelerle yapabileceğiniz en iyi şey:
/(.?)(.?)(.?)(.?)(.?)(.?)(.?)(.?)(.?).?\9\8\7\6\5\4\3\2\1/
Bu, uzunluğu 19 karaktere kadar olan tüm palindromlarla eşleşecektir.
Tüm uzunluklar için programlı çözümleme önemsizdir:
str == str.reverse ? true : false
Henüz satır içi yorum yapacak temsilcim yok, ancak MizardX tarafından sağlanan ve Csaba tarafından değiştirilen normal ifade, PCRE'de çalışması için daha fazla değiştirilebilir. Bulduğum tek hata, tek karakterli dizedir, ancak bunu ayrı ayrı test edebilirim.
/^((.)(?1)?\2|.)$/
Başka dizelerde başarısız olmasını sağlayabilirseniz, lütfen yorum yapın.
#!/usr/bin/perl
use strict;
use warnings;
print "Enter your string: ";
chop(my $a = scalar(<STDIN>));
my $m = (length($a)+1)/2;
if( (length($a) % 2 != 0 ) or length($a) > 1 ) {
my $r;
foreach (0 ..($m - 2)){
$r .= "(.)";
}
$r .= ".?";
foreach ( my $i = ($m-1); $i > 0; $i-- ) {
$r .= "\\$i";
}
if ( $a =~ /(.)(.).\2\1/ ){
print "$a is a palindrome\n";
}
else {
print "$a not a palindrome\n";
}
exit(1);
}
print "$a not a palindrome\n";
Otomata teorisine göre, herhangi bir uzunluktaki bir paliandromu eşleştirmek imkansızdır (çünkü bu sonsuz miktarda bellek gerektirir). Ancak, Sabit Uzunluktaki Paliandromes ile eşleşmesi MÜMKÜN. <= 5 veya <= 6 vb. Uzunluktaki tüm paliandromlarla eşleşen ancak üst sınırın net olmadığı> = 5 vb. İle eşleşmeyen bir normal ifade yazmanın mümkün olduğunu söyleyin
Ruby'de, \b(?'word'(?'letter'[a-z])\g'word'\k'letter+0'|[a-z])\bpalindrome sözcüklerini eşleştirmek için kullanabilirsiniz a, dad, radar, racecar, and redivider. ps: bu normal ifade yalnızca tek sayıda harf uzunluğunda olan palindrome kelimeleriyle eşleşir.
Bu normal ifadenin radarla nasıl eşleştiğini görelim. Kelime sınırı \ b dizenin başında eşleşir. Normal ifade motoru, yakalama grubu "word" e girer. [az], daha sonra yakalama grubu "harf" için yığında sıfır özyineleme seviyesinde saklanan r ile eşleşir. Şimdi normal ifade motoru "kelime" grubunun ilk özyinelemesine girer. (? 'mektup' [az]), birinci özyineleme düzeyinde a ile eşleşir ve yakalar. Normal ifade, "kelime" grubunun ikinci yinelemesine girer. (? 'mektup' [az]) ikinci özyineleme düzeyinde d'yi yakalar. Sonraki iki özyineleme sırasında, grup üçüncü ve dördüncü seviyelerde a ve r yakalar. Beşinci özyineleme başarısız olur çünkü dizede [az] ile eşleşecek karakter kalmamıştır. Normal ifade motoru geri dönmelidir.
Normal ifade motoru şimdi "kelime" grubu içindeki ikinci alternatifi denemelidir. Normal ifadedeki ikinci [az], dizedeki son r ile eşleşir. Motor şimdi başarılı bir özyinelemeden çıkar ve bir seviye geri üçüncü özyinelemeye gider.
Eşleştirmeden (& word) sonra motor \ k'letter + 0'a ulaşır. Normal ifade motoru zaten konu dizesinin sonuna ulaştığı için geri başvuru başarısız olur. Böylece bir kez daha geri adım atıyor. İkinci alternatif artık a ile eşleşiyor. Normal ifade motoru üçüncü özyinelemeden çıkar.
Normal ifade motoru tekrar eşleşti (& word) ve geri başvuruyu tekrar denemesi gerekiyor. Geri referans +0 veya mevcut özyineleme seviyesini belirtir, bu 2'dir. Bu seviyede, yakalama grubu d ile eşleşti. Dizedeki sonraki karakter r olduğundan geri referans başarısız olur. Tekrar geri dönüş, ikinci alternatif eşleşir d.
Şimdi \ k'letter + 0 'dizedeki ikinci a ile eşleşiyor. Bunun nedeni, normal ifade motorunun, yakalama grubunun ilk a ile eşleştiği ilk özyinelemeye geri dönmesidir. Normal ifade motoru ilk özyinelemeden çıkar.
Normal ifade motoru artık tüm özyinelemenin dışında kaldı. Bu seviyede, yakalama grubu r depolanır. Geri referans artık dizedeki son r ile eşleşebilir. Motor artık herhangi bir özyineleme içinde olmadığından, gruptan sonra normal ifadenin geri kalanıyla devam eder. \ b dizenin sonunda eşleşir. Normal ifadenin sonuna ulaşılır ve genel eşleşme olarak radar döndürülür.
burada verilen dizenin palindrome olup olmadığını normal ifadeler kullanıp kullanmadığını söyleyen PL / SQL kodu:
create or replace procedure palin_test(palin in varchar2) is
tmp varchar2(100);
i number := 0;
BEGIN
tmp := palin;
for i in 1 .. length(palin)/2 loop
if length(tmp) > 1 then
if regexp_like(tmp,'^(^.).*(\1)$') = true then
tmp := substr(palin,i+1,length(tmp)-2);
else
dbms_output.put_line('not a palindrome');
exit;
end if;
end if;
if i >= length(palin)/2 then
dbms_output.put_line('Yes ! it is a palindrome');
end if;
end loop;
end palin_test;
my $pal='malayalam';
while($pal=~/((.)(.*)\2)/){ #checking palindrome word
$pal=$3;
}
if ($pal=~/^.?$/i){ #matches single letter or no letter
print"palindrome\n";
}
else{
print"not palindrome\n";
}