Herhangi bir geçerli sudoku çözümü ile eşleşen ve herhangi bir geçersiz sudoku çözümü ile eşleşmeyen bir regex yazın . Girdi, sudoku'nun kontrolsüz bir sürümüdür, yani satır sınırlayıcısı yoktur. Örneğin, aşağıdaki tahta:

7 2 5 8 9 3 4 6 1
8 4 1 6 5 7 3 9 2
3 9 6 1 4 2 7 5 8
4 7 3 5 1 6 8 2 9
1 6 8 4 2 9 5 3 7
9 5 2 3 7 8 1 4 6
2 3 4 7 6 1 9 8 5
6 8 7 9 3 5 2 1 4
5 1 9 2 8 4 6 7 3

olarak verilecekti:

725893461841657392396142758473516829168429537952378146234761985687935214519284673

Kurallar muhtemelen şu ana kadar yaygın bir bilgidir, ancak sadece ... bir sudoku kartı aşağıdaki durumlarda geçerlidir:

• Her bir satır gelen rakam içerir 1için 9tam olarak bir kez.
• Her bir sütun gelen rakam içerir 1için 9tam olarak bir kez.
• Dokuz 3x3 subgrids her birinden rakam içerir 1için 9tam olarak bir kez.

kurallar

Cevabınız, ek bir kod olmadan tek bir regex'ten oluşmalıdır (isteğe bağlı olarak, çözümünüzü çalışması için gereken regex değiştiricilerin bir listesi hariç). Dilinizin regex lezzetinin, barındırma dilinde kod çağırmanıza izin veren özelliklerini kullanmamalısınız (örneğin Perl'in edeğiştiricisi).

Bu zorluktan önce varolan herhangi bir regex lezzetini kullanabilirsiniz, ancak lütfen lezzeti belirtin.

Regex'in dolaylı olarak tutturulduğunu varsaymayın. Örneğin, Python kullanıyorsanız, regex'inizin birlikte kullanıldığını re.searchve kullanılmadığını varsayalım re.match. Regex'iniz tüm dizeyle eşleşmek zorunda değildir. Geçerli çözümler için sadece en az bir alt dizeyle (boş olabilir) eşleşmesi ve geçersiz çözümler için eşleşme olmaması gerekiyor.

Girişin her zaman 81 pozitif basamaktan oluşan bir dize olacağını varsayabilirsiniz.

Bu regex golf, yani bayt cinsinden en kısa regex kazanıyor. /.../Dilinizde düzenli ifadeleri belirtmek için sınırlayıcılar gerekiyorsa (genellikle ) sınırlayıcıları kendileri saymayın. Çözümünüz değiştiriciler gerektiriyorsa, değiştirici başına bir bayt ekleyin.

Test Kılıfları

Geçerli panolar:

123456789456789123789123456231564897564897231897231564312645978645978312978312645
725893461841657392396142758473516829168429537952378146234761985687935214519284673
395412678824376591671589243156928437249735186738641925983164752412857369567293814
679543182158926473432817659567381294914265738283479561345792816896154327721638945
867539142324167859159482736275398614936241587481756923592873461743615298618924375
954217683861453729372968145516832497249675318783149256437581962695324871128796534
271459386435168927986273541518734269769821435342596178194387652657942813823615794
237541896186927345495386721743269158569178432812435679378652914924813567651794283
168279435459863271273415986821354769734692518596781342615947823387526194942138657
863459712415273869279168354526387941947615238138942576781596423354821697692734185
768593142423176859951428736184765923572389614639214587816942375295837461347651298
243561789819327456657489132374192865926845317581673294162758943735914628498236571
243156789519847326687392145361475892724918653895263471152684937436729518978531264
498236571735914628162758943581673294926845317374192865657489132819327456243561789
978531264436729518152684937895263471724918653361475892687392145519847326243156789
341572689257698143986413275862341957495726831173985426519234768734869512628157394

Geçersiz panolar:

