Deadlock when running two go routine

Im studying Golang now on my freetime and I am trying sample exams online to test what i learned,
I came about this coding exam task but I cant seem to make it work/run without a crash,
im getting fatal error: all goroutines are asleep - deadlock! error, can anybody help what I am doing wrong here?

func executeParallel(ch chan<- int, done chan<- bool, functions ...func() int) {
	ch <- functions[1]()
	done <- true
}

func exampleFunction(counter int) int {
	sum := 0
	for i := 0; i < counter; i++ {
		sum += 1
	}
	return sum
}

func main() {
	expensiveFunction := func() int {
		return exampleFunction(200000000)
	}

	cheapFunction := func() int {return exampleFunction(10000000)}

	ch := make(chan int)
	done := make(chan bool)

	go executeParallel(ch, done, expensiveFunction, cheapFunction)

	var isDone = <-done
	for result := range ch {
		fmt.Printf("Result: %d\n", result)

		if isDone {
			break;
		}
	}
}

Your executeParallel function will panic if less than 2 functions are provided - and will only run the 2nd function:

ch <- functions[1]() // runtime panic if less then 2 functions

I think it should look more like this: running all input functions in parallel and grabbing the first result.

for _, fn := range functions {

	fn := fn // so each iteration/goroutine gets the proper value
	
	go func() {
		select {
		case ch <- fn():
			// first (fastest worker) wins

		default:
			// other workers results are discarded (if reader has not read results yet)
			// this ensure we don't leak goroutines - since reader only reads one result from channel

		}
	}()
}

As such there's no need for a done channel - as we just need to read the one and only (quickest) result:

ch := make(chan int, 1) // big enough to capture one result - even if reader is not reading yet

executeParallel(ch, expensiveFunction, cheapFunction)

fmt.Printf("Result: %d\n", <-ch)

https://play.golang.org/p/skXc3gZZmRn

package main

import "fmt"

func executeParallel(ch chan<- int, done chan<- struct{}, functions ...func() int) {
	// Only execute the second function [1], if available.
	if len(functions) > 1 {
		ch <- functions[1]()
	}
	// Close the done channel to signal the for-select to break and the main returns.
	close(done)
}

// example returns the number of iterations for [0..counter-1]
func example(counter int) int {
	sum := 0
	for i := 0; i < counter; i++ {
		sum += 1
	}
	return sum

	// NOTE(SS): This function could just return "counter-1"
	// to avoid the unnecessary calculation done above.
}

func main() {
	var (
		cheap     = func() int { return example(10000000) }
		expensive = func() int { return example(200000000) }
		ch        = make(chan int)
		done      = make(chan struct{})
	)

	// executeParallel takes ch, done channel followed by variable
	// number of functions where on the second i.e., indexed 1
	// function is executed on a separated goroutine which is then
	// sent to ch channel which is then received by the for-select
	// reciever below i.e., <-ch is the receiver.
	go executeParallel(ch, done, expensive, cheap)

	for {
		select {
		// Wait for something to be sent to done or the done channel
		// to be closed.
		case <-done:
			return
		// Keep receiving from ch (if something is sent to it)
		case result := <-ch:
			fmt.Println("Result:", result)
		}
	}
}

I have commented on the code so that it's understandable. As you didn't the actual question the logic could be still wrong.