DEV Community: RATHEESH G KUMAR

Understanding Buffered Channels in Golang with sample problems

RATHEESH G KUMAR — Thu, 03 Apr 2025 14:10:07 +0000

How do you work over a buffered channel ? this question while we learn about the concept channel ?

Before jumping into the buffered channel, we need to understand what the channel is.

Introduction to Channels in Go
Channels in Go provide a medium for communication between two or more goroutines. Goroutines are lightweight threads managed by the Go runtime scheduler, allowing concurrent execution.

Types of Channels in Go
Buffered Channel – A sender can send data until the buffer is full. Once full, it blocks further sends until space is available.

Used for asynchronous communication.

Unbuffered Channel – A sender can only send data if a receiver is ready. The sender blocks until the receiver reads the value.

Used for synchronous communication.

Working with Buffered Channels
Let's take an array and use goroutines with buffered channels to compute:

The sum of the array

The largest element

The second-largest element

`
package main

import (
    "fmt"
    "sync"
)

func secondLargest(arr []int, ch chan int, wg *sync.WaitGroup) <-chan int {
    // Decreases the counter by 1 when a goroutine finishes execution
    defer wg.Done()
    lar := arr[0]
    secnd := -1

    for _, v := range arr {
        if v > lar {
            secnd = lar
            lar = v
        } else if v < lar && v > secnd {
            secnd = v
        }
    }
    ch <- secnd
    return ch
}

func sumOfArray(arr []int, ch chan int, wg *sync.WaitGroup) <-chan int {
    // Decreases the counter by 1 when a goroutine finishes execution
    defer wg.Done()
    sum := 0

    for _, v := range arr {
        sum += v
    }
    ch <- sum
    return ch
}

func largestElement(arr []int, ch chan int, wg *sync.WaitGroup) <-chan int {
    // Decreases the counter by 1 when a goroutine finishes execution
    defer wg.Done()
    largest := arr[0]

    for _, v := range arr {
        if v > largest {
            largest = v
        }
    }

    ch <- largest
    return ch
}

func main() {
    //Buffered channel of size 3
    ch := make(chan int, 3)
    //wait for a group of goroutines to finish execution
    var wg sync.WaitGroup
    arr := []int{2, 3, 4, 50, 6, 70, 8, 9}

    //Increases the counter by the specified number of goroutines.
    wg.Add(3)

    go secondLargest(arr, ch, &wg)
    fmt.Println("Second largest", <-ch)

    go sumOfArray(arr, ch, &wg)
    fmt.Println("Sum of array", <-ch)
    go largestElement(arr, ch, &wg)

    fmt.Println("largest element of array", <-ch)

    go func() {
        close(ch)
        //Blocks execution until the counter becomes zero.
        wg.Wait()
    }()

}
`

Buffered Channel Diagram (Capacity = 3)

   Goroutines Send Data

┌───────────────────────────────┐
│ Goroutine 1 -> ch <- 50 │
│ Goroutine 2 -> ch <- 70 │
│ Goroutine 3 -> ch <- 100 │
└───────────────────────────────┘

    Buffered Channel (Capacity = 3)

┌───────────┬───────────┬───────────┐
│ 50 │ 70 │ 100 │ (Buffered)
└───────────┴───────────┴───────────┘

    Main Goroutine Reads Data

┌───────────────────────────────┐
│ fmt.Println(<-ch) → 50 │
│ fmt.Println(<-ch) → 70 │
│ fmt.Println(<-ch) → 100 │
└───────────────────────────────┘

📌 Understanding Buffered Channel Behavior
The buffered channel is created with a capacity of 3 (make(chan int, 3)).

This means it can hold three values at a time before blocking further writes.

If we try to send more than three values before reading, the program will deadlock.

source code : https://go.dev/play/p/YqaoecokCjl

[Boost]

RATHEESH G KUMAR — Thu, 03 Apr 2025 13:02:18 +0000

#goroutine

RATHEESH G KUMAR — Fri, 14 Mar 2025 10:02:09 +0000

💡 Character Frequency Count in a String using Goroutines in Go

RATHEESH G KUMAR ・ Mar 14

💡 Character Frequency Count in a String using Goroutines in Go

RATHEESH G KUMAR — Fri, 14 Mar 2025 10:00:37 +0000

In Go, strings are immutable, meaning once a string is created, its value cannot be modified directly. However, we can still analyze and process strings efficiently.

In this example, we will implement a program to calculate the frequency of each character in a string using Goroutines and channels.

🔤 Sample String:

`str := "We often will need to manipulate strings in our messaging app. For example, adding some personalization by using a customer's name within a template"`

📦 Step 1: Define a Struct to Hold Character and Count

type CharFreq struct {
Char rune
Count int
}

