Minimum & Maximum (DSA)

package main

import (
	"fmt"
	"math"
)

// Minimum
func min5Log(n int) {
	limit := int(math.Min(5, float64(n)))
	for i := 0; i <= limit; i++ {
		fmt.Println(i)
	}
}

// Maximum
func max5Log(n int) {
	limit := int(math.Max(10, float64(n)))
	for i := 0; i <= limit; i++ {
		fmt.Println(i)
	}
}

func main() {
	// min5Log(90000000000000)
	max5Log(-1)
}

Visualization (min&max)

Sum Of Array (DSA)

package main

import "fmt"

// Space Complexity: O(1)
func sumOfArray(arr []int) int {
	total := 0
	for i := 0; i < len(arr); i++ {
		total += arr[i]
	}
	return total
}

// Space Complexity: O(n)
func doubleArray(arr []int) []int {
	newArr := []int{}
	for i := 0; i < len(arr); i++ {
		newArr = append(newArr, arr[i]*2)
	}
	return newArr
}

func main() {
	fmt.Println(sumOfArray([]int{25, 25, 50}))
	fmt.Println(doubleArray([]int{25, 25, 50}))
}

Visualization (sumOfArray)

character Count (DSA)

package main

import "fmt"

func main() {
	str := "anower hossain"
	charList := make(map[string]int)

	for i := 0; i < len(str); i++ {
		char := string(str[i])
		if _, ok := charList[char]; ok {
			charList[char]++
		} else {
			charList[char] = 1
		}
	}

	fmt.Println(charList)
}

Visualization (charCount)

Binary Search (DSA)

package main

import "fmt"

func binarySearch(arr []int, value int) int {
	start := 0
	end := len(arr) - 1

	for start <= end {
		mid := start + (end-start)/2

		if arr[mid] == value {
			return mid
		}

		if value < arr[mid] {
			end = mid - 1
		} else {
			start = mid + 1
		}
	}

	return -1
}

func main() {
	fmt.Println(binarySearch([]int{2, 3, 4, 7, 34, 66}, 7)) // 3
}

Visualization (binarySearch)

Recursion (DSA)

package main

import "fmt"

// Countdown using recursion
func countDown(n int) {
	fmt.Println(n)
	n--
	if n > 0 {
		countDown(n)
	}
}

// Normal loop version
func sumOfNumber(n int) int {
	sum := 0
	for i := n; i >= 0; i-- {
		sum += i
	}
	return sum
}

// Recursive version
func sumOfNumberRe(n int) int {
	if n < 0 {
		return 0
	}
	return n + sumOfNumberRe(n-1)
}

func main() {
	// countDown(10)
	// fmt.Println(sumOfNumber(10))
	fmt.Println(sumOfNumberRe(10))
}

/*
Operation
============
10 + 9
19 + 8
27 + 7
34 + 6
40 + 5
45 + 4
49 + 3
52 + 2
54 + 1
55 + 0

finel result = 55
*/

Visualization (recursion)

Proble Solving(DSA)

package main

import "fmt"

func getHigherAndLower(arr []interface{}) int {
	var higher, lower int
	firstNumberFound := false

	for i := 0; i < len(arr); i++ {
		num, ok := arr[i].(int)
		if !ok {
			continue
		}
		if !firstNumberFound {
			higher = num
			lower = num
			firstNumberFound = true
		}
		if num > higher {
			higher = num
		}
		if num < lower {
			lower = num
		}
	}

	return higher - lower
}

func main() {
	temperature := []interface{}{-2, 4, 45, "error", -6, -8, 43}
	fmt.Println(getHigherAndLower(temperature))
}

Visualization (problesolving)

Analyze BigO (DSA)

package main

import "fmt"

func contains(arr []string, target string) bool {
	for _, v := range arr {
		if v == target {
			return true
		}
	}
	return false
}

func uniqueStrings(arr []string) []string {
	var unique []string
	for _, v := range arr {
		if !contains(unique, v) {
			unique = append(unique, v)
		}
	}
	return unique
}

func main() {
	nameArray := []string{"anower", "shanto", "rohan", "rohan"}
	fmt.Println(uniqueStrings(nameArray))
}

Visualization (analyzeBigO)

Bubble Sort(DSA)

package main

import "fmt"

func main() {
	arr := []int{2, 53, 23, 1, -3}
	var isSwap bool

	for i := 0; i < len(arr)-1; i++ {
		isSwap = false
		for j := 0; j < len(arr)-1-i; j++ {
			fmt.Println(arr)
			if arr[j] > arr[j+1] {
				arr[j], arr[j+1] = arr[j+1], arr[j]
				isSwap = true
			}
		}
		if !isSwap {
			break
		}
	}

	fmt.Println("Sorted:", arr)
}

Visualization (bubbleSort)

Linear Search (DSA)

package main

import "fmt"

func linearSearch(arr []int, value int) int {
	for i := 0; i < len(arr); i++ {
		if arr[i] == value {
			return i
		}
	}
	return -1
}

func main() {
	fmt.Println(linearSearch([]int{2, 3, 4, 5, 6}, 5)) // 3
}

Visualization (linearSearch)

Helper Function(DSA)

package main

import "fmt"

func findOddNumber(arr []int) []int {
	var result []int

	var helper func([]int)
	helper = func(input []int) {
		if len(input) == 0 {
			return
		}
		if input[0]%2 != 0 {
			result = append(result, input[0])
		}
		helper(input[1:])
	}

	helper(arr)
	return result
}

func main() {
	fmt.Println(findOddNumber([]int{2, 3, 56, 8, 3, 6, 8, 5}))
}

Visualization (helperFunction)