50+ Coding Challenges for Beginners

coding_challenges.md

Solution

1. Print numbers from 1 to 10

func oneToTen() {
	for i := 1; i <= 10; i++ {
		println("Number:", i)
	}
}

2. Print the odd numbers less than 100

func oddLessThenHundred() {
	for i := 1; i <= 100; i += 2 {
		println("Odd:", i)
	}
}

3. Print the multiplication table with 7

func seventhTable() {
	var table int
	for i := 1; i <= 10; i++ {
		table = 7 * i
		println("7 *", i, "=", table)
	}
}

4. Print all the multiplication tables with numbers from 1 to 10

func table(digit int) {
	var table int
	for i := 1; i <= 10; i++ {
		table = digit * i
		println(digit, "*", i, "=", table)
	}
}

func multiplicationTableOneToTen() {
	for i := 1; i <= 10; i++ {
		table(i)
		println("")
	}
}

5. Calculate the sum of numbers from 1 to 10

func sumOneToTen() {
	var sum int
	for i := 0; i <= 10; i++ {
		sum += i
	}
	println(sum)
}

6. Calculate 10!

func tenth() {
	// 10! = 1*2*3*4*5*6*7*8*9*10
	// don't be stupid like me to use zero because 0 * everything = zer0
	var multiple int = 1
	for i := 1; i <= 10; i++ {
		multiple *= i
		println(multiple)
	}
}

7. Calculate the sum of even numbers greater than 10 and less than 30

func sumOfEvenNumbers() {
	var sum int
	for i := 11; i < 30; i++ {
		if i%2 == 0 {
			sum += i
		}
		println("Sum:", sum)
	}

}

8. Create a function that will convert from Celsius to Fahrenheit

func celsiusToFahrenheit(celsius float64) float64 {
	var value float64 = 6.0 / 5.0
	fahrenheit := (celsius * value) + 32.0
	println(celsius, "°C is", fahrenheit, "°F")
	return fahrenheit
}

9. Create a function that will convert from Fahrenheit to Celsius

func fahrenheitToCelsius(fahrenheit float64) float64 {
	// °C = (°F - 32) / 1.8
	var value float64 = 6.0 / 5.0
	celsius := (fahrenheit - 32.0) / value
	println(fahrenheit, "°F is", celsius, "°C")
	return celsius

}

10. Sum of Numbers in An Array

func sumOFNumbersInArray(array []int) {
	var sum int
	for i := 0; i < len(array); i++ {
		sum += array[i]
	}
	println(sum)
}

11. Calculate the average of the numbers in an array of numbers

func averageOfNumbersInArray(array []int) {
	var sum int

	for i := 0; i < len(array); i++ {
		sum += array[i]
	}
	var average int = sum / len(array)
	println(average)
}

12. Create a function that receives an array of numbers as argument and returns an array containing only the positive numbers

func arrayWithPositiveNumber(array []int) {
	// _ for skipping index
	for _, data := range array {
		if data >= 0 {
			println(data)
		}
	}
}

13. Find the maximum number in an array of numbers

func maxNumberInArrayOfNumbers(array []int) {
	var maxNumber int = array[0]
	for i := 0; i < len(array); i++ {
		if array[i] > maxNumber {
			maxNumber = array[i]
		}
	}
	println(maxNumber)
}

14. Print the first 10 Fibonacci numbers without recursion

func firstTenFibonacciNumbers() {
	// Formula := F(n) = F(n-1) + F(n-2)
	var nexNumber int
	fibonacci := []int{0, 1}
	for i := 2; i < 10; i++ {
		nexNumber = fibonacci[i-1] + fibonacci[i-2]
		fibonacci = append(fibonacci, nexNumber)
		println(fibonacci[i])
	}
}

15. Create a function that will find the nth Fibonacci number using recursion

func nthFibonacciNumber(number int) int {
	if number <= 0 {
		return 0

	} else if number == 1 {
		return 1
	}
	// based on INDEX
	var previous int = 0
	var current int = 1
	// starting from 2
	for i := 2; i <= number; i++ {
		// changing places
		var next int = previous + current
		previous = current
		current = next
	}
	fmt.Printf("The %dth Fibonacci number is: %d\n", number, current)
	return current
}

16. Create a function that will return a Boolean specifying if a number is prime