519284673725893461841657392396142758473516829168429537952378146234761985687935214
839541267182437659367158924715692843624973518573864192298316475941285736456729381
679543182158926473432817659567381294914256738283479561345792816896154327721638945
867539142324167859159482736275398684936241517481756923592873461743615298618924375
754219683861453729372968145516832497249675318983147256437581962695324871128796534
271459386435168927986273541518734269769828435342596178194387652657942813823615794
237541896186927345378652914743269158569178432812435679495386721924813567651794283
168759432459613278273165984821594763734982516596821347615437829387246195942378651
869887283619214453457338664548525781275424668379969727517385163319223917621449519
894158578962859187461322315913849812241742157275462973384219294849882291119423759
123456789456789123564897231231564897789123456897231564312645978645978312978312645
145278369256389147364197258478512693589623471697431582712845936823956714931764825
243561789829317456657489132374192865916845327581673294162758943735924618498236571
243156789529847316687392145361475892714928653895263471152684937436719528978531264
498236571735924618162758943581673294916845327374192865657489132829317456243561789
978531264436719528152684937895263471714928653361475892687392145529847316243156789
342571689257698143986413275861342957495726831173985426519234768734869512628157394
345678192627319458892451673468793521713524986951862347179246835534187269286935714
341572689257698143986413275862341957495726831173985426519234768734869512628517394

Daha fazla test için, geçerli bir tahtayı giriş olarak alan ve rasgele rasgele yerleştiren bu CJam komut dosyasını kullanabilirsiniz (yeni basamaklar ve isteğe bağlı olarak beyaz alan içerdiği sürece ilgisiz)

Eğer regex'iniz .NET aromasıyla uyumluysa, Retina'yı kullanarak çevrimiçi olarak test edebilirsiniz . Geçerli bir çözüm, 0geçersiz panolar için ve geçerli panolar için bazı pozitif tamsayılar için yazdırılmalıdır . Tüm test durumlarını bir kerede çalıştırmak için bu şablonu kullanın ve regex'i ikinci satıra yerleştirin. Regex değiştiricilere ihtiyacınız varsa, a regex'e `hazırlayın ve standart değiştirici harfleri önüne koyun.

Ruby regex, 71 78 73 bayt

^(?!.*(?=(.))(.{9}+|(.(?!.{9}*$))+|(?>.(?!.{3}*$)|(.(?!.{27}*$)){7})+)\1)

Ruby'yi gerçekten tanımıyorum ama görünüşe göre basamaklı niceleyicilerden şikayetçi değil.

Burada dene.

.NET regex, 79 78 75 veya 77 bayt

Çünkü Martin bunun mümkün olduğunu düşünüyor ... Ama sanırım bu değişiklikleri de dahil edecek.

^(?!(.)+((.{9})+|(?>(.{9})+
|.)+|(?((...)*
)(?>(.{27})+
|.){7}|.)+)(?<=\1))

Çalışmak için girişte izleyen bir yeni satır gerektirir. Bunu yapmama izin verilip verilmediğinden emin değilim (muhtemelen değil).

Burada dene.

77 byte aklı başında sürüm:

^(?!(.)+((.{9})+|((?!(.{9})*$).)+|(?((...)*$)((?!(.{27})*$).){7}|.)+)(?<=\1))

Önceki sürümümdeki hatayı işaret ettiğin ve 1 baytlık golf oynadığı için teşekkürler Neil ( (...)*).

Burada dene.

PCRE, 77 78 bayt

^(?!.*(?=(.))((.{9})+|(.(?!(?3)*$))+|(?(?=.(...)*$)(.(?!(.{27})*$)){7}|.)+)\1)

Sadece bütünlük için.

Burada dene.

Başka bir sürüm, ayrıca 78 bayt:

^(?!.*(?=(.))((.{9})+|(.(?!(?3)*$))+|(?>.(?!(...)*$)|(.(?!(.{27})*$)){7})+)\1)

Burada dene.

açıklama

^(?!.*                    # Match a string that doesn't contain the pattern,
                          # at any position.
  (?=(.))                 # Capture the next character.
  (
    (.{9})+               # Any 9*n characters. The next character is in
                          # the same column as the captured one.
  |
    (.(?!(.{9})*$))+      # Any n characters not followed by a positions 9*m
                          # to the end. The next character is in the same row
                          # as the captured one.
  |
    (                     # Any n occasions of...
    ?(.(...)*$)           # If it is at a position 3*k+1 to the end:
      (.(?!(.{27})*$)){7} # Then count 7*m characters that are not followed
                          # by a position 27*j to the end,
    |
      .                   # Else count any character.
    )+                    # The next character is in the same block as the
                          # captured one.
  )
  \1                      # Fail if the next character is the captured character.
)

PCRE, 117 119 130 133 147 bayt

^(?!(.{27})*(...){0,2}(.{9})?.?.?(.).?.?(?=(?2)*$).{6,8}(?3)?\4.{0,17}(?1)*$|.*(.)(.{8}(?3)*|((?!(?3)*$)(|.(?7))))\5)

Python, Java vb. Aromalarda da çalışmalı. Şimdi özyinelemeyle! Ve "özyineleme" özelliği özyinelemesiz olarak "özyinelemeler" için kullandı, gerçek özyineleme kullanmak zorunda kalana kadar tamamen unuttum.

.NET regex, 8339 bayt

Evet, çözümümün çok saf olmadığını biliyorum, çünkü Martin bana 130 bayt gibi yaptığını söyledi. Aslında, çevrimiçi deneme URL’si o kadar uzun ki, kabul edecek bir URL kısaltıcı bulamadım.

(code removed, since it's so long nobody will read it here, 
and it made the post take forever to load. Just use the "Try it online" link.)

Aşağıdaki bağlantı IE’de çalışmıyor, ancak Chrome ve Firefox’ta çalışıyor.

Çevrimiçi deneyin - Tüm test durumları bir kerede,!`başlangıçta, bayt sayısına dahil olmayanlarınyardımıyla.

