Kann dieser Behälter so viel Flüssigkeit aufnehmen?

Synopse herausfordern

Wie Sie höchstwahrscheinlich wissen, haben Flüssigkeiten eine unbestimmte Form und ein bestimmtes Volumen. Als solche nehmen sie immer die Form ihres Behälters an. Sie können sich jedoch nicht erweitern, um ihren Container zu füllen.

Ihre heutige Aufgabe ist es zu bestimmen, ob eine bestimmte Menge an Flüssigkeit (dargestellt durch eine bestimmte Anzahl von LZeichen oder Zahlen, die das Volumen des Teils darstellen, gemäß Vorschlag) in einen Behälter einer bestimmten Größe (dargestellt durch eine Matrix von) passen kann oder nicht CZeichen) mit einer gewissen Menge an Leerzeichen (dargestellt durch Leerzeichen). Der Container enthält immer CZeichen rund um den Umfang.

Ihr Programm gibt einen Wahrheits- / Falschwert zurück, der davon abhängt, ob die Flüssigkeit in den Behälter passt. Es passt nur, wenn für jeden Teil der Flüssigkeit, der vom Rest getrennt ist (entweder durch einen Raum oder durch zwei Zeilenumbrüche).

Testfälle

LLL
L
-----    True
CCCCC
C  CC
C  CC
CCCCC

LLL
 LL
------   True
CCCCCC
C C  C
C  CCC
CCCCCC

L L
LLL
-----    False (Not enough space)
CCCCC
CCCCC
C  CC
CCCCC

LL
------   False (Spaces are not connected but liquid is)
CCCCCC
CCCC C
C CCCC
CCCCCC

L L
------   True
CCCCCC
CCCC C
C CCCC
CCCCCC

L L
------   True (There is a pocket of empty space which holds both parts of the liquid)
CCCCCC
CCC  C
CCCCCC
CCCCCC

L

L
------   True (There is a pocket of empty space for each part of the liquid)
CCCCCC
CCCC C
C CCCC
CCCCCC

L L L LL
------   True
CCCCCCCCC
CCCC  C C
C CCCCCCC
CCCCCC CC
CCCCCCCCC

L
L
-----    True
CCCCC
CCCCC
C  CC
CCCCC

Fühlen Sie sich frei, Testfälle vorzuschlagen!

Regeln

• Dies ist Code-Golf , daher gewinnt die kürzeste Antwort in Bytes.
• Standardlücken sind nicht zulässig.

Schnecken, 58 Bytes

Die Eingabe erfolgt genau wie in den Beispielen.

t\ t\L{t\L?t\ z!.o=(\ ,\C},!(tz(\L!.!~|\ !.o=(\ ,\C},!(t\L

Eine 4 Byte längere Version ist schnell genug, um die Testfälle sofort abzuschließen (Testen Sie diese Version online ):

?^
t\ t\L{t\L`?t\ z!.o=(\ ,\C},!(tz(\L!.!~|\ !.o=(\ ,\C},!(t\L

Eine eingerückte Formatierung des letzteren:

?^
    t\ 
    t\L
    {
        t\L`?
        t\ 
        z!.
        o=(\ ,\C
    },
    !(tz(
         \L!.!~
         |
         \ !.o=(\ ,\C
},
!(t\L

Sauber , 313 Bytes

import StdEnv,Data.List
?v=nub[v:[[sum s:k]\\s<-subsequences v|s>[],k<- ?(difference v s)]]
$v m#p=[[(x,y)]\\x<-[0..]&l<-m,y<-[0..]&' '<-l]
=or[and(zipWith(>=)(s++[0,0..])r)\\r<- ?v,s<-permutations(map length(foldl(\p _=nub[sort(nub(e++[(x,y)\\(u,v)<-e,x<-[u-1,u,u+1],y<-[v-1,v,v+1]|(m!!x)!!y<'C']))\\e<-p])p p))]

Probieren Sie es online aus!

Definiert die Funktion $ :: [Int] [[Char]] -> Bool. Der TIO-Link enthält einen Wrapper um STDIN.

? :: [Int] -> [[Int]] ist ein Helfer, um die verschiedenen Möglichkeiten zu generieren, wie die Volumes kombiniert werden können.

Erweitert:

$ v m // in function $ of v and m
    # p // define p as
        = [ // a list of
            [(x, y)]    // lists of pairs (x, y)
        \\              // for each
            x <- [0..]  // index x
            & l <- m    // at list l in m
        ,               // for each
            y <- [0..]  // index y
            & ' ' <- l  // at spaces in l
        ]
    = or [ // true if any of the list of
        and (               // true if all of
            zipWith         // element-wise application of
                (>=)            // greater than or equal to
                (s ++ [0, 0..]) // permutation s padded with zeroes
                v               // list v of volumes
        )
    \\                      // for each
        s <- permutations ( // permutation s of
            map length (    // the lengths of
                foldl       // a left-fold of
                    (\p _   // function on p discarding second argument
                        = nub [ // the unique elements of the list of
                            sort (          // sorted versions of
                                nub (       // unique lists composed of
                                    e       // list e of points in a region
                                    ++ [    // prepended to the list of
                                        (x, y)      // pairs (x, y)
                                    \\              // for each
                                        (u, v) <- e // pair (u, v) in list e
                                    ,               // for each
                                        x <- [u-1, u, u+1] // x-coordinate adjacent to u
                                    ,               // for each
                                        y <- [v-1, v, v+1] // y-coordinate adjacent to v
                                    |               // where
                                        (m!!x)!!y < 'C' // the character in m at (x, y) is a space
                                    ]
                                )
                            )
                        \\          // for each
                            e <- p  // region e in p
                        ]
                    )
                    p // applied to a starting argument of p
                    p // recursively, for each element in p
            )
        )
    ]