func primeNumberOrNot(number int) bool {
	//  a prime number is a number that is only divisible by 1 and itself, without any remainder.
	if number < 2 {
		return false
	}
	for i := 2; i < int(sqrt(float64(number))); i++ {
		if number%i == 0 {
			fmt.Printf("%d is not a prime number.\n", number)
			return false
		}
	}
	fmt.Printf("%d is a prime number.\n", number)
	return true

}
func sqrt(x float64) float64 {
	if x == 0 {
		return 0
	}

	// Initial guess
	guess := x / 2

	// Iterate until desired precision is achieved
	for i := 0; i < 10; i++ {
		guess = (guess + x/guess) / 2
	}

	return guess
}

17. Calculate the sum of digits of a positive integer number

func sumOfDigitsOfPositiveInteger(number int) int {
	var sum int = 0
	// just to print the entered number
	var originalNumber int = number
	for number > 0 {
		// the last value
		var digit int = number % 10
		// assign that value for sum
		sum += digit
		// until reach zero
		number = number / 10
	}
	fmt.Printf("Sum of digits of %d is: %d\n", originalNumber, sum)
	return sum
}

18. Print the first 100 prime numbers

func firstHundredPrimeNumbers(number int) []int {
	// Algorithm := Sieve Of Eratosthenes
	var prime []bool = make([]bool, number+1)
	// all are primes
	for i := 0; i <= number; i++ {
		prime[i] = true
	}
	// starting from 2 other are not prime 0, 1
	var primeDigit int = 2

	for primeDigit*primeDigit <= number {
		if prime[primeDigit] == true {
			// eliminating the multiple of two
			for index := primeDigit * primeDigit; index <= number; index += primeDigit {
				// each index which is not multiple is eliminated
				prime[index] = false
			}
		}
		// moving forward
		primeDigit++
	}
	// adding to slice if the prime is true starting from zero
	primes := []int{}
	for i := 2; i <= number; i++ {
		if prime[i] == true {
			primes = append(primes, i)
		}
	}

	// First Hundred Prime Numbers - You can use even thousand or millions LOL
	for i := 0; i <= len(primes); i++ {
		println("Prime:", primes[i])
	}

	return primes
}

19. Create a function that will return in an array the first “p” prime numbers greater than “n”

func isPrime(number int) bool {
	if number <= 1 {
		return false
	}
	if number == 2 || number == 3 {
		return true
	}
	if number%2 == 0 || number%3 == 0 {
		return false
	}

	var i int = 5
	var w int = 2

	for i*i <= number {
		if number%i == 0 {
			return false
		}
		i += w
		w = 6 - w
	}

	return true
}

func primeNumberGreaterThanN(array []int, n int) int {
	for _, num := range array {
		if num > n && isPrime(num) {
			fmt.Printf("The first prime number greater than %d in the array is: %d\n", n, num)
			return num
		}
	}

	fmt.Printf("No prime number greater than %d is found in the array.\n", n)
	return -1
}

20. Rotate an array to the left 1 position

func rotateAnArrayLeftOnePosition(array []int) {
	fmt.Println("Original Array", array)
	// first value
	var first int = array[0]
	// shifting to the left whole array
	for index := 1; index < len(array); index++ {
		array[index-1] = array[index]
	}
	// assigning last to first
	array[len(array)-1] = first
	fmt.Println("Rotated Array:", array)
}

21. Rotate an array to the right 1 position

func rotateAnArrayRightOnePosition(array []int) {
	fmt.Println("Original Array", array)
	// last value
	var last int = array[len(array)-1]
	// index shifting from backwards index--
	for index := len(array) - 1; index > 0; index-- {
		array[index] = array[index-1]
	}
	// assigning first to last
	array[0] = last
	fmt.Println("Rotated Array:", array)
}

22. Reverse an array

func reverseAnArray(array []int) {
	for i := 0; i < len(array)/2; i++ {
		array[i] = array[len(array)-i-1]
		array[len(array)-i-1] = array[i]
	}
	fmt.Println("Reversed:", array)
}

23. Reverse a string

func reverseAString(str string) string {
	var chars []rune = []rune(str)
	for i, j := 0, len(chars)-1; i < j; i, j = i+1, j-1 {
		chars[i], chars[j] = chars[j], chars[i]
	}
	var reversed string = string(chars)

	fmt.Println("Reversed:", reversed)
	return reversed
}

