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


8

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 , daher gewinnt die kürzeste Antwort in Bytes.
  • Standardlücken sind nicht zulässig.

1
Ich würde vorschlagen , einen Testfall Addition gleichartigen L\n\nL, CCCCC\nCCCCC\nC..CC\nCCCCC( .steht für ein Leerzeichen, \nrepräsentiert eine neue Zeile).
Erik der Outgolfer

1
Dürfen wir den LText als eine Liste von Bänden nehmen (dh eine Liste der Anzahl von Ls in jedem Betrag)? Da das Parsen nach Leerzeichen und doppelten Zeilenumbrüchen nichts mit dem Kern der Herausforderung zu tun zu haben scheint. Dürfen wir den CText stattdessen aus demselben Grund auch als Matrix aus zwei unterschiedlichen Werten betrachten?
Jonathan Allan

1
Vorgeschlagener Testfall 3 Lund einer LLmit Leerzeichen der Größe 3 und 2 (ein Algorithmus, der nur kleinste Leerzeichen zuerst mit kleinsten noch zu verwendenden Flüssigkeitsstücken füllt, ergibt Falsey). Vielleicht das gleiche, aber mit 2 Lund einem LLLauch, um für die andere Richtung zu sorgen.
Jonathan Allan

1
Diese Frage scheint mir drei verschiedene Fragen zu sein. Der erste ist das Parsen der Eingabe Lin eine Liste von Ganzzahlen. Die zweite ist das Parsen der Eingabematrix Cin eine Liste von Ganzzahlen. Und die dritte ist eine bestimmte Frage für einen gegebenen ganzzahligen Beutel A und B, wenn es eine Partition in A gibt, wenn alle ganzen Zahlen in jeder Partition summiert werden, um einen Beutel A 'zu erhalten, ist jede n-te größte Zahl in A' kleiner ( <=) als n-te größte Zahl in B '.
tsh

1
Ich glaube, dass die Zeichenform sowieso ein bevorzugtes Eingabeformat für Schnecken wäre. Im Allgemeinen werden bei PPCG lose E / A-Anforderungen bevorzugt, aber es liegt sicherlich an Ihnen.
Jonathan Allan

Antworten:


4

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

2
Könnten Sie der eingerückten Version eine Erklärung hinzufügen? Oder spielen Sie noch weiter Golf, bevor Sie eines hinzufügen?
Kevin Cruijssen

1

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
            )
        )
    ]
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.