package main

import (
    "fmt"
    "path/filepath"
    "strings"
)

func main() {
    filePath := "/tmp/file.ext"

    // get file name with extension
    fileName := filepath.Base(filePath)

    // get file extension
    fileExt := filepath.Ext(filePath)

    // truncate file name extension
    fileNameWithoutExt := strings.TrimSuffix(fileName, fileExt)

    fmt.Println("File name without extension: " + fileNameWithoutExt)
}

// $ go run main.go
// File name without extension: file

package main

import (
	"fmt"
	"os"
	"strings"
)

func main() {
	os.Setenv("FOO", "1")
	fmt.Println("FOO:", os.Getenv("FOO"))
	fmt.Println("BAR:", os.Getenv("BAR"))

	fmt.Println("----------------------")

	for _, env := range os.Environ() {
		pair := strings.SplitN(env, "=", 2)
		fmt.Println(pair[0])
	}
}

// FOO: 1
// BAR: 
// ----------------------
// HOSTNAME
// PWD
// HOME
// LANG
// SHLVL
// PATH
// _
// FOO

<?php 

$folderPath = "/tmp/test-folder"; 

// List of files inside the folder 
$files = glob($folderPath.'/*'); 
 
foreach($files as $file) { 
	if(is_file($file)) 
		// Delete the given file 
		unlink($file); 
} 

echo "Files deleted";

// php main.php
// Files deleted

package main

import "fmt"

func factorial(n int) int {
	if n == 0 {
		return 1
	}

	return n * factorial(n-1)
}

func main() {
	fmt.Println(factorial(5))
}

// $ go run main.go 
// 120

package main

import "fmt"

// The function createCounter returns anonymous function defined within its body.
// The returned function encapsulates the variable count, creating a closure.
func createCounter() func() int {
	count := 0

	return func() int {
		count++

		return count
	}
}

func main() {
    // We invoke createCounter, storing the result (a function) in counter variable.
    // This function captures and retains its own count value,
    // which updates with each subsequent invocation of createCounter.
	counter := createCounter()

	fmt.Println(counter())
	fmt.Println(counter())
	fmt.Println(counter())

	newCounter := createCounter()
	
    fmt.Println(newCounter())
}

// $ go run main.go 
// 1
// 2
// 3
// 1

package main

import "fmt"

func main() {
    // Recover function must be called inside a deferred function.
    // When the enclosing function panics, defer is activated and the restore call inside it catches the panic.
    defer func() {
        if r := recover(); r != nil {
            fmt.Printf("recovered: %s\n", r)
        }
    }()

    panic("some fatal error")
    
    // This code won't run because of panic.
    // Basic operations stop during a panic and resume during a deferred close.
    fmt.Println("after panic")
}

package main

import (
	"fmt"
	"sync"
)

// without using mutex the following error can happen: "fatal error: concurrent map writes" while changing the map in multiple goroutines
type Storage struct {
	sync.Mutex
	storage map[string]int // map is not threade-safe
}

func (s *Storage) Increment(name string) {
	s.Lock() // lock the mutex before accessing counters
	defer s.Unlock() // unlock the mutex at the end of the function using a defer statement
    s.storage[name]++
}

func (s *Storage) Decrement(name string) {
	s.Lock()
    defer s.Unlock()
	s.storage[name]--
}

func main() {
	s := &Storage{
		storage: make(map[string]int),
	}

	wg := sync.WaitGroup{}
	wg.Add(5)

    // increment a named counter in a loop
	increment := func(name string, count uint) {
		for i := 0; i < int(count); i++ {
			s.Increment(name)
		}

		wg.Done()
	}

    // decrement a named counter in a loop
	decrement := func(name string, count uint) {
		for i := 0; i < int(count); i++ {
			s.Decrement(name)
		}

		wg.Done()
	}

    // run 5 goroutines concurrently
	go increment("a", 1000)
	go decrement("a", 500)

	go increment("b", 1000)
	go increment("b", 1000)
	go decrement("b", 1500)

	wg.Wait() // wait for the goroutines to finish

	fmt.Println(s.storage)
}

