To wait for multiple goroutines to execute, you can use the built-in WaitGroup construct. 

package main

import (
	"fmt"
	"sync"
	"time"
)

func main() {
	wg := &sync.WaitGroup{} // WaitGroup is used to wait for the execution of all running goroutines

	for i := 1; i <= 5; i++ {
		wg.Add(1) // launch several goroutines and increment the counter in WaitGroup for each running goroutine

		go func(id int) {
			worker(id, wg)
		}(i)
	}

	fmt.Println("waiting for all goroutines to complete")
	wg.Wait() // block the execution of the program until the WaitGroup counter becomes equal to 0 again
	fmt.Println("done")
}

func worker(id int, wg *sync.WaitGroup) {
	fmt.Printf("worker %d started\n", id)
	time.Sleep(time.Second) // Sleep simulates a long task
	
    fmt.Printf("worker %d finished\n", id)
	wg.Done() // notify WaitGroup that the worker has completed
}

// $ go run waitgroups.go 
// waiting for all goroutines finished
// worker 4 started
// worker 1 started
// worker 2 started
// worker 3 started
// worker 2 finished
// worker 4 finished
// worker 1 finished
// worker 3 finished
// done

main.go

Example of WaitGroup in Go

In this code, the quick_sort function is a recursive implementation of the Quick Sort algorithm. The pivot element is chosen as the first element of the array, and elements are partitioned into two sub-arrays (left and right) based on their relationship to the pivot. The function is then called recursively on the left and right sub-arrays until the entire array is sorted.

def quick_sort(arr):
    if len(arr) <= 1:
        return arr
    else:
        pivot = arr[0]
        left = [x for x in arr[1:] if x <= pivot]
        right = [x for x in arr[1:] if x > pivot]
        return quick_sort(left) + [pivot] + quick_sort(right)

# Example usage:
input_array = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
sorted_array = quick_sort(input_array)

print("Original Array:", input_array)
print("Sorted Array:", sorted_array)


main.py

Python

Implementation of the Quick Sort algorithm in Python

Here's a simple implementation of the Quick Sort algorithm in PHP

<?php

function quickSort(array $array): array
{
    $length = count($array);

    if ($length <= 1) {
        return $array;
    }

    $pivot = $array[0];
    $left = $right = [];

    for ($i = 1; $i < $length; $i++) {
        if ($array[$i] < $pivot) {
            $left[] = $array[$i];
        } else {
            $right[] = $array[$i];
        }
    }

    return array_merge(quickSort($left), [$pivot], quickSort($right));
}

// Example usage:
$array = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5];
$sortedArray = quickSort($array);

echo "Original Array: " . implode(", ", $array) . "\n";
echo "Sorted Array: " . implode(", ", $sortedArray) . "\n";



main.php

Simple implementation of the Quick Sort algorithm in PHP

To check if a certain file exists inside a given directory in Golang, the Stat() and isNotExists() functions from the os package can be used. The Stat() function is used to return a file information structure that describes the file.

package main

import (
	"errors"
	"fmt"
	"os"
)

func main() {
	filePath := "file.txt"

	if _, err := os.Stat(filePath); errors.Is(err, os.ErrNotExist) {
		fmt.Println("file not exists")
	} else {
		fmt.Println("file exists")
	}
}

Share & grow the world's code base!

Example of WaitGroup in Go

Implementation of the Quick Sort algorithm in Python

Simple implementation of the Quick Sort algorithm in PHP

Check if a file exists or not in Go

Implementation of the Quick Sort algorithm in Python

Simple implementation of the Quick Sort algorithm in PHP

Check if a file exists or not in Go