Merge pull request #2541 from jeongoon/master

[ch-082/jeongoon] Go solution added.

2 files changed, 211 insertions, 0 deletions

diff --git a/challenge-082/jeongoon/go/ch-1.go b/challenge-082/jeongoon/go/ch-1.go
new file mode 100644
index 0000000000..1205ad51df
--- /dev/null
+++ b/challenge-082/jeongoon/go/ch-1.go
@@ -0,0 +1,112 @@
+/*
+ * test with : go run ch-1.go 12 8
+ * Ref: https://www.admfactory.com/convert-string-to-int-golang/
+ *      https://stackoverflow.com/questions/13247644/tostring-function-in-go
+ */
+
+/* Comment:
+ * I cannot see why go is popular... T.T
+ */
+
+package main
+
+import (
+	"os"
+	"fmt"
+	"strings"
+	"strconv"
+)
+
+func usage() {
+	fmt.Println( "Usage: go run ch-1.go <natural num> <natural num>" )
+}
+
+
+type MaybeNat string
+
+func (str MaybeNat) Nat() Nat {
+	n, err := strconv.Atoi(string(str))
+	if err == nil {
+		return(Nat(n))
+	} else {
+		return(Nat(0))
+	}
+}
+
+func (str MaybeNat) isNatural() bool {
+	return(str.Nat() > 0)
+}
+
+type Nat int
+func (n Nat) String() string {
+	return fmt.Sprintf("%d", n)
+}
+
+func gcd(m int, n int) int { // a not bad gcd implementation
+	var sm, bg int
+
+	if m == n {
+		return(m)
+	} else if m < n {
+		sm, bg = m, n
+	} else {
+		sm, bg = n, m
+	}
+
+	if bg % sm == 0 {
+		return(sm)
+	}
+
+	for i := sm-1; i > 0; i-- {
+		if bg % i == 0 && sm % i == 0  {
+			return(i)
+		}
+	}
+	// cannot reach here but have to mention
+	return(1)
+}
+
+func commonDivisors (a int, b int) []int {
+	var result []int
+	gcd := gcd(a,b)
+
+	for i := 1; i <= gcd; i++ {
+		if gcd % i == 0 {
+			result = append(result, i);
+		}
+	}
+	return result
+}
+
+func main() {
+	if len(os.Args[1:]) != 2 {
+		usage();
+		os.Exit(1);
+	}
+
+	var N []Nat
+	all_good := true
+
+	for _, str := range os.Args[1:3] {
+		if MaybeNat(str).isNatural() {
+			N = append(N, MaybeNat(str).Nat())
+		} else {
+			all_good = false
+			break
+		}
+	}
+
+	if ! all_good {
+		usage();
+		os.Exit(2);
+	}
+
+	cvs := commonDivisors(int(N[0]), int(N[1]))
+
+	var S []string
+	for _, n := range(cvs) {
+		S = append(S, Nat(n).String())
+	}
+
+	fmt.Println( "(" + strings.Join(S, ", ") + ")" )
+}
diff --git a/challenge-082/jeongoon/go/ch-2.go b/challenge-082/jeongoon/go/ch-2.go
new file mode 100644
index 0000000000..10b66cf142
--- /dev/null
+++ b/challenge-082/jeongoon/go/ch-2.go
@@ -0,0 +1,99 @@
+/*
+ * note: this is different approach when compared to my other solutions
+ *
+ * checking just interleaving or not (non-recursive version)
+ *
+ * Tested with:
+
+  *  go run ch-2.go ABCDEFGHIJKLMNOPQRSTUVWXYZ ABCDEFGHIJKLMNOPQRSTUVWXYZ ABCABCDDEFGHIJEFKLGHIJKLMNMNOOPPQRQRSTUVSTWXYUVWXYZZ #  -> 1
+  *  go run ch-2.go XY XX XYXX #  -> 1
+  *  go run ch-2.go YX X XXY   #  -> 0
+  */
+
+package main
+
+import (
+	"os"
+	"fmt"
+)
+
+func isInterleaving (A string, B string, C string) bool {
+	Alen, Blen, Clen := len(A), len(B), len(C)
+	if Alen + Blen != Clen {
+		return false
+	}
+
+	Apin, Bpin := -1, -1
+	checkpingPlanB := false
+
+	for Ai, Bi, Ci := 0, 0, 0 ;; Ci = Ai + Bi {
+		if checkpingPlanB {
+			if Bpin > 0 {
+				// note: it was A[Ai] == B[Bi] == C[Ci]
+				// and tried A already.
+				Bi = Bpin + 1
+				Ai = Apin
+				Apin, Bpin = -1, -1
+				checkpingPlanB = false
+			} else {
+				// there is no plan B ...
+				return false
+			}
+			continue
+		} else {
+			if Ci == Clen {
+				return true
+			}
+			if Ai == Alen {
+				if B[Bi:] == C[Ci:] {
+					return true
+				} else {
+					checkpingPlanB = true
+					continue
+				}
+			} else if Bi == Blen {
+				return A[Ai:] == C[Ci:]
+			}
+
+			if A[Ai] == B[Bi] {
+
+				if A[Ai] != C[Ci] {
+					checkpingPlanB = true
+				}  else {
+					// remember this node
+					Apin, Bpin = Ai, Bi
+					// try plan A first
+					Ai++
+				}
+			} else {
+
+				if A[Ai] == C[Ci] {
+					Ai++
+				} else if B[Bi] == C[Ci] {
+					Bi++
+				} else {
+					checkpingPlanB = true
+				}
+			}
+		}
+	}
+}
+
+func usage() {
+	fmt.Println( "Usage: go run ch-2.go " +
+		"<string> <string> <may be interleaved string>\n" )
+}
+
+func main() {
+	if len(os.Args[1:]) != 3 {
+		usage();
+		os.Exit(1);
+	}
+	A, B, C := os.Args[1], os.Args[2], os.Args[3]
+
+	if isInterleaving(A, B, C) {
+		fmt.Println( "1" )
+	} else {
+		fmt.Println( "0" )
+	}
+}