Giriş

Birkaç evden ve boş alanlardan başka bir şey olmayan küçük bir köy var. Yerel bürokratlar, köyü partilere bölmek istiyor, böylelikle her partide tam olarak bir ev var ve partilerin sınırları güzel bir düz çizgi ızgara oluşturuyor. Göreviniz bunun mümkün olup olmadığını belirlemektir.

Görev

Girişiniz dikdörtgen bir 2D bit dizisidir; 1 bir evi ve 0 boş bir alanı temsil eder. Boyutu en az 1 × 1 olacak ve en az 1 tane içerecektir. Girdiyi herhangi bir makul biçimde (iç içe tamsayılar listesi, dizgiler listesi, çok satırlı dize vb.) Alabilirsiniz.

Programınız, her bir ızgara hücresi tam olarak 1 içerecek şekilde düz yatay ve dikey çizgiler kullanılarak dizinin ızgara hücrelerine bölünüp bölünmeyeceğini belirleyecektir, böylece her bir dikdörtgen biçiminde olmasına rağmen, ızgara hücreleri farklı boyut ve şekillerde olabilir. Çizgiler dizinin bir kenarından diğer kenara doğru koşmalıdır.

Örneğin, aşağıdakiler bir dizinin geçerli bir bölümüdür:

00|0010|01|1
01|0000|00|0
--+----+--+-
00|0000|00|1
01|0010|01|0
--+----+--+-
01|1000|10|1

aşağıdaki bölüm geçerli değildir, çünkü 1 veya daha fazla 1 olmayan ızgara hücreleri vardır:

00|0010|01|1
--+----+--+-
01|0000|00|0
00|0000|00|1
01|0010|01|0
--+----+--+-
00|1000|10|1

Eğer geçerli bir bölüm varsa, bir gerçeğe uygun değer, aksi takdirde sahte bir değer vermelisiniz.

Kurallar ve puanlama

Tam bir program veya bir fonksiyon yazabilirsiniz. En düşük bayt sayısı kazanır.

Test durumları

[[1]] -> True
[[0,1],[1,0]] -> True
[[1,1],[1,0]] -> False
[[1,0,1],[0,1,0]] -> True
[[1,0],[0,1],[0,1]] -> True
[[1,0,0],[0,0,1],[0,1,1]] -> True
[[1,1,1],[1,1,1],[1,1,1]] -> True
[[1,0,1],[0,1,0],[1,0,0]] -> True
[[1,0,0],[1,0,0],[0,1,1]] -> False
[[0,0,0,0,1],[1,0,0,1,0],[0,0,0,1,0]] -> False
[[0,0,1,0,1],[0,0,0,1,0],[0,0,0,0,0]] -> True
[[1,1,0,0,0],[0,0,0,0,0],[1,0,1,0,0]] -> True
[[1,1,0,1,1],[0,1,0,1,1],[1,0,0,0,0]] -> True
[[0,0,0,0,0,0,0],[0,1,1,1,0,1,0],[0,1,0,0,1,0,0],[0,0,0,0,0,0,1],[0,0,1,0,0,0,1],[1,1,0,1,1,0,0]] -> False
[[1,1,0,0,0,0,0],[1,0,1,1,0,1,0],[0,0,0,0,1,0,0],[0,1,0,1,1,0,0],[1,0,0,0,1,1,0],[0,0,0,0,0,1,0]] -> False
[[0,1,0,1,1,1,0],[0,0,0,0,1,0,0],[0,0,0,0,0,0,0],[1,0,0,1,0,0,0],[0,0,0,0,0,0,0],[0,0,0,0,0,0,1]] -> True
[[0,1,0,0,1,0,1],[1,0,0,0,1,0,1],[0,0,1,0,1,0,1],[1,0,0,0,1,1,0],[0,0,0,1,1,1,0],[0,1,0,0,1,0,1]] -> True
[[0,1,0,0,1,0,0,1,0],[0,0,0,0,1,1,0,1,0],[1,1,0,0,1,0,0,0,0],[0,0,1,0,1,0,1,0,0],[0,0,1,0,1,0,1,0,0],[0,1,0,0,0,1,0,0,1],[0,1,0,0,0,0,1,0,0]] -> False
[[1,0,1,0,0,1,1,0,1],[0,1,1,0,0,1,1,0,1],[1,0,0,0,0,1,0,0,0],[0,0,0,0,0,0,0,0,0],[0,0,1,0,0,0,0,1,1],[0,1,1,0,1,0,1,0,1],[1,0,1,0,0,1,1,0,1]] -> True