// $ go run main.go  
// map[a:500 b:500]

// without mutex the following error can happen
// $ go run main.go
// fatal error: concurrent map writes

package main

import (
    "fmt"
    "os"
    "os/signal"
    "syscall"
)

func main() {
    sigs := make(chan os.Signal, 1) // create channel for signal, it should be buffered
    signal.Notify(sigs, syscall.SIGINT) // register the channel to receive notifications of the specified signals
    done := make(chan bool, 1)

    go func() {
        sig := <-sigs // wait for OS signal, once received, notify main go routine
        fmt.Printf("\nos signal: %v\n", sig)
        done <- true
    }()

    fmt.Println("awaiting signal")
    <-done // wait for the expected signal and then exit
    fmt.Println("exiting")
}

// $ go run main.go 
// awaiting os signal
// ^C
// os signal: interrupt
// exiting program

<?php 
  
function binarySearch(array $arr, int $target): int 
{ 
    $low = 0; 
    $high = count($arr) - 1; 
      
    while ($low <= $high) {          
        // compute middle index 
        $mid = floor(($low + $high) / 2);  
  
        if ($arr[$mid] > $target) { 
            // search the left side of the array 
            $high = $mid -1; 
        } else if ($arr[$mid] < $target) { 
            // search the right side of the array 
            $low = $mid + 1; 
        } else {
            // element found at mid 
            return $mid; 
        }
    } 
      
    // If we reach here element x doesnt exist 
    return -1; 
} 
  
// Driver code 
$arr = [1, 2, 3, 4, 5]; 
$target = 3;
$result = binarySearch($arr, $target);

if($result !== -1) { 
    echo "Target '$target' exists at position $result"; 
} else {
    echo "Target '$target' does not exist";
}

# Returns index of target in arr if present, else -1
def binary_search(arr, target):
	low = 0
	high = len(arr) - 1

	while low <= high:
		# Check base case
		mid = (high + low) // 2

		# If element is smaller than mid, then it can only
		# be present in left subarray
		if arr[mid] > target:
			high = mid - 1
		# Else the element can only be present in right subarray
		elif arr[mid] < target:
			low = mid + 1
		# If element is present at the middle itself
		else:
			return mid

	# Element is not present in the array
	return -1

# Test array
arr = [ 2, 3, 4, 10, 40 ]
target = 10

result = binary_search(arr, target)

if result != -1:
	print("Element is present at index", str(result))
else:
	print("Element is not present in array")

package main

import "fmt"

// return target index if it exists in arr
func search(arr []int, target int) int {
    low := 0
    high := len(arr) - 1

    for low <= high {
        mid := (low + high) / 2

        if arr[mid] < target {
            low = mid + 1
        } else if arr[mid] > target {
            high = mid - 1
        } else {
            return mid
        }
    }

    return -1
}

func main() {
    target := 7
    items := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    fmt.Printf("Element '%d' index is %d", target, search(items, target))
}

// $ output
// 6

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

package main

import (
    "fmt"
    "net/http"
)

func hello(w http.ResponseWriter, req *http.Request) {
    fmt.Fprintf(w, "Hello, World!\n")
}

func headers(w http.ResponseWriter, req *http.Request) {
    for name, headers := range req.Header {
        for _, h := range headers {
            fmt.Fprintf(w, "%v: %v\n", name, h)
        }
    }
}

func main() {
    http.HandleFunc("/hello", hello)
    http.HandleFunc("/headers", headers)

    http.ListenAndServe(":8080", nil) // run http server on port 8080
}

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)

<?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";

import csv

# Writing to a CSV file
with open('data.csv', 'w', newline='') as csvfile:
    fieldnames = ['name', 'age', 'city']
    writer = csv.DictWriter(csvfile, fieldnames=fieldnames)

    writer.writeheader()
    writer.writerow({'name': 'John', 'age': 30, 'city': 'New York'})
    writer.writerow({'name': 'Alice', 'age': 25, 'city': 'London'})

# Reading from a CSV file
with open('data.csv', newline='') as csvfile:
    reader = csv.DictReader(csvfile)
    for row in reader:
        print(row)