Scrivi una regex che corrisponda a qualsiasi soluzione di sudoku valida e non corrisponda a nessuna soluzione di sudoku non valida. L'input è una versione non srotolata del sudoku, cioè non ci sono delimitatori di linea. Ad esempio la seguente scheda:

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

sarebbe dato come:

725893461841657392396142758473516829168429537952378146234761985687935214519284673

Le regole sono probabilmente conosciute ormai, ma nel caso ... una tavola di sudoku è valida se e solo se:

• Ogni riga contiene le cifre da 1a 9esattamente una volta.
• Ogni colonna contiene le cifre da 1a 9esattamente una volta.
• Ognuna delle nove subgrid 3x3 contiene le cifre da 1a 9esattamente una volta.

Regole

La tua risposta dovrebbe consistere in un unico regex, senza alcun codice aggiuntivo (tranne, facoltativamente, un elenco di modificatori regex necessari per far funzionare la tua soluzione). Non devi usare le caratteristiche del sapore regex della tua lingua che ti consentono di invocare il codice nella lingua di hosting (ad esempio il emodificatore di Perl ).

Puoi usare qualsiasi sapore regex che esisteva prima di questa sfida, ma specifica il sapore.

Non dare per scontato che il regex sia ancorato implicitamente. Ad esempio, se stai usando Python, supponi che il tuo regex sia usato con re.searche non con re.match. Il tuo regex non deve corrispondere all'intera stringa. Deve solo corrispondere ad almeno una sottostringa (che può essere vuota) per soluzioni valide e non produrre corrispondenze per soluzioni non valide.

Si può presumere che l'input sarà sempre una stringa di 81 cifre positive.

Questo è regex golf, quindi vince il regex più breve in byte. Se la tua lingua richiede delimitatori (di solito /.../) per indicare espressioni regolari, non contare i delimitatori stessi. Se la tua soluzione richiede modificatori, aggiungi un byte per modificatore.

Casi test

Schede valide:

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

Schede non valide:

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

Per ulteriori casi di test, è possibile utilizzare questo script CJam che accetta una scheda valida come input e la mescola casualmente per dare una nuova scheda valida (formato di input irrilevante purché contenga solo cifre e, eventualmente, uno spazio).

Se il tuo regex è compatibile con il sapore .NET, puoi testarlo online usando Retina. Una soluzione valida deve essere stampata 0per schede non valide e un numero intero positivo per schede valide. Per eseguire tutti i casi di test contemporaneamente, utilizzare questo modello e inserire la regex sulla seconda riga. Se hai bisogno di modificatori regex, anteponi `a regex e metti le lettere del modificatore standard davanti ad esso.

Ruby regex, 71 78 73 byte

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

Non conosco davvero Ruby ma a quanto pare non si lamenta dei quantificatori a cascata.

Provalo qui.

Regex .NET, 79 78 75 o 77 byte

Perché Martin pensa che sia possibile ... Ma immagino che includerà anche questi cambiamenti.

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

Richiede una nuova riga finale nell'input per funzionare. Non sono sicuro che mi sia permesso farlo (probabilmente no).

Provalo qui.

La versione sana di 77 byte:

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

Grazie Neil per aver segnalato l'errore nella mia versione precedente e aver giocato a golf a 1 byte (per il (...)*).

Provalo qui.

PCRE, 77 78 byte

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

Solo per completezza.

Provalo qui.

Un'altra versione, anche 78 byte:

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

Provalo qui.

Spiegazione

^(?!.*                    # 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 byte

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

Dovrebbe funzionare anche con Python, Java, ecc. Ora con ricorsione! E la funzione "ricorsione" è stata utilizzata in modo non ricorsivo per le "subroutine", di cui mi sono completamente dimenticato fino a quando non ho dovuto ricorrere alla ricorsione effettiva.

Regex .NET, 8339 byte

Sì, so che la mia soluzione è molto ingenua, dal momento che Martin mi ha detto di averlo fatto in 130 byte. In effetti, l'URL per provarlo online è così lungo che non sono riuscito a trovare un accorciatore di URL che lo accetterebbe.

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

Il link seguente non funziona in IE, ma funziona in Chrome e Firefox.

Provalo online : tutti i casi di test contemporaneamente, con l'aiuto di!`all'inizio, non inclusi nel conteggio dei byte.

Ecco lo script Python che ho usato per generarlo (codice sotto):

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)

Regex .NET, 121 byte

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

Spiegazione:

