Problem #11

Problem link
Solution:

package main

import (
    "strconv"
    "io/ioutil"
    "strings"
)

func main() {
    fileBuf, err := ioutil.ReadFile("011_input.txt")
    if err != nil {
        panic(err.String())
    }
    fileStr := string(fileBuf)
    lines := strings.Split(fileStr, "\n", 20)
    arr := make([][]uint, 20)
    var strArr []string
    for i := range lines {
        arr[i] = make([]uint, 20)
        strArr = strings.Split(lines[i], " ", 20)
        for j := range arr[i] {
            intvalue, _ := strconv.Atoi(strArr[j])
            arr[i][j] = uint(intvalue)
        }
    }
    max := uint(0)
    //left to right
    for i := range arr {
        for j := 0; j < 17; j++ {
            mul := arr[i][j] * arr[i][j+1] * arr[i][j+2] * arr[i][j+3]
            if mul > max {
                max = mul
            }
        }
    }
    //up to down
    for i := 0; i < 17; i++ {
        for j := range arr[i] {
            mul := arr[i][j] * arr[i+1][j] * arr[i+2][j] * arr[i+3][j]
            if mul > max {
                max = mul
            }
        }
    }
    //first diagonal
    for i := 0; i < 17; i++ {
        for j := 0; j < 17; j++ {
            mul := arr[i][j] * arr[i+1][j+1] * arr[i+2][j+2] * arr[i+3][j+3]
            if mul > max {
                max = mul
            }
        }
    }
    //second diagonal
    for i := 3; i < 20; i++ {
        for j := 0; j < 17; j++ {
            mul := arr[i][j] * arr[i-1][j+1] * arr[i-2][j+2] * arr[i-3][j+3]
            if mul > max {
                max = mul
            }
        }
    }
    println(max)
}

Input file is renamed as 011_input.txt.

Result: 70600674
Time: 0m0.005s

Problem #13

Problem link
Solution:

package main

import (
    "io/ioutil"
    "strconv"
    "strings"
)

func main() {
    fileBuf, err := ioutil.ReadFile("013_input.txt")
    if err != nil {
        panic(err.String())
    }
    fileStr := string(fileBuf)
    lines := strings.Split(fileStr, "\n", 100)
    result := ""
    carryout, digit := 0, 0
    for i := 49; i >= 0; i-- {
        sum := carryout
        for j := range lines {
            num, _ := strconv.Atoi(string(lines[j][i]))
            sum += num
        }
        digit = sum % 10
        carryout = sum / 10
        result = strconv.Itoa(digit) + result
    }
    result = strconv.Itoa(carryout) + result
    println(result[0:10])
}

Result: 5537376230
Time: 0m0.010s

Problem #18

Problem link
Solution:

package main

import (
    "io/ioutil"
    "strconv"
    "strings"
)

var arr [][]int
var bests [][]int

func main() {
    fileBuf, err := ioutil.ReadFile("018_input.txt")
    if err != nil {
        panic(err.String())
    }
    fileStr := strings.Trim(string(fileBuf), "")
    oneDArrStr := strings.Split(fileStr, "\n", -1)
    var line []string
    arr = make([][]int, 15)
    bests = make([][]int, len(arr))
    for i := range arr {
        line = strings.Split(oneDArrStr[i], " ", -1)
        arr[i] = make([]int, len(line))
        bests[i] = make([]int, len(arr[i]))
        for j := range line {
            arr[i][j], _ = strconv.Atoi(line[j])
            bests[i][j] = -1
        }
    }
    println(bestSum(0, 0))
}

func bestSum(i, j int) int {
    var result int
    if bests[i][j] != -1 {
        result = bests[i][j]
    } else if i == len(arr)-1 {
        result = arr[i][j]
        return arr[i][j]
    } else {
        sumLeft, sumRight := bestSum(i+1, j), bestSum(i+1, j+1)
        if sumLeft > sumRight {
            result = arr[i][j] + sumLeft
        } else {
            result = arr[i][j] + sumRight
        }
    }
    bests[i][j] = result
    return result
}

Tree is read from a file named as 018_input.txt and also memoization is used for this problem.

Result: 1074
Time: 0m0.005s

Problem #22

Problem link
Solution:

package main

import (
    "io/ioutil"
    "strings"
    "sort"
)

func main() {
    fileBuf, err := ioutil.ReadFile("022_input.txt")
    if err != nil {
        panic(err.String())
    }
    fileStr := string(fileBuf)
    arr := strings.Split(fileStr, ",", -1)
    for i := range arr {
        arr[i] = strings.Split(arr[i], "\"", -1)[1]
    }

    sort.SortStrings(arr)

    result := uint64(0)
    for i := range arr {
        result += uint64(i+1) * uint64(alphabeticValue(arr[i]))
    }
    println(result)
}

func alphabeticValue(in string) int {
    sum := 0
    for i := range in {
        sum += int(in[i]) - int('A') + 1
    }
    return sum
}

Result: 871198282
Time: 0m0.035s

Problem #32