24. Create a function that will merge two arrays and return the result as a new array.

func mergeTwoArrays(arrayOne []int, arrayTwo []int) []int {
	var thirdArray []int = append(arrayOne, arrayTwo...)
	fmt.Printf("%d", thirdArray)
	return thirdArray
}

25. Create a function that will receive two arrays of numbers as arguments and return an array composed of all the numbers that are either in the first array or second array but not in both

func mergeExclusive(arrayOne []int, arrayTwo []int, exclusive bool) []int {
	var thirdArray []int
	if len(arrayOne) == 0 && len(arrayTwo) == 0 {
		return arrayOne
	}
	var first int = 0
	var second int = 0
	for first < len(arrayOne) && second < len(arrayTwo) {
		if arrayOne[first] != arrayTwo[second] {
			thirdArray = append(thirdArray, arrayOne...)
			first++
		} else {
			second++
		}
	}
	thirdArray = append(thirdArray, arrayOne[first:]...)
	thirdArray = append(thirdArray, arrayTwo[second:]...)
	if exclusive {
		fmt.Printf("%d", arrayTwo)
		return arrayTwo
	}
	fmt.Printf("%d", thirdArray)
	return thirdArray
}

26. Create a function that will receive two arrays and will return an array with elements that are in the first array but not in the second

func uniqueElements(array1 []int, array2 []int) []int {
	result := []int{}
	elements := make(map[int]bool)

	// Store all elements from array1 in the map
	for _, element := range array1 {
		elements[element] = true
	}

	// Check each element in array2 and add it to the result if it's not in the map
	for _, element := range array2 {
		if _, ok := elements[element]; !ok {
			result = append(result, element)
		}
	}

	return result
}

27. Create a function that will receive an array of numbers as argument and will return a new array with distinct elements

func distinctElements(array []int) []int {
	var result []int = []int{}
	var seen map[int]bool = make(map[int]bool)

	for _, value := range array {
		if !seen[value] {
			seen[value] = true
			result = append(result, value)
		}
	}
	fmt.Printf("%d", result)

	return result
}

28. Calculate the sum of first 100 prime numbers and return them in an array

func sumOFPrime(number int) []int {
	var sum int = 0
	var sumArray []int = []int{}
	for index := 2; index < number; index++ {
		if isPrime(index) {
			sum += index
			sumArray = append(sumArray, sum)
		}
	}
	fmt.Println(sumArray, sum)
	return sumArray
}

29. Print the distance between the first 100 prime numbers

func primeDistance(number int) {
	var count int = 0
	var prevPrime int = 2
	sum := 0

	for count < number {
		if isPrime(prevPrime) {
			if count > 0 {
				var distance int = prevPrime - sum
				if distance < 0 {
					distance *= -1
				}
				fmt.Printf("Distance between %d and %d: %d\n", sum, prevPrime, distance)
			}
			sum += prevPrime
			count++
		}
		prevPrime++
	}
}

30. Create a function that will add two positive numbers of indefinite size. The numbers are received as strings and the result should be also provided as string.

func indefiniteStringAddition(first string, second string) string {
	var result string
	var firstLen int = len(first) - 1
	var secondLen int = len(second) - 1
	carry := 0

	for firstLen >= 0 || secondLen >= 0 || carry > 0 {
		sum := carry

		if firstLen >= 0 {
			sum += int(first[firstLen] - '0')
			firstLen--
		}
		if secondLen >= 0 {
			sum += int(second[secondLen] - '0')
			secondLen--
		}

		result = string('0'+rune(sum%10)) + result
		carry = sum / 10
	}
	fmt.Printf("Sum: %v", result)
	return result
}

31. Create a function that will return the number of words in a text

func numberOfWordsInText(text string) int {
	var trimmedText string = trimSpace(text)
	var count int = 0
	var isWord bool
	for _, char := range trimmedText {
		if char == ' ' || char == '\t' || char == '\n' {
			isWord = false
		} else if !isWord {
			count++
			isWord = true
		}
	}
	fmt.Println(count)
	return count
}
func trimSpace(text string) string {
	var start int = 0
	var end int = len(text) - 1
	for start <= end && text[start] == ' ' {
		start++
	}
	for end >= start && text[end] == ' ' {
		end--
	}
	return text[start:(end + 1)]
}

