WIP: not working
parent
1c7732cf32
commit
ad900e8767
@ -0,0 +1,267 @@
|
||||
package bucket
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"sort"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// Buckets manages bucket objects
|
||||
type Buckets []Bucket
|
||||
|
||||
// // action name
|
||||
type actionType int
|
||||
|
||||
const (
|
||||
actionTypeUnknown actionType = iota
|
||||
actionTypeEmpty
|
||||
actionTypeFill
|
||||
actionTypePour
|
||||
)
|
||||
|
||||
type action struct {
|
||||
kind actionType
|
||||
src int
|
||||
target int
|
||||
}
|
||||
|
||||
type actions []action
|
||||
|
||||
func (a actions) String() string {
|
||||
acts := []string{}
|
||||
for _, act := range a {
|
||||
acts = append(acts, act.String())
|
||||
}
|
||||
return fmt.Sprintf("[%s]", strings.Join(acts, ","))
|
||||
}
|
||||
|
||||
func (a action) String() string {
|
||||
switch a.kind {
|
||||
case actionTypeEmpty:
|
||||
return fmt.Sprintf("empty %d ", a.target)
|
||||
case actionTypeFill:
|
||||
return fmt.Sprintf("fill %d ", a.target)
|
||||
case actionTypePour:
|
||||
return fmt.Sprintf("pour %d → %d", a.src, a.target)
|
||||
case actionTypeUnknown:
|
||||
}
|
||||
return fmt.Sprintf("unknown (src: %d, target: %d)", a.src, a.target)
|
||||
}
|
||||
|
||||
type result struct {
|
||||
mapping map[string][]actions
|
||||
matched map[string]interface{}
|
||||
}
|
||||
|
||||
func (r *result) get(key string) ([]actions, bool) {
|
||||
acts, ok := r.mapping[key]
|
||||
return acts, ok
|
||||
}
|
||||
|
||||
func (r *result) keys() []string {
|
||||
keys := []string{}
|
||||
for key := range r.mapping {
|
||||
keys = append(keys, key)
|
||||
}
|
||||
sort.Strings(keys)
|
||||
return keys
|
||||
}
|
||||
|
||||
func (r *result) matchedKeys() []string {
|
||||
keys := []string{}
|
||||
for key := range r.matched {
|
||||
keys = append(keys, key)
|
||||
}
|
||||
sort.Strings(keys)
|
||||
return keys
|
||||
}
|
||||
|
||||
func (r *result) bestMatches() ([]string, bool) {
|
||||
var best []string
|
||||
found := false
|
||||
numActions := 0
|
||||
|
||||
matched := r.matchedKeys()
|
||||
for _, key := range matched {
|
||||
acts, ok := r.get(key)
|
||||
if found == false && ok && len(acts) > 0 {
|
||||
found = true
|
||||
numActions = len(acts[0])
|
||||
best = []string{key}
|
||||
continue
|
||||
}
|
||||
|
||||
if numActions > len(acts[0]) {
|
||||
numActions = len(acts[0])
|
||||
best = []string{key}
|
||||
} else if numActions == len(acts[0]) {
|
||||
best = append(best, key)
|
||||
}
|
||||
}
|
||||
|
||||
if !found {
|
||||
return nil, false
|
||||
}
|
||||
return best, true
|
||||
}
|
||||
|
||||
func (r *result) addMatch(key string) {
|
||||
r.matched[key] = struct{}{}
|
||||
}
|
||||
|
||||
func (r *result) addActions(key string, acts actions) bool {
|
||||
currentActions, ok := r.mapping[key]
|
||||
if !ok || len(currentActions) == 0 {
|
||||
currentActions = []actions{acts}
|
||||
r.mapping[key] = currentActions
|
||||
return true
|
||||
}
|
||||
|
||||
if len(acts) > len(currentActions[0]) {
|
||||
return false
|
||||
}
|
||||
|
||||
if len(acts) == len(currentActions[0]) {
|
||||
r.mapping[key] = append(currentActions, acts)
|
||||
return true
|
||||
}
|
||||
|
||||
r.mapping[key] = []actions{acts}
|
||||
return true
|
||||
}
|
||||
|
||||
func (b Buckets) empty(index int) {
|
||||
buk := &b[index]
|
||||
buk.Empty()
|
||||
b[index] = *buk
|
||||
}
|
||||
|
||||
func (b Buckets) fill(index int) {
|
||||
buk := &b[index]
|
||||
buk.Fill()
|
||||
b[index] = *buk
|
||||
}
|
||||
|
||||
func (b Buckets) pour(i, j int) {
|
||||
src := &b[i]
|
||||
dest := &b[j]
|
||||
src.Pour(dest)
|
||||
b[i] = *src
|
||||
b[j] = *dest
|
||||
}
|
||||
|
||||
// HasTarget returns true
|
||||
func (b Buckets) HasTarget(target uint64) bool {
|
||||
for _, bucket := range b {
|
||||
if bucket.Volume == target {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func (b Buckets) String() string {
|
||||
bucketStrs := []string{}
|
||||
for _, bucket := range b {
|
||||
bucketStrs = append(bucketStrs, bucket.String())
|
||||
}
|
||||
return fmt.Sprintf("[%s]", strings.Join(bucketStrs, ","))
|
||||
}
|
||||
|
||||
// FindTarget returns actions to find target
|
||||
func (b Buckets) FindTarget(target uint64) []string {
|
||||
r := &result{
|
||||
mapping: map[string][]actions{},
|
||||
matched: map[string]interface{}{},
|
||||
}
|
||||
b.findTarget(target, r, actions{})
|
||||
|
||||
keys, found := r.bestMatches()
|
||||
if !found {
|
||||
return []string{"No solution"}
|
||||
}
|
||||
fmt.Printf("%d solutions\n", len(keys))
|
||||
for i, key := range keys {
|
||||
allacts, ok := r.get(key)
|
||||
if !ok {
|
||||
continue
|
||||
}
|
||||
newState := make(Buckets, len(b))
|
||||
copy(newState, b)
|
||||
fmt.Printf("solution %d\n", i+1)
|
||||
for _, acts := range allacts {
|
||||
if len(acts) == 0 {
|
||||
fmt.Println("no actions required")
|
||||
continue
|
||||
}
|
||||
for _, act := range acts {
|
||||
newState = newState.performAction(act)
|
||||
fmt.Printf("%s\t%s\n", act.String(), newState.String())
|
||||
}
|
||||
}
|
||||
}
|
||||
ret := []string{}
|
||||
return ret
|
||||
}
|
||||
|
||||
func (b Buckets) performAction(act action) Buckets {
|
||||
newState := make(Buckets, len(b))
|
||||
copy(newState, b)
|
||||
|
||||
switch act.kind {
|
||||
case actionTypeEmpty:
|
||||
newState.empty(act.target)
|
||||
case actionTypeFill:
|
||||
newState.fill(act.target)
|
||||
case actionTypePour:
|
||||
newState.pour(act.src, act.target)
|
||||
}
|
||||
|
||||
return newState
|
||||
}
|
||||
|
||||
func (b Buckets) findTarget(
|
||||
target uint64,
|
||||
states *result,
|
||||
prevActions actions,
|
||||
) {
|
||||
key := b.String()
|
||||
|
||||
added := states.addActions(key, prevActions)
|
||||
|
||||
if b.HasTarget(target) {
|
||||
states.addMatch(key)
|
||||
return
|
||||
}
|
||||
|
||||
if !added {
|
||||
return
|
||||
}
|
||||
|
||||
possibleActions := b.possibleActions()
|
||||
for _, act := range possibleActions {
|
||||
newActions := append(prevActions, act)
|
||||
newState := b.performAction(act)
|
||||
newState.findTarget(target, states, newActions)
|
||||
}
|
||||
}
|
||||
|
||||
func (b Buckets) possibleActions() actions {
|
||||
ret := actions{}
|
||||
for i, bucket := range b {
|
||||
if !bucket.IsFull() {
|
||||
ret = append(ret, action{kind: actionTypeFill, target: i})
|
||||
}
|
||||
if !bucket.IsEmpty() {
|
||||
// ret = append(ret, action{kind: actionTypeEmpty, fn: b.empty(i), target: i})
|
||||
ret = append(ret, action{kind: actionTypeEmpty, target: i})
|
||||
for j, target := range b {
|
||||
if !target.IsFull() && i != j {
|
||||
// ret = append(ret, action{kind: actionTypePour, fn: b.pour(i, j), src: i, target: j})
|
||||
ret = append(ret, action{kind: actionTypePour, src: i, target: j})
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return ret
|
||||
}
|
Loading…
Reference in New Issue