Problem link
Solution:

package main

import (
    "strconv"
    "strings"
)

func main() {
    mp := map[int]int{}
    for i := 1; i < 200; i++ {
        for j := 1; j < 5000; j++ {
            if isPandigital(i, j, i*j) {
                mp[i*j] = 1
            }
        }
    }
    sum := 0
    for key, _ := range mp {
        sum += key
    }
    println(sum)
}

func isPandigital(mul1, mul2, result int) bool {
    str := strconv.Itoa(mul1) + strconv.Itoa(mul2) + strconv.Itoa(result)
    if len(str) != 9 {
        return false
    }
    for i := 1; i < 10; i++ {
        if !strings.Contains(str, strconv.Itoa(i)) {
            return false
        }
    }
    return true
}

Result: 45228
Time: 0m2.405s

Problem #38

Problem link
Solution:

package main

import (
    "strconv"
    "strings"
)

func main() {
    max := 0
    var tmp int
    for i := 1; i < 10000; i++ {
        str := ""
        for j := 1; j < 9 && len(str) < 9; j++ {
            str += strconv.Itoa(i * j)
        }
        if len(str) == 9 && isPandigital(str) {
            tmp, _ = strconv.Atoi(str)
            if tmp > max {
                max = tmp
            }
        }
    }
    println(max)
}

func isPandigital(str string) bool {
    if len(str) != 9 {
        return false
    }
    for i := 1; i < 10; i++ {
        if !strings.Contains(str, strconv.Itoa(i)) {
            return false
        }
    }
    return true
}

Result: 932718654
Time: 0m0.049s

Problem #41

Problem link
Solution:

package main

import (
    "strconv"
    "strings"
)

func main() {
    a := make([]bool, 87654322)
    a[0], a[1] = true, true
    prime := 3
    var k int
    finished := false
    for !finished {
        for k = 2 * prime; k < len(a); k += prime {
            a[k] = true
        }
        for k = prime + 2; k < len(a) && a[k]; k += 2 {
        }
        if k < len(a) {
            prime = k
        } else {
            finished = true
        }
    }
    //a now has false values for the primes and multiples of 2
    //but we skip even numbers in our iteration.
    for i := int64(87654321); i > 0; i -= 2 {
        if !a[i] && isPandigital(i) {
            println(i)
            return
        }
    }
}

func isPandigital(in int64) bool {
    str := strconv.Itoa64(in)
    n := len(str)
    for i := 1; i <= n; i++ {
        if !strings.Contains(str, strconv.Itoa(i)) {
            return false
        }
    }
    return true
}

Result: 7652413
Time: 0m15.596s

Problem #42

Problem link
Solution:

package main

import (
    "io/ioutil"
    "strings"
)

var triangles []int

func main() {
    //read names
    fileBuf, err := ioutil.ReadFile("042_input.txt")
    if err != nil {
        panic(err.String())
    }
    fileStr := string(fileBuf)
    arr := strings.Split(fileStr, ",", -1)
    for i := range arr {
        arr[i] = strings.Split(arr[i], "\"", -1)[1]
    }

    //create an array of triangle numbers
    triangles = make([]int, 20)
    for i := range triangles {
        triangles[i] = (i * (i + 1)) / 2
    }

    //iterate over names to check
    result := 0
    for i := range arr {
        if isTriangle(alphabeticValue(arr[i])) {
            result++
        }
    }
    println(result)
}

func isTriangle(in int) bool {
    for i := range triangles {
        if triangles[i] == in {
            return true
        }
    }
    return false
}

func alphabeticValue(in string) int {
    sum := 0
    for i := range in {
        sum += int(in[i]) - int('A') + 1
    }
    return sum
}

Result: 162
Time: 0m0.009s

Problem #49

Problem link
Solution:

package main

import (
    "strings"
    "strconv"
)

func main() {
    arr := make([]bool, 10000)
    prime := 2
    finished := false
    var i int
    for !finished {
        for i = 2 * prime; i < 10000; i += prime {
            arr[i] = true
        }
        //next prime
        for i = prime + 1; i < 10000 && arr[i]; i++ {
        }
        if i < 10000 {
            prime = i
        } else {
            finished = true
        }
    }
outer:
    for i := 1000; i < len(arr); i++ {
        for j := i + 1; j < len(arr); j++ {
            if i != 1487 && !arr[i] && !arr[j] && isPerm(i, j) && 2*j-i < 10000 && !arr[2*j-i] && isPerm(i, 2*j-i) {
                print(i)
                print(j)
                print(2*j - i)
                break outer
            }
        }
    }
    println()
}

func isPerm(i1, i2 int) bool {
    s1, s2 := strconv.Itoa(i1), strconv.Itoa(i2)
    for i := 0; i < len(s1); i++ {
        //we need a cross check for repetition of numbers like in 1049 1499 comparison
        if !strings.Contains(s1, s2[i:i+1]) || !strings.Contains(s2, s1[i:i+1]) {
            return false
        }
    }
    return true
}

Result: 296962999629
Time: 0m0.420s