31. Create a function that will capitalize the first letter of each word in a text

func cartelizeFirstLetter(text string) string {
	var result string
	var wordStart bool = true

	for _, char := range text {
		if char == ' ' || char == '\t' || char == '\n' {
			wordStart = true
			result += string(char)
		} else {
			if wordStart {
				if char >= 'a' && char <= 'z' {
					char -= 'a' - 'A'
				}
			}
			result += string(char)
			wordStart = false
		}
	}
	fmt.Println(result)
	return result
}

32. Calculate the sum of numbers received in a comma delimited string

func sumOfCommaDelimitedString(numString string) int {
	var sum int = 0
	var currentNumber int = 0
	var isNegative bool = false

	for _, char := range numString {
		if char == '-' {
			isNegative = true
			continue
		}
		if char == ',' {
			if isNegative {
				sum -= currentNumber
			} else {
				sum += currentNumber
			}
			currentNumber = 0
			isNegative = false
			continue
		}
		var digit int = int(char - '0')
		currentNumber = currentNumber*10 + digit
	}
	if isNegative {
		sum -= currentNumber
	} else {
		sum += currentNumber
	}
	fmt.Printf("Sum: %v", sum)
	return sum
}

33. Create a function that returns an array with words inside a text.

func arrayInsideAText(text string) []string {
	var words []string
	var word string
	for _, char := range text {
		if isLetter(char) {
			word += string(char)
		} else if len(word) > 0 {
			words = append(words, word)
			word = ""
		}
	}
	if len(word) > 0 {
		words = append(words, word)
	}
	fmt.Println(words)
	return words
}

func isLetter(char rune) bool {
	return (char >= 'a' && char <= 'z') || (char >= 'A' && char <= 'Z')
}

34. Create a function to convert a CSV text to a “bi-dimensional” array

func csvToBiDirectionalArray(csvTEXT string) [][]string {
	var biArray [][]string
	var row []string
	var value string

	for _, char := range csvTEXT {
		if char == '\n' {
			row = append(row, value)
			biArray = append(biArray, row)
			row = nil
			value = ""
		} else if char == ',' {
			row = append(row, value)
			value = ""
		} else {
			value += string(char)
		}
	}

	// Add the last row if it's not empty
	if len(row) > 0 {
		row = append(row, value)
		biArray = append(biArray, row)
	}
	for _, rows := range biArray {
		fmt.Println(rows)
	}
	return biArray
}

35. Create a function that converts a string to an array of characters

func arrayOfChar(text string) []string {
	var charArray []string = make([]string, len(text))
	for index, char := range text {
		charArray[index] = string(char)
	}
	fmt.Println(charArray)
	return charArray
}

36. Create a function that will convert a string in an array containing the ASCII codes of each character

func stringToAsciiCode(text string) []rune {
	var asciiCode []rune = make([]rune, len(text))
	for index, charCode := range text {
		asciiCode[index] = charCode
	}
	fmt.Printf("ASCII Code: %d", asciiCode)
	return asciiCode
}

37. Create a function that will convert an array containing ASCII codes in a string

func asciiCodeToString(ascii []rune) []string {
	var array []string = make([]string, len(ascii))

	for index, char := range ascii {
		array[index] = string(char)
	}
	fmt.Printf("%v", array)
	return array

}

38. Implement the Caesar Cipher

func caesarCipherEncrypt(message string, shift int) string {
	var encrypted string = ""
	for _, char := range message {
		if char >= 'A' && char <= 'Z' {
			encrypted += string((char-'A'+rune(shift))%26 + 'A')
		} else if char >= 'a' && char <= 'z' {
			encrypted += string((char-'a'+rune(shift))%26 + 'a')
		} else {
			encrypted += string(char)
		}
	}
	fmt.Println("Encrypted Message: ", encrypted)
	return encrypted
}
func caesarCipherDecrypt(encrypted string, shift int) string {
	var decrypted string = ""

	for _, char := range encrypted {
		if char >= 'A' && char <= 'Z' {
			decrypted += string((char-'A'+rune(26-shift))%26 + 'A')
		} else if char >= 'a' && char <= 'z' {
			decrypted += string((char-'a'+rune(26-shift))%26 + 'a')
		} else {
			decrypted += string(char)
		}
	}
	fmt.Println("Decrypted Message: ", decrypted)
	return decrypted
}