📦 Step 2: Declare a Map and Channel


charCh := make(chan CharFreq)
strMap := make(map[string]int)

🔁 Step 3: Iterate Through the String and Count Characters
We will convert all characters to lowercase and ignore spaces and punctuation.


`for _, v := range str {
    // Convert uppercase to lowercase
    if v >= 'A' && v <= 'Z' {
        v += 32
    }

    // Skip spaces and punctuation (optional enhancement)
    if v == ' ' {
        continue
    }

    // Convert rune to string and count
    strMap[v]++
}`

⚙️ Step 4: Use an Anonymous Goroutine to Send Data to Channel

`go func() {
    for i, v := range strMap {
        charCh <- CharFreq{Char: i, Count: v}
    }
    close(charCh)
}()`

📤 Step 5: Read from Channel and Print Results


`for item := range charCh {
    fmt.Printf("Character: %s, Count: %d\n", item.Char, item.Count)
}`

✅ Final Output:
You will get the frequency of each character (excluding spaces) printed via the channel using a concurrent approach.

//output Character: g, Count: 5 Character: x, Count: 1 Character: e, Count: 14 Character: o, Count: 8 Character: m, Count: 7

Complete implementation link: https://www.programiz.com/online-compiler/0G4nsPTV0NR3B

Product of Array Expect Itself Leetcode Question - 238

RATHEESH G KUMAR — Sat, 08 Mar 2025 06:29:25 +0000

Given an integer array nums, return an array answer such that answer[i] is equal to the product of all the elements of nums except nums[i].
The product of any prefix or suffix of nums is guaranteed to fit in a 32-bit integer.
You must write an algorithm that runs in O(n) time and without using the division operation.

Example 1:

Input: nums = [1,2,3,4]
Output: [24,12,8,6]
Example 2:

Input: nums = [-1,1,0,-3,3]
Output: [0,0,9,0,0]

Solution
Approach: Prefix and Postfix Products
My solution uses a two-pass approach utilizing prefix and postfix products to efficiently solve the problem in O(n) time with O(1) extra space (excluding the output array).
Key Insight

Prefix product: The product of all elements to the left of the current element
Postfix product: The product of all elements to the right of the current element
The product of all elements except the current one is: prefix × postfix

Algorithm

Initialize a result array of the same size as the input array
First pass: Calculate prefix products from left to right
Second pass: Calculate postfix products from right to left, while multiplying with the existing prefix products

Visualization
For example, with input array nums = [1, 2, 3, 4]:
First Pass (Prefix Products):

Start with prefix = 1
For each position, store the current prefix in the result array, then update the prefix
After first pass, result = [1, 1, 2, 6]

Second Pass (Postfix Products):

Start with postfix = 1
For each position (in reverse), multiply the existing value by the current postfix, then update the postfix
After second pass, result = [24, 12, 4, 1]

This gives us our answer, as each position now contains the product of all elements except the one at that position.
Code Implementation
Approach: Prefix and Postfix Products
My solution uses a two-pass approach utilizing prefix and postfix products to efficiently solve the problem in O(n) time with O(1) extra space (excluding the output array).
Key Insight

Algorithm

Visualization
For example, with input array nums = [1, 2, 3, 4]:
First Pass (Prefix Products):

Start with prefix = 1
For each position, store the current prefix in the result array, then update the prefix
After first pass, result = [1, 1, 2, 6]

Second Pass (Postfix Products):

Start with postfix = 1
For each position (in reverse), multiply the existing value by the current postfix, then update the postfix
After second pass, result = [24, 12, 4, 1]

This gives us our answer, as each position now contains the product of all elements except the one at that position.
Code Implementation
My solution uses a two-pass approach utilizing prefix and postfix products to efficiently solve the problem in O(n) time with O(1) extra space (excluding the output array).
Key Insight

Algorithm

Visualization
For example, with input array nums = [1, 2, 3, 4]:
First Pass (Prefix Products):

Start with prefix = 1
For each position, store the current prefix in the result array, then update the prefix
After first pass, result = [1, 1, 2, 6]

Second Pass (Postfix Products):

Start with postfix = 1
For each position (in reverse), multiply the existing value by the current postfix, then update the postfix
After second pass, result = [24, 12, 4, 1]

This gives us our answer, as each position now contains the product of all elements except the one at that position.
Code Implementation

func productExceptSelf(nums []int) []int {
// result array of the same size as input array
    res := make([]int,len(nums))
//calculate prefix
    prefix :=1
    for i,v := range nums{
        res[i] = prefix
        prefix *= v
    }

// Calculate postfix products and multiply with prefix products
    postfix := 1
    for i := len(nums)-1; i >= 0 ; i--{
      res[i] *= postfix
      postfix *= nums[i]
    }

    return res
}