Напишіть регулярний вираз, який відповідає будь-якому дійсному рішенню судоку і не відповідає жодному недійсному рішенню судоку. Вхід представляє собою розгорнуту версію судоку, тобто немає обмежувачів ліній. Наприклад, наступна рада:

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

буде надано як:

725893461841657392396142758473516829168429537952378146234761985687935214519284673

Наразі правила, мабуть, загальновідомі, але про всяк випадок ... Дошка судоку діє лише тоді:

• Кожен рядок містить цифри від 1до 9рівно один раз.
• Кожен стовпець містить цифри від 1до 9рівно один раз.
• Кожен з дев'яти 3x3 підмереж містять цифри від 1до 9рівно один рази.

Правила

Ваша відповідь повинна складатися з одного регулярного вираження без будь-якого додаткового коду (крім, необов'язково, списку модифікаторів регулярних виразів, необхідних для роботи вашого рішення). Ви не повинні використовувати функції смаку регулярних виразів вашої мови, які дозволяють викликати код на мові хостингу (наприклад, eмодифікатор Perl ).

Ви можете використовувати будь-який аромат регексу, який існував до цього виклику, але, будь ласка, вкажіть аромат.

Не вважайте, що регулярний вираз закріплений неявно. Наприклад, якщо ви використовуєте Python, припустіть, що ваш регекс використовується з, re.searchа не з re.match. Ваш регулярний вираз не повинен відповідати всій рядку. Просто потрібно відповідати принаймні одній підрядковій частині (яка може бути порожньою) для дійсних рішень і не відповідати недійсним рішенням.

Ви можете припустити, що вхід завжди буде рядком з 81 позитивної цифри.

Це гольф-реджекс, тому виграє найкоротший регулярний вираз у байтах. Якщо ваша мова вимагає роздільників (як правило /.../) для позначення регулярних виразів, не рахуйте самих роздільників. Якщо для вашого рішення потрібні модифікатори, додайте один байт на модифікатор.

Випробування

Дійсні дошки:

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

Недійсні дошки:

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

Для подальших тестових випадків ви можете використовувати цей скрипт CJam, який приймає дійсну дошку як вхідну інформацію і випадковим чином переміщує її, щоб дати нову дійсну дошку (формат введення не має значення, якщо вона містить лише цифри та необов'язково пробіл).

Якщо ваш регекс сумісний із ароматом .NET, ви можете протестувати його в Інтернеті за допомогою Retina. Дійсне рішення має надрукувати 0для недійсних дощок та деяке додатне ціле число для дійсних дощок. Щоб запустити всі тестові випадки одразу, використовуйте цей шаблон і вставте регулярний вираз у другому рядку. Якщо вам потрібні модифікатори регулярних виразів, додайте `до регулярного вираження і покладіть перед ним стандартні літери модифікатора.

Регекс Рубі, 71 78 73 байт

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

Я не знаю Рубі, але, мабуть, вона не скаржиться на каскадні квантори.

Спробуйте тут.

.NET регулярний вираз, 79 78 75 або 77 байт

Тому що Мартін вважає, що це можливо ... Але я думаю, що він просто включить ці зміни.

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

Потрібна нова лінія для введення в роботу. Я не впевнений, чи мені це дозволяється (напевно, ні).

Спробуйте тут.

Версія з вимогою 77 байт:

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

Дякую Нілу за вказівку на помилку в моїй попередній версії та гольф на 1 байт (для (...)*).

Спробуйте тут.

PCRE, 77 78 байт

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

Просто для повноти.

Спробуйте тут.

Інша версія, також 78 байт:

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

Спробуйте тут.

Пояснення

^(?!.*                    # 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 байт

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

Також слід працювати в ароматах Python, Java тощо. Тепер з рекурсією! І функція "рекурсія" використовувалася не рекурсивно для "підпрограм", про які я повністю забув, поки не довелося використовувати фактичну рекурсію.

.NET регекс, 8339 байт

Так, я знаю, що моє рішення дуже наївне, оскільки Мартін сказав мені, що він це зробив у 130 байтах. Насправді, URL-адреса для спробу в Інтернеті настільки довга, що я не зміг знайти скорочувач URL-адрес, який би її прийняв.

(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.)

Наведене нижче посилання не працює в IE, але працює в Chrome і Firefox.

Спробуйте в Інтернеті - всі тестові випадки одразу, за допомогою!`на початку, не включені до складу байтів.

Ось сценарій Python, який я використовував для його створення (код нижче):

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 регулярний вираз, 121 байт

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

Пояснення:

^(?!                     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 байт

Абсолютно жахливе жорстоке рішення. Негативний погляд за спиною ахой!

Я витратив на це занадто багато часу, щоб відмовитися від цього, тож ось, заради нащадків.

З іншого боку, якщо судоку раптом почне використовувати інший набір з 9 символів, це все одно спрацює, я думаю ...

http://pastebin.com/raw/CwtviGkC

Я не знаю, як керувати Retina, але ви також можете вставити його на https://regex101.com або подібне, і воно відповідатиме.

Код Ruby, який використовується для генерування регулярного вираження:

# 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

Рубіновий аромат, 75 74 байт

Завдяки jimmy23013 за збереження 1 байта.

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

Перевірте це тут.

Тепер, коли його нарешті побили, я можу поділитися власним рішенням. :) Я виявив цікаву (можливо, нову?) Техніку регулярних виразів у процесі ( (.|(.)){,8}\3деталі), яка, ймовірно, виявиться неперевершеною у випадках, коли це неможливо поєднати з іншими частинами регулярного виразу (як це було у відповіді jimmy23013) .

Пояснення

Як і інші короткі відповіді, я використовую негативний пошук, який шукає дублікати в рядках, стовпцях або блоках. Основний будівельний блок рішення:

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

Зауважте, що \3повторне використання використовується між трьома різними альтернативами (які всі використовують 3для виявлення дублікатів).

Ця група зліва (яка є групою 2, що містить групу 3) використовується для будь-якої позиції, яка може містити першу половину дублюючої цифри (всередині групи, яка не повинна містити повторюваних цифр). Тоді ...це є те, що дає нам наступну позицію, де може виникнути така цифра (якщо це необхідно) і \3намагається знайти другу половину дубліката за допомогою зворотної референції. Причина цього працює - це зворотній трек. Коли двигун вперше відповідає, (.|(.))він просто використовуватиме .кожен раз і нічого не захопить. Тепер \3кінець провалюється. Але тепер двигун буде поступово намагатися використовувати (.)замість .окремих матчів. Зрештою, якщо є дублікат, він знайде комбінацію де(.)востаннє використовувався на першій цифрі дубліката (таким чином, щоб захоплення не було перезаписано пізніше), а потім використовує ще деяку кількість, .щоб перевести проміжок до зворотної референції. Якщо є дублікат, зворотний трек завжди знайде його.

Давайте розглянемо три різні частини, де це використовується:

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

Це перевіряє наявність дублікатів у деякому рядку. Спочатку ми переходимо до будь-якого ряду .{9}*. Потім ми порівнюємо до 8 символів (тобто будь-що в цьому рядку, крім останньої цифри), використовуючи необов'язковий дублікат, та намагаємось знайти його \3після.

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

Це шукає дублікатів у деяких стовпцях. По-перше, зауважте, що \g<2>це виклик підпрограми, тому це те саме, що:

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

де дві групи, які ми щойно вставили, все ще називають 2і 3.

Тут .*просто пропускається наскільки це можливо (досить було б тут зіставити до 8 символів, але це коштує більше байтів). Потім зовнішня група відповідає одному цілому ряду (який може обертатися на два фізичні ряди) за один раз, необов'язково фіксуючи перший символ. Після \3цього буде шукатись воля, яка забезпечує вертикальне вирівнювання між захопленням і зворотною референцією.

Нарешті, перевірка блоків:

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

Знову ж таки, \g<2>виклик підпрограми, тому це те саме, що:

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

Для перевірки блоків зауважте, що оскільки ми вже перевірили всі рядки та стовпці, нам потрібно лише перевірити чотири блоки 3x3. Коли ми знаємо, що всі рядки та стовпці, а також ці блоки 3x3 є правильними:

XX.
XX.
...

Тоді ми знаємо, що в інших блоках не може бути дублікатів. Отже, я перевіряю лише ці чотири блоки. Крім того, зауважте, що нам не потрібно шукати дублікати в одному рядку блоку 3x3. Досить знайти першу половину дубліката в одному ряду і пошукати другу половину підряд далі вниз.

Тепер для самого коду ми спочатку переходимо до початку одного з чотирьох блоків .{27}?.{3}?((пропустимо три ряди, необов'язково пропустимо три колонки). Потім ми намагаємось зіставити до двох рядків блоку 3x3 тим самим трюком, який ми використовували для рядків раніше:

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

Ми дозволяємо, але не вимагаємо захоплення жодної з 3 комірок у поточному рядку блоку 3x3, а потім переходимо до наступного рядка .{6}. Нарешті, ми намагаємось знайти дублікат у будь-якій з 3 комірок рядка, на яких ми закінчуємо:

.?.?

І це все.

Jage regex, 532 530 481 463 символів

Проверка рядків:

/^((?=.{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})+$/

І весь вираз:

/^(?=((?=.{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})+$/

Відповідає цілому рядку.

Тест у Javascript ES6:

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))