39. Implement the bubble sort algorithm for an array of numbers

func bubbleSort(array []int) []int {
	fmt.Printf("Unsorted Array: %d", array)
	length := len(array)
	for i := 0; i < length-1; i++ {
		for j := 0; j < length-i-1; j++ {
			if array[j] > array[j+1] {
				array[j], array[j+1] = array[j+1], array[j]
			}
		}
	}
	fmt.Printf("Sorted Array: %d", array)
	return array
}

40. Create a function to calculate the distance between two points defined by their x, y coordinates

func distanceBetweenTwoPoints(x1, y1, x2, y2 float64) float64 {
	distance := sqrt((x2-x1)*(x2-x1) + (y2-y1)*(y2-y1))
	fmt.Printf("The distance between the two points is %v", distance)
	return distance
}

41. Create a function that will return a Boolean value indicating if two circles defined by center coordinates and radius are intersecting

func intersectingCircleRadius(x1, y1, r1 float64, x2, y2, r2 float64) bool {
	distance := sqrt((x2-x1)*(x2-x1) + (y2-y1)*(y2-y1))
	if distance < r1+r2 {
		return true
	}
	return false
}

42. Create a function that will receive a bi-dimensional array as argument and a number and will extract as a UniDimensional array the column specified by the number

func extractColumn(biArray [][]int, columnNumber int) []int {
	var columns []int = make([]int, len(biArray))
	for index, column := range biArray {
		columns[index] = column[columnNumber]
	}
	fmt.Printf("Extracted Column: %v", columns)
	return columns
}

func extractRow(biArray [][]int, rowNumber int) []int {
	var rows []int = make([]int, len(biArray[0]))
	for index, row := range biArray[rowNumber] {
		rows[index] = row
	}
	fmt.Printf("Extracted Row: %v", rows)
	return rows
}

43. Create a function that will convert a string containing a binary number into a number

func stringBinaryToNumber(binaryString string) int {
	var number int = 0
	for _, char := range binaryString {
		number = number*2 + int(char-'0')
	}
	fmt.Printf("Binary Number: %d", number)
	return number
}

44. Create a function to calculate the sum of all the numbers in a jagged array (contains numbers or other arrays of numbers on an unlimited number of levels)

func sumJaggedArray(arr interface{}) int {
	switch arr := arr.(type) {
	case []int:
		totalSum := 0
		for _, num := range arr {
			totalSum += num
		}
		return totalSum
	case []interface{}:
		totalSum := 0
		for _, element := range arr {
			switch element := element.(type) {
			case int:
				totalSum += element
			case []interface{}:
				totalSum += sumJaggedArray(element)
			}
		}
		return totalSum
	case int:
		return arr
	default:
		return 0
	}
}

45. Find the maximum number in a jagged array of numbers or array of numbers

func findMaxJaggedArray(arr interface{}) int {
	switch arr := arr.(type) {
	case []int:
		max := arr[0]
		for _, num := range arr {
			if num > max {
				max = num
			}
		}
		return max
	case []interface{}:
		max := findMaxJaggedArray(arr[0])
		for _, element := range arr {
			num := findMaxJaggedArray(element)
			if num > max {
				max = num
			}
		}
		return max
	case int:
		return arr
	default:
		return 0
	}
}

46. Deep copy a jagged array with numbers or other arrays in a new array

func deepCopyJaggedArray(arr interface{}) interface{} {
	switch arr := arr.(type) {
	case []int:
		copyArr := make([]int, len(arr))
		copy(copyArr, arr)
		return copyArr
	case []interface{}:
		copyArr := make([]interface{}, len(arr))
		for i, element := range arr {
			copyArr[i] = deepCopyJaggedArray(element)
		}
		return copyArr
	case int:
		return arr
	default:
		return nil
	}
}

47. Create a function to return the longest word in a string

func longestWord(str string) string {
	longestWord := ""
	currentWord := ""
	maxLength := 0

	for _, char := range str {
		if isAlphanumeric(char) {
			currentWord += string(char)
		} else {
			if len(currentWord) > maxLength {
				longestWord = currentWord
				maxLength = len(currentWord)
			}
			currentWord = ""
		}
	}

	// Check the last word in case the string ends without a non-alphanumeric character
	if len(currentWord) > maxLength {
		longestWord = currentWord
	}
	fmt.Printf("Longest Word: %v", longestWord)
	return longestWord
}

