Data commit

Task/Fraction-reduction/Go/fraction-reduction-1.go

@@ -0,0 +1,101 @@
+package main
+
+import (
+    "fmt"
+    "time"
+)
+
+func indexOf(n int, s []int) int {
+    for i, j := range s {
+        if n == j {
+            return i
+        }
+    }
+    return -1
+}
+
+func getDigits(n, le int, digits []int) bool {
+    for n > 0 {
+        r := n % 10
+        if r == 0 || indexOf(r, digits) >= 0 {
+            return false
+        }
+        le--
+        digits[le] = r
+        n /= 10
+    }
+    return true
+}
+
+var pows = [5]int{1, 10, 100, 1000, 10000}
+
+func removeDigit(digits []int, le, idx int) int {
+    sum := 0
+    pow := pows[le-2]
+    for i := 0; i < le; i++ {
+        if i == idx {
+            continue
+        }
+        sum += digits[i] * pow
+        pow /= 10
+    }
+    return sum
+}
+
+func main() {
+    start := time.Now()
+    lims := [5][2]int{
+        {12, 97},
+        {123, 986},
+        {1234, 9875},
+        {12345, 98764},
+        {123456, 987653},
+    }
+    var count [5]int
+    var omitted [5][10]int
+    for i, lim := range lims {
+        nDigits := make([]int, i+2)
+        dDigits := make([]int, i+2)
+        blank := make([]int, i+2)
+        for n := lim[0]; n <= lim[1]; n++ {
+            copy(nDigits, blank)
+            nOk := getDigits(n, i+2, nDigits)
+            if !nOk {
+                continue
+            }
+            for d := n + 1; d <= lim[1]+1; d++ {
+                copy(dDigits, blank)
+                dOk := getDigits(d, i+2, dDigits)
+                if !dOk {
+                    continue
+                }
+                for nix, digit := range nDigits {
+                    if dix := indexOf(digit, dDigits); dix >= 0 {
+                        rn := removeDigit(nDigits, i+2, nix)
+                        rd := removeDigit(dDigits, i+2, dix)
+                        if float64(n)/float64(d) == float64(rn)/float64(rd) {
+                            count[i]++
+                            omitted[i][digit]++
+                            if count[i] <= 12 {
+                                fmt.Printf("%d/%d = %d/%d by omitting %d's\n", n, d, rn, rd, digit)
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        fmt.Println()
+    }
+
+    for i := 2; i <= 6; i++ {
+        fmt.Printf("There are %d %d-digit fractions of which:\n", count[i-2], i)
+        for j := 1; j <= 9; j++ {
+            if omitted[i-2][j] == 0 {
+                continue
+            }
+            fmt.Printf("%6d have %d's omitted\n", omitted[i-2][j], j)
+        }
+        fmt.Println()
+    }
+    fmt.Printf("Took %s\n", time.Since(start))
+}

Task/Fraction-reduction/Go/fraction-reduction-2.go

@@ -0,0 +1,120 @@
+package main
+
+import (
+    "fmt"
+    "time"
+)
+
+type result struct {
+    n    int
+    nine [9]int
+}
+
+func indexOf(n int, s []int) int {
+    for i, j := range s {
+        if n == j {
+            return i
+        }
+    }
+    return -1
+}
+
+func bIndexOf(b bool, s []bool) int {
+    for i, j := range s {
+        if b == j {
+            return i
+        }
+    }
+    return -1
+}
+
+func toNumber(digits []int, removeDigit int) int {
+    digits2 := digits
+    if removeDigit != 0 {
+        digits2 = make([]int, len(digits))
+        copy(digits2, digits)
+        d := indexOf(removeDigit, digits2)
+        copy(digits2[d:], digits2[d+1:])
+        digits2[len(digits2)-1] = 0
+        digits2 = digits2[:len(digits2)-1]
+    }
+    res := digits2[0]
+    for i := 1; i < len(digits2); i++ {
+        res = res*10 + digits2[i]
+    }
+    return res
+}
+
+func nDigits(n int) []result {
+    var res []result
+    digits := make([]int, n)
+    var used [9]bool
+    for i := 0; i < n; i++ {
+        digits[i] = i + 1
+        used[i] = true
+    }
+    for {
+        var nine [9]int
+        for i := 0; i < len(used); i++ {
+            if used[i] {
+                nine[i] = toNumber(digits, i+1)
+            }
+        }
+        res = append(res, result{toNumber(digits, 0), nine})
+        found := false
+        for i := n - 1; i >= 0; i-- {
+            d := digits[i]
+            if !used[d-1] {
+                panic("something went wrong with 'used' array")
+            }
+            used[d-1] = false
+            for j := d; j < 9; j++ {
+                if !used[j] {
+                    used[j] = true
+                    digits[i] = j + 1
+                    for k := i + 1; k < n; k++ {
+                        digits[k] = bIndexOf(false, used[:]) + 1
+                        used[digits[k]-1] = true
+                    }
+                    found = true
+                    break
+                }
+            }
+            if found {
+                break
+            }
+        }
+        if !found {
+            break
+        }
+    }
+    return res
+}
+
+func main() {
+    start := time.Now()
+    for n := 2; n <= 5; n++ {
+        rs := nDigits(n)
+        count := 0
+        var omitted [9]int
+        for i := 0; i < len(rs)-1; i++ {
+            xn, rn := rs[i].n, rs[i].nine
+            for j := i + 1; j < len(rs); j++ {
+                xd, rd := rs[j].n, rs[j].nine
+                for k := 0; k < 9; k++ {
+                    yn, yd := rn[k], rd[k]
+                    if yn != 0 && yd != 0 &&
+                        float64(xn)/float64(xd) == float64(yn)/float64(yd) {
+                        count++
+                        omitted[k]++
+                        if count <= 12 {
+                            fmt.Printf("%d/%d => %d/%d (removed %d)\n", xn, xd, yn, yd, k+1)
+                        }
+                    }
+                }
+            }
+        }
+        fmt.Printf("%d-digit fractions found:%d, omitted %v\n\n", n, count, omitted)
+    }
+    fmt.Printf("Took %s\n", time.Since(start))
+}