Step by Step solution about How to resolve the algorithm Largest number divisible by its digits step by step in the Go programming language

The provided Go code contains two variations of a program that finds the largest decimal and hexadecimal numbers divisible by each of their unique digits. Here's a detailed explanation of both versions:

Decimal Version (First Code Block):

Function divByAll:

• It takes an integer num and a slice of bytes digits representing the unique digits of num.
• It iterates through the digits slice, converting each byte to an integer (the actual digit) using int(digit-'0').
• It checks if num is divisible by each of the digits. If it's not divisible by any digit, it returns false. Otherwise, it returns true.

Main Function:

• It calculates magic, which is the product of integers from 9 down to 7. This value is used to find numbers divisible by these digits.
• It calculates high, which is the largest number divisible by magic that fits within a 32-bit integer.
• It starts a loop from high down to magic.
• For each number i, it checks the following conditions to filter out numbers that don't meet the criteria:
  • Ends with '0' (because it requires distinct digits).
  • Contains '0' or '5'.
  • Doesn't contain unique digits (checks if the length of the converted string representation of i is the same as the number of unique digits).
• If all conditions are met, it checks if i is divisible by all its unique digits using the divByAll function.
• If divByAll returns true, it prints i as the largest decimal number that meets the criteria and returns.

Hexadecimal Version (Second Code Block):

Function divByAll:

• This version is similar to the decimal version, but it handles hexadecimal digits.
• It takes an integer num and a slice of bytes digits.
• It iterates through the digits slice, converting each byte to an integer using int64(digit-'0') or int64(digit-'W') depending on whether it's a number or a letter.
• It checks if num is divisible by each of the digits. If it's not divisible by any digit, it returns false. Otherwise, it returns true.

Main Function:

• It calculates magic, which is the product of integers from 15 down to 11. This value is used to find numbers divisible by these digits.
• It calculates high, which is the largest number divisible by magic that fits within a 64-bit integer.
• It starts a loop from high down to magic.
• For each number i, it checks the following conditions:
  • Ends with '0' (because it requires distinct digits).
  • Contains '0'.
  • Doesn't contain unique digits.
• It converts i to a hexadecimal string using strconv.FormatInt and ensures it's in lowercase.
• It checks if i is divisible by all its unique digits using the divByAll function.
• If divByAll returns true, it prints i (in hexadecimal format) as the largest hexadecimal number that meets the criteria and returns.

package main

import (
    "fmt"
    "strconv"
    "strings"
)

func divByAll(num int, digits []byte) bool {
    for _, digit := range digits {
        if num%int(digit-'0') != 0 {
            return false
        }
    }
    return true
}

func main() {
    magic := 9 * 8 * 7
    high := 9876432 / magic * magic
    for i := high; i >= magic; i -= magic {
        if i%10 == 0 {
            continue // can't end in '0'
        }
        s := strconv.Itoa(i)
        if strings.ContainsAny(s, "05") {
            continue // can't contain '0'or '5'
        }
        var set = make(map[byte]bool)
        var sd []byte // distinct digits
        for _, b := range []byte(s) {
            if !set[b] {
                set[b] = true
                sd = append(sd, b)
            }
        }
        if len(sd) != len(s) {
            continue // digits must be unique
        }
        if divByAll(i, sd) {
            fmt.Println("Largest decimal number is", i)
            return
        }
    }
}


package main

import (
    "fmt"
    "strconv"
    "strings"
)

func divByAll(num int64, digits []byte) bool {
    for _, digit := range digits {
        var d int64
        if digit <= '9' {
            d = int64(digit - '0')
        } else {
            d = int64(digit - 'W')
        }
        if num%d != 0 {
            return false
        }
    }
    return true
}

func main() {
    var magic int64 = 15 * 14 * 13 * 12 * 11
    high := 0xfedcba987654321 / magic * magic
    for i := high; i >= magic; i -= magic {
        if i%16 == 0 {
            continue // can't end in '0'
        }
        s := strconv.FormatInt(i, 16) // always generates lower case a-f
        if strings.IndexByte(s, '0') >= 0 {
            continue // can't contain '0'
        }
        var set = make(map[byte]bool)
        var sd []byte // distinct digits
        for _, b := range []byte(s) {
            if !set[b] {
                set[b] = true
                sd = append(sd, b)
            }
        }
        if len(sd) != len(s) {
            continue // digits must be unique
        }
        if divByAll(i, sd) {
            fmt.Printf("Largest hex number is %x\n", i)
            return
        }
    }
}