Pyth, 30 29 26 24 23 bayt

sm.Asmmq1ssbCkds./MC./M

Çevrimiçi deneyin.

Bunun daha kısa olacağına eminim. Bu O (2 ^mn ) , m ve n'nin dizinin genişliği ve yüksekliği ancak pille laptopumdaki son iki test senaryosunu 45 saniyede tamamlıyor (sınırlı performansla i5-5200U).

Çözüm sayısını verir.

açıklama

Beş boyutlu dizilerle çalışmak gerçekten eğlenceli. _^</sarcasm> Bunun açıklamada bile nasıl çalıştığını anlamanız gerekmiyor.

                    ./M    Find all partitions of each row. Now we have a list of rows,
                           each containing the ways to split the row, each containing
                           the parts of the split (3D).
                   C       Transpose. Now we have a list of ways to split the columns,
                           each containing the rows, each containing the parts of the
                           row (3D).
                ./M        Find all partitions of each row list. Now we have a list of
                           ways to split the columns, each containing the ways to split
                           the rows, each containing the bunch of rows, each containing 
                           the rows in the bunch, each containing the parts of the row
                           (6D).
               s           Combine the ways to split rows & columns into one array (5D).
 m            d            Do the following for each way to split rows & columns (4D):
     m       k                 Do the following for each bunch of rows (3D):
            C                      Transpose the array. We now have a list of column
                                   groups, each containing the row parts (3D).
      m    b                       Do the following for each column group (2D):
          s                            Combine the row parts in the column group. We now
                                       have the list of cells in this row/column group
                                       (1D).
         s                             Sum the cells.
       q1                              Check if the sum is one.
                                   We now have the list of booleans that tell if each
                                   row/column group is valid (1D).
                               We now have the 2D list of booleans that tell if each
                               row/column group in each bunch of rows is valid. (2D)
    s                          Combine the 2D list of booleans to 1D.
  .A                           Check if all values are truthy; if the split is valid.
                           We now have the validity of each split.
s                          Sum the list to get the number of valid solutions.

Jöle , 22 bayt

ŒṖḅ1S€€=1Ȧ€
SŒṖ⁸ṁþÇ€FS

Çevrimiçi deneyin!

Haskell , 116 bayt

import Data.List
m(a:b)=[a:e|e<-m b]++[zipWith(+)a d:e|d:e<-m b];m e=[e]
d=(any$any$all$all(==1)).map(m.transpose).m

Çevrimiçi deneyin!

Jöle , 20 bayt

ŒṖS€€ỊȦ$ÐfZ€µ⁺€Ȧ€€FS

Bu hala kaba kuvvetli bir çözüm, ancak diğer cevabımdan biraz daha hızlı - bu da TIO'daki son iki test durumuyla başa çıkamıyor - ve tüm test vakalarını ~ 4 saniye içinde ele alıyor.

Çevrimiçi deneyin!

Nasıl çalışır

ŒṖS€€ỊȦ$ÐfZ€µ⁺€Ȧ€€FS  Main link. Argument: M (matrix, array of rows)

ŒṖ                    Compute all partitions, i.e., all groupings of M's rows.
  S€€                 Map sum over all individual groupings, collapsing the grouped
                      rows into a single row.
        Ðf            Filter; keep only those partially collapsed matrices for
                      which the link to the left returns a truthy value.
       $                Group the two links to the left into a monadic chain.
     Ị                    Insignificant; map 0 and 1 to 1, greater integers to 0.
      Ȧ                   All; return 1 iff the matrix contains no zeroes.
          Z€          Zip/transpose all kept matrices,
            µ         Combine all links to the left into a monadic chain.
             ⁺€       Duplicate the chain and map it over the individual results
                      from the first call. We now have all possible combinations
                      of row and column groupings (represented by the corresponding
                      matrices of collapsed rows and columns) that do not have a
                      2 anywhere. However, they still may contain zeroes.
               Ȧ€€    Map the all atom over the matrices, returning 1 only for
                      matrices that consist entirely of ones.
                  FS  Flatten and sum, counting the number of valid divisions.