İşte onu oluşturmak için kullandığım Python betiği (aşağıdaki kod):

R=range(0,9)
S=range(1,10)

o = ""

# validate rows
T = "(?=.{%s,%s}%s)"
for j in R:
    for i in S:
        o += T % (9*j,9*(j+1)-1, i)

# validate columns
# "(?=(.{%s}|.{%s}|.{%s}|.{%s}|.{%s}|.{%s}|.{%s}|.{%s}|.{%s})%s)"
T = "(?=("+"|".join([".{%s}"]*9)+")%s)"
for j in R:
    for i in S:
        o += T % (j,j+9,j+18,j+27,j+36,j+45,j+54,j+63,j+72, i)

# validate boxes
# (?=.{0,2}1|.{9,11}1|.{18,20}1)(?=.{3,5}1|.{12,14}1|.{21,23}1)
# (?=.{27,29}1|.{36,38}1|.{45,47}1)
T = ".{%s,%s}%s"
for i in S:
    for x in (0,27,54):
        for y in (0,3,6):
            o += "(?="+"|".join(T % (x+y+z,x+y+z+2, i) for z in (0,9,18))+")"

o += ".{81}"

o = o.replace(".{0}","").replace(",80}",",}")
print(o)

.NET regex, 121 bayt

^(?!(.{27})*(.{9})?(...){0,2}.?.?(.).?.?(?=(...)*$)(.{9})?.{6,8}\4.{0,17}(.{27})*$|.*(?=(.))((.{9})+|(.(?!(.{9})*$))+)\8)

Açıklama:

^(?!                     Invert match (because we're excluding duplicates)
 (.{27})*                Skip 0, 3 or 6 rows
 (.{9})?                 Optionally skip another row
 (...){0,2}              Skip 0, 3 or 6 columns
 .?.?(.).?.?(?=(...)*$)  Choose any of the next three cells
 (.{9})?                 Optionally skip another row
 .{6,8}\4                Match any of the three cells below
 .{0,17}(.{27})*$        As long as they're from the same square
|                        OR
 .*(?=(.))(              Choose any cell
  (.{9})+                Skip at least one row
 |                       or
  (.                     Skip cells
   (?!(.{9})*$)          Without reaching the end of the row
  )+                     For at least one cell (i.e. the cell chosen above)
 )\8)                    Match the chosen cell to the next cell
)

