-
Notifications
You must be signed in to change notification settings - Fork 0
/
fizzbuzz.go
157 lines (120 loc) · 2.21 KB
/
fizzbuzz.go
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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
// Package fizzbuzz is all about demonstrating and testing GO in various ways
package fizzbuzz
// Constants to demonstrate the challenge
const (
FIZZ = 3 // multiples of 3 yield fizz
BUZZ = 5 // multiples of 5 yield buzz
FIZZBUZZ = 15 // finally, multiples of 15 yield fizzbuzz
)
// Type1 is the most performant I could come up with
func Type1(i int) string {
if i%FIZZ == 0 {
if i%BUZZ == 0 {
return "FIZZBUZZ"
}
return "FIZZ"
}
if i%BUZZ == 0 {
return "BUZZ"
}
return string(rune(i))
}
// Type2 is clearer than Type1
func Type2(i int) string {
if i%FIZZ == 0 && i%BUZZ == 0 {
return "FIZZBUZZ"
}
if i%FIZZ == 0 {
return "FIZZ"
}
if i%BUZZ == 0 {
return "BUZZ"
}
return string(rune(i))
}
// Type3 tosses in a bool for working
func Type3(i int) string {
p := false
if i%FIZZ == 0 {
p = true
}
if i%BUZZ == 0 {
if p {
return "FIZZBUZZ"
}
return "BUZZ"
}
if p {
return "FIZZ"
}
return string(rune(i))
}
// Type4 demonstrates how messing with the immutable strings is costly
func Type4(i int) string {
p := false
r := ""
if i%FIZZ == 0 {
r += "FIZZ"
p = true
}
if i%BUZZ == 0 {
r += "BUZZ"
p = true
}
if !p {
return string(rune(i))
}
return r
}
// Type5 uses a switch though appears less performant than Type2
func Type5(i int) string {
switch {
case i%FIZZ == 0 && i%BUZZ == 0:
return "FIZZBUZZ"
case i%FIZZ == 0:
return "FIZZ"
case i%BUZZ == 0:
return "BUZZ"
}
return string(rune(i))
}
// Type6 is exactly like Type1 but works with without the constants defined before
func Type6(i int) string {
if i%3 == 0 {
if i%5 == 0 {
return "FIZZBUZZ"
}
return "FIZZ"
}
if i%5 == 0 {
return "BUZZ"
}
return string(rune(i))
}
// Type7 is like Type1 but without the nested start
func Type7(i int) string {
if i%FIZZBUZZ == 0 {
return "FIZZBUZZ"
}
if i%FIZZ == 0 {
return "FIZZ"
}
if i%BUZZ == 0 {
return "BUZZ"
}
return string(rune(i))
}
// Type8 does the same as type5 but with a named return
func Type8(i int) (result string) {
switch {
case i%FIZZ == 0 && i%BUZZ == 0:
result = "FIZZBUZZ"
case i%FIZZ == 0:
result = "FIZZ"
case i%BUZZ == 0:
result = "BUZZ"
default:
result = string(rune(i))
}
return
}