DEV Community: hamza72x

[Grind 169] 8. Binary Search

hamza72x — Tue, 25 Oct 2022 13:56:14 +0000

Problem Link: https://leetcode.com/problems/binary-search/

Solution:

func search(nums []int, target int) int {

    var l, r = 0, len(nums)-1

    for l <= r {

        var mid = (l + r) / 2

        if nums[mid] == target {
            return mid
        }

        if target > nums[mid] {
           l = mid + 1
        } else {
           r = mid - 1
        }
    }

    return -1
}

[Grind 169] 7. Valid Anagram

hamza72x — Tue, 25 Oct 2022 13:54:35 +0000

Problem Link: https://leetcode.com/problems/valid-anagram/

Solution:

func isAnagram(s string, t string) bool {
    var n1 = len(s)
    var n2 = len(t)

    if n1 != n2 {
        return false
    }

    var data1 = make(map[byte]int)
    var data2 = make(map[byte]int)

    for i := 0; i < n1; i++ {
        var c1 = s[i]
        var c2 = t[i]

        _, ok1 := data1[c1]
        _, ok2 := data2[c2]

        if ok1 {
            data1[c1]++
        } else {
            data1[c1] = 1
        }

        if ok2 {
            data2[c2]++
        } else {
            data2[c2] = 1
        }
    }

    for k := range data1 {
        if data1[k] != data2[k] {
           return false 
        }
    }

    return true
}

[Grind 169] 6. Invert Binary Tree

hamza72x — Tue, 25 Oct 2022 13:51:05 +0000

Dedicated to mxcl, Creator of brew :)

Problem Link: https://leetcode.com/problems/invert-binary-tree/

Solution:

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func invertTree(root *TreeNode) *TreeNode {

    if root == nil {
        return nil
    }

    var temp = root.Left
    root.Left = root.Right
    root.Right = temp

    invertTree(root.Left)
    invertTree(root.Right)

    return root
}

[Grind 169] 5. Valid Palindrome

hamza72x — Tue, 25 Oct 2022 13:45:20 +0000

Problem Link: https://leetcode.com/problems/valid-palindrome/

Solution:

func isPalindrome(s string) bool {
    var sb strings.Builder

    for _, c := range s {
        var str = string(c)
        if (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') {
            sb.WriteString(str)
        } else if (c >= 'A' && c <= 'Z') {
            sb.WriteString(strings.ToLower(str)) 
        }
    }

    s = sb.String()
    var n = len(s)

    for i := 0; i < n/2; i++ {
        if s[i] != s[n-i-1]  {
           return false 
        }
    }

    return true
}

[Grind 169] 4. Best Time to Buy and Sell Stock

hamza72x — Tue, 25 Oct 2022 13:43:48 +0000

Problem Link: https://leetcode.com/problems/best-time-to-buy-and-sell-stock/

Solution:

func maxProfit(prices []int) int {
    var profit = 0
    var n = len(prices)
    var left = 0
    var right = 1

    for right < n {
        if prices[right] > prices[left] {
            var diff = prices[right] - prices[left]
            if diff > profit {
                profit = diff 
            }
        } else {
            left = right
        }

        right++
    }

    return profit
}

[Grind 169] 3. Merge Two Sorted Lists

hamza72x — Tue, 25 Oct 2022 13:39:39 +0000

Problem Link: https://leetcode.com/problems/merge-two-sorted-lists/

Solution:

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func mergeTwoLists(list1 *ListNode, list2 *ListNode) *ListNode {

    var node = &ListNode{}
    var tail = node

    for {
        if list1 == nil || list2 == nil {
           break 
        }

        if list1.Val < list2.Val {
            tail.Next = list1
            list1 = list1.Next
        } else {
            tail.Next = list2
            list2 = list2.Next
        }

        tail = tail.Next
    }

    if list1 != nil {
        tail.Next = list1
    } else if list2 != nil {
        tail.Next = list2
    }


    return node.Next
}

[Grind 169] 2. Valid Parentheses

hamza72x — Tue, 25 Oct 2022 13:36:45 +0000

Problem Link: https://leetcode.com/problems/valid-parentheses/

Solution:

func isValid(s string) bool {
    var stacks = []rune{}

    var closeToOpen = map[rune]rune{
        ')' : '(',
        '}' : '{',
        ']' : '[',
    }

    for _, c := range s {

        n := len(stacks)

        if n > 0 {
            if stacks[n-1] == closeToOpen[c] {
                stacks = stacks[:n-1]
            } else {
                stacks = append(stacks, c)
            }
        } else {
            stacks = append(stacks, c)
        }
    }

    return len(stacks) == 0
}

[Grind 169] 1. Two Sum

hamza72x — Tue, 25 Oct 2022 13:19:11 +0000

Problem Link: https://leetcode.com/problems/two-sum/

Solution 1:

func twoSum(nums []int, target int) []int {
    var n = len(nums)
    for i := 0; i < n; i ++ {
        for j := i+1; j < n; j++ {
            if nums[i] + nums[j] == target {
                return []int{i, j}
            } 
        }
    }
    return []int{}
}

Solution 2:

func twoSum(nums []int, target int) []int {
    var data = make(map[int]int)
    for j, v := range nums {
        if i, ok := data[v]; ok {
            return []int{i, j}
        } else {
            data[target - v] = j
        }
    }
    return []int{}
}

Block CTRL-C in bash script

hamza72x — Sun, 25 Sep 2022 01:14:16 +0000

You can block / control ctrl-c in bash script by following:

#!/bin/bash

trap ctrl_c INT

function ctrl_c() {
    echo "Cleaning up some stuff before quiting..."

    # Do your stuff here
    # For example: kill any background task that you ran

    # Don't forget to exit after your cleanup is done
    # otherwise the script will not be stopped

    exit
}

# here goes your rest of the script