PCRE, 3579 bayt

Kesinlikle korkunç bir kaba kuvvet çözümü. Olumsuz bakışlar ahoy!

Bu konuyu terk etmek için çok fazla zaman harcadım, o yüzden işte burası, gelecek nesillerin iyiliği için.

Parlak tarafta, Sudoku aniden farklı 9 karakterlik bir küme kullanmaya başlarsa, bu hala işe yarayacak, sanırım ...

http://pastebin.com/raw/CwtviGkC

Retina'yı nasıl çalıştıracağımı bilmiyorum, ancak https://regex101.com veya benzeri bir öğeye yapıştırabilirsiniz ve eşleşir.

Regex oluşturmak için kullanılan yakut kodu:

# Calculate the block you're in
def block(x)
    x /= 3
    x + x%3 - x%9
end

81.times do |i|
    row, col = i.divmod(9)
    neg = []
    neg += (0...col).map {|e| 9*row + e + 1}
    neg += (0...row).map {|e| 9*e + col + 1}
    neg += (0...i).map {|e| e + 1 if block(e) == block(i)}.compact
    neg = neg.uniq.sort.map {|e| "\\#{e}"}
    if neg.size > 0
        print "(?!#{neg.join '|'})"
    end
    print "(.)"
end

Yakut tadı, 75 74 bayt

1 byte tasarruf için jimmy23013'e teşekkürler.

^(?!(.{9}*(.|(.)){,8}|.*(\g<2>.{8})*|.{27}?.{3}?(\g<2>{3}.{6}){,2}.?.?)\3).

Burada test et.

Şimdi nihayet dövüldüğü için kendi çözümümü paylaşabilirim. :) Süreçte ilginç bir (belki yeni?) Regex tekniği keşfettim ( (.|(.)){,8}\3bölüm), bunun regex'in diğer bölümleriyle birleştirilemediği durumlarda yenilmez olabilir (jimmy23013'in cevabında olduğu gibi) .

açıklama

Diğer kısa cevaplar gibi ben de satırlar, sütunlar veya bloklar halinde kopyaları arayan negatif bir bakış açısı kullanıyorum. Çözümün temel yapı taşı şudur:

(.|(.))...\3

\3Üç farklı alternatif arasında tekrar kullanıldığına dikkat edin (tümü 3yinelenen algılama için grup kullanır ).

Soldaki bu grup (grup olan 2gruptur 3), çift basamağın ilk yarısını içerebilecek herhangi bir konum için kullanılır (çift basamak içermemesi gereken bir grup içinde). Öyleyse ..., bizi böyle bir rakamın (gerekirse) oluşabileceği bir sonraki pozisyona \3getiren ve yinelemenin ikinci yarısını geri referans yoluyla bulmaya çalışan bir şey. Bunun işe yaramasının nedeni geri izleme. Motor ilk eşleştiğinde (.|(.)), .her zaman sadece kullanır ve hiçbir şey yakalamaz. Şimdi \3sonunda başarısız olur. Ama şimdi motor yavaş yavaş bireysel maçlar (.)yerine kullanmayı deneyecek .. Sonuçta, eğer bir yinelenen varsa, kombinasyonu nerede bulacak(.)en son kopyadaki ilk basamakta kullanıldı (yakalama daha sonra üzerine yazılmayacak şekilde), ve daha sonra .açığı geri akıma köprülemek için biraz daha kullanır . Bir yinelenen varsa, geri izleme her zaman onu bulur.

Bunun kullanıldığı üç farklı kısma bakalım:

.{9}*(.|(.)){,8}

Bu, bazı satırlardaki kopyaları kontrol eder. İlk önce herhangi bir satıra atlayalım .{9}*. Ardından, isteğe bağlı yinelemeli yakalamayı kullanarak 8 karaktere kadar (yani, son rakam hariç bu satırdaki herhangi bir şey) eşleşir ve \3ardından onu bulmaya çalışırız .

