Sending and receiving values in Go - Time & Space Complexity

Time Complexity: Sending and receiving values

O(n)

Understanding Time Complexity

When we send and receive values in Go channels, we want to know how the time to do this changes as we handle more data.

We ask: How does the number of send and receive actions grow with the input size?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

package main

func main() {
  ch := make(chan int)

  go func() {
    for i := 0; i < 5; i++ {
      ch <- i
    }
    close(ch)
  }()

  for val := range ch {
    _ = val
  }
}

This code sends 5 values into a channel and receives them in the main goroutine.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Sending and receiving values in a loop.
• How many times: 5 times each for sending and receiving.

How Execution Grows With Input

As the number of values to send and receive grows, the total operations grow in the same way.

Input Size (n)	Approx. Operations
10	10 sends + 10 receives = 20
100	100 sends + 100 receives = 200
1000	1000 sends + 1000 receives = 2000

Pattern observation: The total work grows directly with the number of values sent and received.

Final Time Complexity

Time Complexity: O(n)

This means the time to send and receive values grows in a straight line as the number of values increases.

Common Mistake

[X] Wrong: "Sending and receiving values in channels is constant time no matter how many values there are."

[OK] Correct: Each value must be sent and received separately, so the total time grows with the number of values.

Interview Connect

Understanding how sending and receiving values scale helps you reason about concurrent programs and their performance in real projects.

Self-Check

"What if we used buffered channels with capacity n? How would the time complexity change?"

Practice

1. What is the correct way to send a value 5 to a channel named ch in Go?

easy

A. ch <- 5

B. 5 <- ch

C. send(ch, 5)

D. ch = 5

Solution

1. Step 1: Understand channel send syntax

   In Go, to send a value to a channel, you write channel <- value.

2. Step 2: Apply syntax to given variables

   Here, the channel is ch and the value is 5, so the correct send is ch <- 5.

3. Final Answer:

   ch <- 5 -> Option A

4. Quick Check:

   Send syntax = channel <- value [OK]

Hint: Remember: channel <- value sends data [OK]

Common Mistakes:

• Reversing send syntax as value <- channel
• Using assignment operator instead of send
• Calling a non-existent send function

2. Which of the following is the correct syntax to receive a value from a channel ch and store it in variable v?

easy

A. v := ch <-

B. v = ch <-

C. v = ch.receive()

D. v := <- ch

Solution

1. Step 1: Recall channel receive syntax

   To receive a value from a channel, Go uses value := <- channel.

2. Step 2: Match syntax with variables

   Here, v receives from ch, so v := <- ch is correct.

3. Final Answer:

   v := <- ch -> Option D

4. Quick Check:

   Receive syntax = v := <- ch [OK]

Hint: Use := <- channel to receive value [OK]

Common Mistakes:

• Placing <- after channel name
• Using method calls like receive()
• Using assignment = instead of := for declaration

3. What will be the output of the following Go program?

package main
import "fmt"
func main() {
    ch := make(chan int)
    go func() {
        ch <- 10
    }()
    val := <-ch
    fmt.Println(val)
}

medium

A. 0

B. Compilation error

C. 10

D. Deadlock error

Solution

1. Step 1: Understand channel creation and goroutine

   The channel ch is created and a goroutine sends 10 to it.

2. Step 2: Receive value and print

   The main goroutine receives the value from ch and prints it.

3. Final Answer:

   10 -> Option C

4. Quick Check:

   Send and receive work correctly, output = 10 [OK]

Hint: Send in goroutine, receive in main prints sent value [OK]

Common Mistakes:

• Expecting zero value instead of sent value
• Thinking channel blocks forever causing deadlock
• Confusing send and receive syntax

4. Identify the error in this Go code snippet:

package main
func main() {
    ch := make(chan int)
    ch <- 5
    val := <- ch
    println(val)
}

medium

A. Channel is not created properly

B. Sending to channel blocks forever causing deadlock

C. Receiving from channel is incorrect syntax

D. Variable val is not declared

Solution

1. Step 1: Analyze channel usage without goroutine

   The code sends to ch but no goroutine is receiving yet, so send blocks forever.

2. Step 2: Understand deadlock cause

   Since the send blocks and main goroutine waits, program deadlocks before receiving.

3. Final Answer:

   Sending to channel blocks forever causing deadlock -> Option B

4. Quick Check:

   Send blocks without concurrent receiver [OK]

Hint: Send blocks if no goroutine receives concurrently [OK]

Common Mistakes:

• Assuming send works without concurrent receive
• Thinking channel creation is wrong
• Confusing syntax errors with runtime deadlock

5. You want to send multiple values 1, 2, 3 to a channel ch and receive them in order. Which code snippet correctly does this without causing deadlock?

hard

A. ch := make(chan int)
go func() {
ch <- 1
ch <- 2
ch <- 3
}()
for i := 0; i < 3; i++ {
fmt.Println(<-ch)
}

B. ch := make(chan int)
ch <- 1
ch <- 2
ch <- 3
for i := 0; i < 3; i++ {
fmt.Println(<-ch)
}

C. ch := make(chan int, 1)
ch <- 1
ch <- 2
ch <- 3
for i := 0; i < 3; i++ {
fmt.Println(<-ch)
}

D. ch := make(chan int)
for i := 1; i <= 3; i++ {
ch <- i
}
for i := 0; i < 3; i++ {
fmt.Println(<-ch)
}

Solution

1. Step 1: Check for deadlock prevention

   ch := make(chan int)
   go func() {
       ch <- 1
       ch <- 2
       ch <- 3
   }()
   for i := 0; i < 3; i++ {
       fmt.Println(<-ch)
   }

   uses a goroutine to send values, so sending won't block the main goroutine.

2. Step 2: Confirm receiving order and printing

   Main goroutine receives three values in order and prints them correctly.

3. Final Answer:

   This code runs without deadlock and prints 1, 2, 3 -> Option A

4. Quick Check:

   Use goroutine to send multiple values safely [OK]

Hint: Send in goroutine or use buffered channel to avoid deadlock [OK]

Common Mistakes:

• Sending multiple values on unbuffered channel without goroutine
• Assuming unbuffered channel allows multiple sends without receive
• Forgetting to import fmt for printing