1. 1
2. 2
3. 3
4. 4
5. 5
6. 6
7. 7
8. 8
9. 9
10. 10
11. 11
12. 12
13. 13
14. 14
15. 15
16. 16
17. 17
18. 18
19. 19
20. 20
21. 21
22. 22
23. 23
24. 24
25. 25
26. 26
27. 27
28. 28
29. 29
30. 30
31. 31
32. 32
33. 33
34. 34
35. 35
36. 36
37. 37
38. 38
39. 39
40. 40
41. 41
42. 42
43. 43
44. 44
45. 45
46. 46
47. 47
48. 48
49. 49
50. 50
51. 51
52. 52
53. 53
54. 54
55. 55
56. 56
57. 57
58. 58
59. 59
60. 60
61. 61
62. 62
63. 63
64. 64
65. 65
66. 66
67. 67
68. 68
69. 69
70. 70
71. 71
72. 72
73. 73
74. 74
75. 75
76. 76
77. 77
78. 78
79. 79
80. 80
81. 81
82. 82
83. 83
84. 84
85. 85
86. 86
87. 87
88. 88
89. 89
90. 90
91. 91
92. 92
93. 93

package main

import (
	"fmt"
	"math"
	"os"
	"strconv"
	"sync"
)

func main() {
	if len(os.Args) != 3 {
		fmt.Println("we need 2 numbers. usage: ./gcd 200 50")
		os.Exit(2)
	}
	a, err := strconv.Atoi(os.Args[1])
	if err != nil {
		fmt.Printf("whatever %s is… I can't make it an integer: %v\n", os.Args[1], err)
		os.Exit(1)
	}
	b, err := strconv.Atoi(os.Args[2])
	if err != nil {
		fmt.Printf("whatever %s is… I can't make it an integer: %v\n", os.Args[2], err)
		os.Exit(1)
	}

	fmt.Println(gcd(a, b))
}

func gcd(a, b int) int {
	if a == 0 || b == 0 {
		return 0
	}

	adiv := make(chan []int)
	bdiv := make(chan []int)

	go getDivisors(a, adiv)
	go getDivisors(b, bdiv)

	adivs := <-adiv
	bdivs := <-bdiv

	var gcd int

	for i := 0; i < len(adivs); i++ {
		for j := 0; j < len(bdivs); j++ {
			if adivs[i] == bdivs[j] && adivs[i] > gcd {
				gcd = adivs[i]
			}
		}
	}

	return gcd
}

func getDivisors(num int, out chan []int) {
	results := make(chan int, 4096)
	joined := make(chan struct{})
	var res []int
	var wg sync.WaitGroup

	go func(r chan int) {
		for i := range r {
			res = append(res, i)
		}
		joined <- struct{}{}
	}(results)

	concurrency := int(math.Ceil(float64(num) / 512))

	for i := 0; i < concurrency; i++ {
		wg.Add(1)
		go func(n, l, u int) {
			defer wg.Done()
			getDivisorsLimit(n, l, u, results)
		}(num, i*512+1, i*512+512)
	}

	wg.Wait()
	close(results)
	<-joined

	out <- res
}

func getDivisorsLimit(num, lowerBound, upperBound int, results chan int) {
	for i := lowerBound; i <= upperBound && i <= num; i++ {
		if num%i == 0 {
			results <- i
		}
	}
}