.*(\g<2>.{8})*

Bu, bazı sütunlarda kopyaları arar. Öncelikle, bunun \g<2>bir alt program çağrısı olduğuna dikkat edin , bu nedenle aynı:

.*((.|(.)).{8})*

biz sadece ekledikten iki grup hala olarak anılacaktır nerede 2ve 3.

Burada, .*basitçe gerektiği kadar atlar (burada 8 karaktere kadar eşleştirmek yeterlidir, ancak bu daha fazla bayt tutar). Daha sonra dış grup isteğe bağlı olarak birinci karakteri yakalayan bir seferde bir tam sırayı (iki fiziksel sıra boyunca sarabilir) eşleştirir. Bundan \3hemen sonra aranacak, bu da yakalama ve geri referans arasında dikey hizalama sağlar.

Son olarak, blokları kontrol ederek:

.{27}?.{3}?(\g<2>{3}.{6}){,2}.?.?

Yine, bu \g<2>bir alt yordam çağrısıdır, bu nedenle bu aynıdır:

.{27}?.{3}?((.|(.)){3}.{6}){,2}.?.?

Blokları doğrulamak için, tüm satırları ve sütunları zaten kontrol ettiğimizden, yalnızca 3x3 bloktan dördünü kontrol etmemiz gerektiğini unutmayın. Bu 3x3 blokların yanı sıra tüm satır ve sütunların doğru olduğunu bildiğimizde:

XX.
XX.
...

O zaman biliyoruz ki, geri kalan bloklarda da iki kopya olamaz. Bu yüzden sadece bu dört bloğu kontrol ediyorum. Ayrıca, 3x3 bloğun aynı satırındaki kopyaları aramak zorunda olmadığımızı unutmayın. Kopyalamanın ilk yarısını bir satırda bulmak ve ikinci yarısını bir satırda aşağıya aramak yeterlidir.

Şimdi kodun kendisi için ilk önce dört bloktan birinin başlangıcına .{27}?.{3}?atlayın (isteğe bağlı olarak üç satırı atlayın, isteğe bağlı olarak üç sütun atlayın). Daha sonra 3x3 bloğunun iki satırına kadar, satırlar için daha önce kullandığımız aynı hile ile eşleştirmeye çalışırız:

(.|(.)){3}.{6}

3x3 bloğunun geçerli satırındaki 3 hücrenin herhangi birinin yakalanmasına izin veriyoruz, ancak bununla bir sonraki satıra atlıyoruz .{6}. Sonunda, sonunu eklediğimiz satırın 3 hücresinden birinde bir kopyasını bulmaya çalışıyoruz:

.?.?

Ve bu kadar.

Javascript regex, 532 530 481 463 karakter

Satırları doğrula:

/^((?=.{0,8}1)(?=.{0,8}2)(?=.{0,8}3)(?=.{0,8}4)(?=.{0,8}5)(?=.{0,8}6)(?=.{0,8}7)(?=.{0,8}8)(?=.{0,8}9).{9})+$/

Sütunları doğrula:

/^((?=(.{9}){0,8}1)(?=(.{9}){0,8}2)(?=(.{9}){0,8}3)(?=(.{9}){0,8}4)(?=(.{9}){0,8}5)(?=(.{9}){0,8}6)(?=(.{9}){0,8}7)(?=(.{9}){0,8}8)(?=(.{9}){0,8}9).){9}/

İlk karakterden kareyi doğrula:

/(?=.?.?(.{9}){0,2}1)(?=.?.?(.{9}){0,2}2)(?=.?.?(.{9}){0,2}3)(?=.?.?(.{9}){0,2}4)(?=.?.?(.{9}){0,2}5)(?=.?.?(.{9}){0,2}6)(?=.?.?(.{9}){0,2}7)(?=.?.?(.{9}){0,2}8)(?=.?.?(.{9}){0,2}9)/

Kareyi başlatmak için önizlemeyi ayarla:

/^(((?=)...){3}.{18})+$/