^(?!                     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 byte

Una soluzione di forza bruta assolutamente terribile. Lookbehinds negativi ahoy!

Ho trascorso troppo tempo su questo per abbandonarlo, quindi eccolo qui, per l'amor dei posteri.

Il lato positivo, se il Sudoku inizia improvvisamente a usare un diverso set di 9 personaggi, funzionerà comunque, immagino ...

http://pastebin.com/raw/CwtviGkC

Non so come utilizzare Retina, ma puoi anche incollarlo in https://regex101.com o simili e corrisponderà.

Codice ruby ​​utilizzato per generare la regex:

# 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

Sapore rubino, 75 74 byte

Grazie a jimmy23013 per aver salvato 1 byte.

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

Provalo qui.

Ora che è stato finalmente sconfitto, posso condividere la mia soluzione. :) Ho scoperto un'interessante (forse nuova?) Tecnica regex nel processo (la (.|(.)){,8}\3parte), che sarebbe probabilmente imbattibile nei casi in cui questo non può essere combinato con altre parti della regex (come nel caso della risposta di jimmy23013) .

Spiegazione

Come le altre brevi risposte, sto usando un lookahead negativo che cerca duplicati in righe, colonne o blocchi. Il blocco base della soluzione è questo:

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

Si noti che \3viene riutilizzato tra tre diverse alternative (che utilizzano tutti il ​​gruppo 3per il rilevamento duplicato).

Quel gruppo a sinistra (che è gruppo 2, contenente gruppo 3) viene utilizzato per qualsiasi posizione che può contenere la prima metà di una cifra duplicata (all'interno di un gruppo che non deve contenere cifre duplicate). Quindi ...è qualcosa che ci porta nella posizione successiva in cui potrebbe verificarsi una cifra del genere (se necessario) e \3cerca di trovare la seconda metà del duplicato tramite backreference. Il motivo per cui funziona è il backtracking. Quando il motore si abbina per la prima volta, (.|(.))lo utilizzerà semplicemente .ogni volta e non catturerà nulla. Ora \3alla fine fallisce. Ma ora il motore proverà gradualmente a utilizzare (.)invece che .per le singole partite. Alla fine, se c'è un duplicato, troverà la combinazione dove(.)è stato utilizzato l'ultima volta sulla prima cifra del duplicato (in modo tale che l'acquisizione non venga sovrascritta in seguito), quindi ne utilizza un po 'di più .per colmare il divario con il riferimento secondario. Se è presente un duplicato, il backtracking lo troverà sempre.

Diamo un'occhiata alle tre diverse parti in cui viene utilizzato:

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

Questo verifica la presenza di duplicati in alcune righe. Per prima cosa saltiamo a qualsiasi riga con .{9}*. Quindi abbiniamo fino a 8 caratteri (ovvero qualsiasi cosa in quella riga tranne l'ultima cifra) usando l'acquisizione duplicata opzionale e proviamo a trovare il \3dopo.

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

Questo cerca duplicati in alcune colonne. Innanzitutto, nota che si \g<2>tratta di una chiamata di subroutine, quindi è la stessa di:

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

dove i due gruppi che abbiamo appena inserito sono ancora indicati come 2e 3.

Qui, .*semplicemente salta per quanto necessario (sarebbe sufficiente far corrispondere fino a 8 caratteri qui, ma questo costa più byte). Quindi il gruppo esterno corrisponde a una riga completa (che può avvolgere due righe fisiche) alla volta, facoltativamente catturando il primo personaggio. Lo si \3cercherà subito dopo, il che garantisce un allineamento verticale tra l'acquisizione e il backreference.

Infine, controllando i blocchi:

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

Ancora una volta, si \g<2>tratta di una chiamata di subroutine, quindi è la stessa di:

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

Per verificare i blocchi, nota che poiché abbiamo già controllato tutte le righe e le colonne, dobbiamo solo controllare quattro dei blocchi 3x3. Quando sappiamo che tutte le righe e le colonne e questi blocchi 3x3 sono corretti:

XX.
XX.
...

Quindi sappiamo che non possono esserci duplicati nei blocchi rimanenti. Quindi sto solo controllando questi quattro blocchi. Inoltre, si noti che non è necessario cercare duplicati all'interno della stessa riga di un blocco 3x3. È sufficiente trovare la prima metà del duplicato in una riga e cercare la seconda metà di una riga più in basso.

Ora per il codice stesso, per prima cosa saltiamo all'inizio di uno dei quattro blocchi con .{27}?.{3}?(facoltativamente salta tre righe, opzionalmente salta tre colonne). Quindi proviamo ad abbinare fino a due delle righe del blocco 3x3 con lo stesso trucco che abbiamo usato per le righe precedenti:

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

Consentiamo, ma non richiediamo l'acquisizione di nessuna delle 3 celle nella riga corrente del blocco 3x3 e quindi passiamo alla riga successiva con .{6}. Infine, proviamo a trovare un duplicato in una delle 3 celle della riga su cui finiamo:

.?.?

E questo è tutto.

Javascript regex, 532 530 481 463 caratteri

Convalida righe:

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

Convalida colonne:

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

Convalida piazza dal suo primo carattere:

/(?=.?.?(.{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)/

Imposta l'anteprima per l'inizio del quadrato:

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

E l'intera espressione:

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

Corrisponde all'intera stringa.

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