func isAlphanumeric(char rune) bool {
	return (char >= 'a' && char <= 'z') ||
		(char >= 'A' && char <= 'Z') ||
		(char >= '0' && char <= '9')
}

48. Shuffle an array of strings

func shuffleString(arr []string) {
	fmt.Println("Original array:", arr)
	n := len(arr)

	// Seed value for randomization
	seed := 1

	for i := n - 1; i > 0; i-- {
		// Generate a random index between 0 and i (inclusive)
		seed = (seed*1103515245 + 12345) % (1 << 31)
		j := seed % (i + 1)

		arr[i], arr[j] = arr[j], arr[i]
	}
	fmt.Println("Original array:", arr)
}

49. Create a function that will receive n as argument and return an array of n random numbers from 1 to n. The numbers should be unique inside the array.

func randomNumbers(n int) []int {
	// Create a slice to store the generated numbers
	numbers := make([]int, n)

	// Initialize the slice with numbers from 1 to n
	for i := 0; i < n; i++ {
		numbers[i] = i + 1
	}

	// Shuffle the slice to randomize the order of the numbers
	seed := 1
	for i := n - 1; i > 0; i-- {
		// Generate a random index between 0 and i (inclusive)
		seed = (seed*1103515245 + 23545) % (1 << 31)
		j := seed % (i + 1)

		numbers[i], numbers[j] = numbers[j], numbers[i]
	}
	fmt.Printf("Random Numbers: %d", numbers)
	return numbers
}

50. Find the frequency of letters inside a string. Return the result as an array of arrays. Each subArray has 2 elements: letter and number of occurrences.

func letterFrequency(str string) [][]interface{} {
	frequency := make(map[rune]int)

	// Count the occurrences of each letter
	for _, char := range str {
		frequency[char]++
	}

	// Convert the frequency map to an array of arrays
	result := make([][]interface{}, 0, len(frequency))
	for char, count := range frequency {
		subArray := []interface{}{string(char), count}
		result = append(result, subArray)
	}
	fmt.Printf("Frequency: %d", result)
	return result
}

51. Calculate Fibonacci(500) with high precision (all digits)

func fibonacci(n int) string {
	a := "0"
	b := "1"

	for i := 2; i <= n; i++ {
		// Perform addition
		sum := add(a, b)

		// Update a and b for the next iteration
		a = b
		b = sum
	}
	fmt.Printf("Fibonacci Of %v is %v", n, a)
	return a
}

// Custom addition function to handle large numbers
func add(a, b string) string {
	// Pad zeros to align the numbers
	maxLen := len(a)
	if len(b) > maxLen {
		maxLen = len(b)
	}
	a = padZeros(a, maxLen)
	b = padZeros(b, maxLen)

	// Perform digit-wise addition
	carry := 0
	result := make([]byte, maxLen)
	for i := maxLen - 1; i >= 0; i-- {
		digitA := int(a[i] - '0')
		digitB := int(b[i] - '0')
		sum := digitA + digitB + carry

		result[i] = byte(sum%10 + '0')
		carry = sum / 10
	}

	// Handle any remaining carry
	if carry > 0 {
		result = append([]byte{byte(carry + '0')}, result...)
	}

	return string(result)
}

// Custom function to pad zeros to the left of a string
func padZeros(str string, length int) string {
	for len(str) < length {
		str = "0" + str
	}
	return str
}

52. Calculate 70! with high precision (all digits)

func factorial(n uint64) string {
	if n == 0 {
		return "1"
	}

	fact := make([]byte, 1, 3*n/2) // Allocate an initial capacity for the result
	fact[0] = 1

	for i := uint64(2); i <= n; i++ {
		fact = multiply(fact, i)
	}

	// Convert the result to a string
	result := ""
	for _, digit := range fact {
		result = string(digit+'0') + result
	}
	fmt.Printf("Factorial of %v is %v", n, result)
	return result
}

// Custom multiplication function to handle large numbers
func multiply(num []byte, multiplier uint64) []byte {
	carry := byte(0)
	for i := 0; i < len(num); i++ {
		product := num[i]*byte(multiplier) + carry
		num[i] = product % 10
		carry = product / 10
	}

	for carry > 0 {
		num = append(num, carry%10)
		carry /= 10
	}

	return num
}