Ve bütün ifade:

/^(?=((?=.{0,8}1)(?=.{0,8}2)(?=.{0,8}3)(?=.{0,8}4)(?=.{0,8}5)(?=.{0,8}6)(?=.{0,8}7)(?=.{0,8}8)(?=.{0,8}9).{9})+$)(?=((?=(.{9}){0,8}1)(?=(.{9}){0,8}2)(?=(.{9}){0,8}3)(?=(.{9}){0,8}4)(?=(.{9}){0,8}5)(?=(.{9}){0,8}6)(?=(.{9}){0,8}7)(?=(.{9}){0,8}8)(?=(.{9}){0,8}9).){9})(((?=.?.?(.{9}){0,2}1)(?=.?.?(.{9}){0,2}2)(?=.?.?(.{9}){0,2}3)(?=.?.?(.{9}){0,2}4)(?=.?.?(.{9}){0,2}5)(?=.?.?(.{9}){0,2}6)(?=.?.?(.{9}){0,2}7)(?=.?.?(.{9}){0,2}8)(?=.?.?(.{9}){0,2}9)...){3}.{18})+$/

Tüm dizeyle eşleşir.

Javascript ES6'da test edin:

r = /^(?=((?=.{0,8}1)(?=.{0,8}2)(?=.{0,8}3)(?=.{0,8}4)(?=.{0,8}5)(?=.{0,8}6)(?=.{0,8}7)(?=.{0,8}8)(?=.{0,8}9).{9})+$)(?=((?=(.{9}){0,8}1)(?=(.{9}){0,8}2)(?=(.{9}){0,8}3)(?=(.{9}){0,8}4)(?=(.{9}){0,8}5)(?=(.{9}){0,8}6)(?=(.{9}){0,8}7)(?=(.{9}){0,8}8)(?=(.{9}){0,8}9).){9})(((?=.?.?(.{9}){0,2}1)(?=.?.?(.{9}){0,2}2)(?=.?.?(.{9}){0,2}3)(?=.?.?(.{9}){0,2}4)(?=.?.?(.{9}){0,2}5)(?=.?.?(.{9}){0,2}6)(?=.?.?(.{9}){0,2}7)(?=.?.?(.{9}){0,2}8)(?=.?.?(.{9}){0,2}9)...){3}.{18})+$/
;`123456789456789123789123456231564897564897231897231564312645978645978312978312645
725893461841657392396142758473516829168429537952378146234761985687935214519284673
395412678824376591671589243156928437249735186738641925983164752412857369567293814
679543182158926473432817659567381294914265738283479561345792816896154327721638945
867539142324167859159482736275398614936241587481756923592873461743615298618924375
954217683861453729372968145516832497249675318783149256437581962695324871128796534
271459386435168927986273541518734269769821435342596178194387652657942813823615794
237541896186927345495386721743269158569178432812435679378652914924813567651794283
168279435459863271273415986821354769734692518596781342615947823387526194942138657
863459712415273869279168354526387941947615238138942576781596423354821697692734185
768593142423176859951428736184765923572389614639214587816942375295837461347651298`
.split`
`.every(r.test.bind(r))
&&
`519284673725893461841657392396142758473516829168429537952378146234761985687935214
839541267182437659367158924715692843624973518573864192298316475941285736456729381
679543182158926473432817659567381294914256738283479561345792816896154327721638945
867539142324167859159482736275398684936241517481756923592873461743615298618924375
754219683861453729372968145516832497249675318983147256437581962695324871128796534
271459386435168927986273541518734269769828435342596178194387652657942813823615794
237541896186927345378652914743269158569178432812435679495386721924813567651794283
168759432459613278273165984821594763734982516596821347615437829387246195942378651
869887283619214453457338664548525781275424668379969727517385163319223917621449519
894158578962859187461322315913849812241742157275462973384219294849882291119423759
123456789456789123564897231231564897789123456897231564312645978645978312978312645
145278369256389147364197258478512693589623471697431582712845936823956714931764825`
.split`
`.every(s => !r.test(s))