package main

	import (
		"bytes"
		"fmt"
	)

	func main() {
		CountdownSolver(Pop([]int{1, 3, 7, 6, 8, 3, 250}))
		CountdownSolver(Pop([]int{25, 100, 9, 7, 3, 7, 881}))
		CountdownSolver(Pop([]int{6, 75, 3, 25, 50, 100, 952}))
	}

	func CountdownSolver(s int, a []int) {
		c := make([]int, len(a))
		m := make(map[string]bool)

		for i := 0; i < len(a); {
			if i == 0 {
				if _, ok := m[AToS(a)]; !ok {
					m[AToS(a)] = true
					if eq, ok := Solve(s, a); ok {
						fmt.Println(eq, "=", s)
					}
				}
			}

			if c[i] < i {
				if i%2 == 0 {
					a[0], a[i] = a[i], a[0]
				} else {
					a[i], a[c[i]] = a[c[i]], a[i]
				}

				c[i]++
				i = 0
			} else {
				c[i] = 0
				i++
			}
		}
	}

	func AToS(v []int) string {
		var buffer bytes.Buffer

		for _, e := range v {
			buffer.WriteString(fmt.Sprint(e, ","))
		}

		return buffer.String()
	}

	func Solve(s int, p []int) (string, bool) {
		ops := GetOperators()

		for _, op := range ops {
			if ApplyOps(p, op) == s {
				return GetEq(p, op), true
			}
		}
		return "", false
	}

	func GetOperators() [][]int {
		var res [][]int
		for i := 0; i < 4; i++ {
			for j := 0; j < 4; j++ {
				for k := 0; k < 4; k++ {
					for l := 0; l < 4; l++ {
						for m := 0; m < 4; m++ {
							res = append(res, []int{i, j, k, l, m})
						}
					}
				}
			}
		}
		return res
	}

	func ApplyOps(p []int, op []int) int {
		s := p[0]
		for i := 1; i < len(p); i++ {
			s = ApplyOp(s, p[i], op[i-1])
		}
		return s
	}

	func ApplyOp(a int, b int, op int) int {
		switch op {
		case 0:
			return a + b
		case 1:
			return a - b
		case 2:
			return a * b
		case 3:
			return a / b
		}
		return 0
	}

	func GetEq(p []int, op []int) string {
		var buffer bytes.Buffer

		buffer.WriteString(fmt.Sprint(p[0]))

		for i := 1; i < len(p); i++ {
			buffer.WriteString(fmt.Sprint(" ", GetOp(op[i-1]), " ", p[i]))
		}

		return buffer.String()
	}

	func GetOp(op int) string {
		switch op {
		case 0:
			return "+"
		case 1:
			return "-"
		case 2:
			return "*"
		case 3:
			return "/"
		}
		return ""

	}

	func Pop(a []int) (int, []int) {
		return a[len(a)-1], a[:len(a)-1]
	}