aboutsummaryrefslogtreecommitdiff
path: root/main.go
blob: c53e2a387a22c7c213d93b0a9d4a5d2b7a7ca9c2 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
package main

import (
	"fmt"
	"log"
)

type testCase struct {
	First, Second, Expect string
}

var (
	alphabet = []string{
		"zero",
		"one",
		"two",
		"tree",
		"four",
		"five",
		"six",
		"seven",
		"eight",
		"nine",
		"ten",
		"eleven",
		"twelve",
		"thirteen",
		"fourteen",
		"fifteen",
		"sixteen",
		"seventeen",
		"eighteen",
		"nineteen",
		"twenty",
	}
	zero     = alphabet[0]
	one      = alphabet[1]
	casesAdd = []testCase{
		testCase{"two", "two", "four"},
		testCase{"two", "five", "seven"},
		testCase{"two", "zero", "two"},
	}
	casesTimes = []testCase{
		testCase{"two", "two", "four"},
		testCase{"two", "tree", "six"},
	}
	casesPot = []testCase{
		testCase{"one", "two", "one"},
		testCase{"two", "two", "four"},
		testCase{"two", "tree", "eight"},
	}
	casesSub = []testCase{
		testCase{"seven", "five", "two"},
		testCase{"two", "zero", "two"},
		testCase{"four", "two", "two"},
	}
)

// next returns next char in alphabet
func next(n string) string {
	for i, v := range alphabet {
		if i == len(alphabet)-1 {
			log.Fatal("out of range")
		}
		if v == n {
			return alphabet[i+1]
		}
	}
	return zero
}

// prev returns previous char in alphabet
func prev(n string) string {
	if n == zero {
		return zero
	}
	for i, v := range alphabet {
		if v == n {
			return alphabet[i-1]
		}
	}
	return zero
}

// add defines addition
func add(m, n string) string {
	if m == zero {
		return n
	}
	return next(add(prev(m), n))
}

// times defines mutiplication
func times(m, n string) string {
	if m == zero {
		return zero
	}
	return add(times(prev(m), n), n)
}

// pot defines power function
func pot(m, n string) string {
	if n == zero {
		return one
	}
	return times(pot(m, prev(n)), m)
}

// sub defines substraction
func sub(m, n string) string {
	if n == zero {
		return m
	}
	return prev(sub(m, prev(n)))
}

// test permoms tests
func test(f func(string, string) string, op string, cases []testCase) {
	for _, c := range cases {
		r := f(c.First, c.Second)
		fmt.Println(r == c.Expect, c.First, op, c.Second, "=", r)
	}
}

func main() {
	test(add, "+", casesAdd)
	test(times, "*", casesTimes)
	test(pot, "^", casesPot)
	test(sub, "-", casesSub)
}