func init() {
ways = memoize.Memoize(func(p, max int) int {
if p == 0 {
return 1
}
var total int
if p >= 1 && max >= 1 {
total += ways(p-1, 1)
}
if p >= 2 && max >= 2 {
total += ways(p-2, 2)
}
if p >= 5 && max >= 5 {
total += ways(p-5, 5)
}
if p >= 10 && max >= 10 {
total += ways(p-10, 10)
}
if p >= 20 && max >= 20 {
total += ways(p-20, 20)
}
if p >= 50 && max >= 50 {
total += ways(p-50, 50)
}
if p >= 100 && max >= 100 {
total += ways(p-100, 100)
}
if p >= 200 && max >= 200 {
total += ways(p-200, 200)
}
return total
}).(func(int, int) int)
}
func TestPanic(t *testing.T) {
count := 0
f := func(i int) {
count++
if count%2 == 1 {
panic(count)
}
}
f = memoize.Memoize(f).(func(int))
expect := func(p interface{}, i int) {
defer func() {
if r := recover(); p != r {
t.Errorf("for input %d:\nexpected: %v\nactual: %v", i, p, r)
}
}()
f(i)
}
expect(1, 1)
expect(1, 1)
expect(nil, 2)
expect(nil, 2)
expect(1, 1)
expect(3, 100)
}
func TestVariadic(t *testing.T) {
count := 0
var concat func(string, ...string) string
concat = func(s0 string, s1 ...string) string {
count++
if len(s1) == 0 {
return s0
}
return concat(s0+s1[0], s1[1:]...)
}
concat = memoize.Memoize(concat).(func(string, ...string) string)
expect := func(actual, expected string, n int) {
if actual != expected || n != count {
t.Errorf("expected: %q\nactual: %q\nexpected count: %d\nactual count: %d", expected, actual, n, count)
}
}
expect("", "", 0)
expect(concat("string"), "string", 1)
expect(concat("string", "one"), "stringone", 3)
expect(concat("string", "one"), "stringone", 3)
expect(concat("string", "two"), "stringtwo", 5)
expect(concat("string", "one"), "stringone", 5)
expect(concat("stringone", "two"), "stringonetwo", 7)
expect(concat("string", "one", "two"), "stringonetwo", 8)
}
func init() {
paths = memoize.Memoize(func(w, h int) int {
if w == 0 || h == 0 {
return 1
}
n := paths(w-1, h) + paths(w, h-1)
return n
}).(func(w, h int) int)
}
func init() {
compute = memoize.Memoize(func(x, y int) int {
if y >= len(triangle) {
return 0
}
n := compute(x, y+1)
if m := compute(x+1, y+1); m > n {
n = m
}
n += triangle[y][x]
return n
}).(func(x, y int) int)
}
}
func nonAbundantSum(n int) bool {
for i := 12; i < n; i++ {
if !isAbundant(i) {
continue
}
if isAbundant(n - i) {
return false
}
}
return true
}
func isAbundant(n int) bool {
return d(n) > n
}
var d = memoize.Memoize(func(n int) int {
var sum int
for i := 1; i < n; i++ {
if n%i == 0 {
sum += i
}
}
return sum
}).(func(n int) int)
for a := -999; a <= 999; a++ {
for b := -999; b <= 999; b++ {
if c := count(a, b); c > max {
maxA, maxB, max = a, b, c
}
}
}
fmt.Println(maxA * maxB)
}
func count(a, b int) int {
var c int
for n := 0; isPrime(n*n + a*n + b); n++ {
c++
}
return c
}
var isPrime = memoize.Memoize(func(i int) bool {
if i < 2 {
return false
}
for j := 2; j*j <= i; j++ {
if i%j == 0 {
return false
}
}
return true
}).(func(int) bool)