Es gibt P-Parkplätze auf einem Parkplatz, obwohl einige Plätze von Autos belegt sind, die durch Oktothorphen dargestellt werden, #während die freien Plätze Punkte sind .. Bald kommen dort T-Trucks an, von denen jeder genau L aufeinanderfolgende Plätze einnehmen wird. Die LKWs müssen nicht nebeneinander geparkt werden.

Ihre Aufgabe ist es, ein Programm zu erstellen, das die geringste Anzahl von Autos findet, die entfernt werden müssen, um alle Lastwagen zu parken. Es wird immer genug Platz geben, um alle Lastwagen unterzubringenT*L<P

Eingang

In der ersten Zeile gibt es drei Ganzzahlen, P, T und L, die durch Leerzeichen getrennt sind. In der zweiten Zeile befindet sich eine Folge von P Zeichen, die den Parkplatz in seinem Ausgangszustand darstellen.

Ausgabe

In der ersten und einzigen Zeile sollte Ihr Programm die kleinste Anzahl von Autos ausdrucken, die entfernt werden müssen, um alle Lastwagen zu parken.

Testfälle

Eingang:
6 1 3
#.#.##

Ausgabe: 1

Eingang:
9 2 3
.##..#..#

Ausgabe: 2

Eingang:
15 2 5
.#.....#.#####.

Ausgabe: 3

Der kürzeste Code gewinnt. (Hinweis: Ich bin besonders an einer Python-Implementierung interessiert, falls eine möglich ist.)

Python 2, 154 Bytes

I,R=raw_input,range
P,T,L=map(int,I().split())
S=I()
D=R(P+1)
for r in R(P):D[1:r+2]=[min([D[c],D[c-1]+(S[r]<".")][c%L>0:])for c in R(1,r+2)]
print D[T*L]

Ein unkomplizierter DP-Ansatz. Ein fairer Teil des Programms liest nur Eingaben.

Erläuterung

Wir berechnen eine dynamische 2D-Programmiertabelle, in der jede Zeile den ersten nParkplätzen entspricht und jede Spalte der Anzahl der bisher platzierten LKWs (oder Teile eines LKWs) entspricht. Insbesondere kbedeutet Spalte , dass wir bisher k//Lvolle LKWs platziert haben und k%Lauf dem Weg zu einem neuen LKW sind. Jede Zelle ist dann die minimale Anzahl von Autos, die gelöscht werden müssen, um den Zustand zu erreichen (n,k), und unser Zielzustand ist (P, L*T).

Die Idee hinter der DP-Wiederholung ist die folgende:

• Wenn wir Platz k%L > 0für einen neuen LKW haben, besteht unsere einzige Möglichkeit darin, Platz k%L-1für einen neuen LKW zu haben
• Andernfalls, wenn k%L == 0wir dann entweder gerade einen neuen LKW fertiggestellt haben oder den letzten LKW bereits fertiggestellt haben und seitdem einige Parkplätze übersprungen haben. Wir nehmen das Minimum der beiden Optionen.

Wenn k > nwir also mehr LKW-Plätze platziert haben, als es Parkplätze gibt, dann setzen wir ∞auf Staat (n,k). Aber zum Zwecke des Golfspiels setzen wir, kda dies der schlimmste Fall ist, jedes Auto zu entfernen, und auch als Obergrenze dient.

Das war ein ziemlicher Schluck, also lassen Sie uns ein Beispiel geben, sagen wir:

5 1 3
..##.

Die letzten beiden Zeilen der Tabelle sind

[0, 1, 2, 1, 2, ∞]
[0, 0, 1, 1, 1, 2]

Der Eintrag bei Index 2 der vorletzten Zeile ist 2, da dies die einzige Option ist, um einen Zustand 2//3 = 0voller platzierter LKWs zu erreichen, die platziert sind und Platz 2%3 = 2für einen neuen LKW bieten:

  TT
..XX

Der Eintrag bei Index 3 der vorletzten Zeile ist jedoch 1, da das Optimum erreicht ist , um einen Zustand 3//3 = 1voller platzierter LKWs zu erreichen, die Platz 3%3 = 0für einen neuen LKW bieten

TTT
..X#

Der Eintrag in Index 3 der letzten Zeile betrachtet die beiden oben genannten Zellen als Optionen. Nehmen wir den Fall, in dem wir zwei Leerzeichen für einen neuen LKW haben, und beenden Sie ihn, oder nehmen wir den Fall, in dem wir einen vollen LKW haben schon fertig?

  TTT            TTT
..XX.     vs     ..X#.

Letzteres ist eindeutig besser, also setzen wir eine 1.

Pyth, 70 Bytes

JmvdczdKw=GUhhJVhJ=HGFTUhN XHhThS>,@GhT+@GTq@KN\#>%hT@J2Z)=GH)@G*@J1eJ

Grundsätzlich ein Port des obigen Codes. Noch nicht sehr gut Golf gespielt. Probieren Sie es online aus

Erweitert

Jmvdczd              J = map(eval, input().split(" "))
Kw                   K = input()
=GUhhJ               G = range(J[0]+1)
VhJ                  for N in range(J[0]):
=HG                    H = G[:]
FTUhN                  for T in range(N+1):
 XHhT                    H[T+1] =
hS                                sorted(                                        )[0]
>                                                                 [            :]
,                                        (      ,                )
@GhT                                      G[T+1]
+@GTq@KN\#                                       G[T]+(K[N]=="#")
>%hT@J2Z                                                           (T+1)%J[2]>0
)=GH                   G = H[:]
)@G*@J1eJ            print(G[J[1]*J[-1]])

Wenn nur Pyth mehrere Zuordnungen zu> 2 Variablen hätte ...

Haskell, 196 Zeichen

import Data.List
f=filter
m=map
q[_,t,l]=f((>=t).sum.m((`div`l).length).f(>"-").group).sequence.m(:".")
k[a,p]=minimum.m(sum.m fromEnum.zipWith(/=)p)$q(m read$words a)p
main=interact$show.k.lines

Führt alle Beispiele aus

& (echo 6 1 3 ; echo "#.#.##" )  | runhaskell 44946-Trucks.hs 
1

& (echo 9 2 3 ; echo ".##..#..#" )  | runhaskell 44946-Trucks.hs 
2

& (echo 15 2 5 ; echo ".#.....#.#####." )  | runhaskell 44946-Trucks.hs 
3

Etwas langsam: O (2 ^ P) wo P ist die Größe des Loses.

Wahrscheinlich gibt es hier noch viel zu golfen.