Interview Questions and Answers

var x float64 = 3.14
var y int = int(x) // Explicitly convert x from float64 to int     

var a int = 42
var b float64 = float64(a)      

import "strconv"

var num int = 42
var str string = strconv.Itoa(num)

var b byte = 'A'
var r rune = '🌟'

var val interface{} = "hello"
str, ok := val.(string)
if ok {
    // Conversion successful
}   

var x int = 42
var px *int = &x
var py *float64 = (*float64)(unsafe.Pointer(px)) // Unsafe pointer type conversion

type MyInt int
var a MyInt = 10
var b int = int(a)  

go myFunction()        

package main

import (
    "fmt"
    "time"
)

func main() {
    // Start two goroutines that execute concurrently.
    go printNumbers()
    go printLetters()

    // Sleep to allow goroutines to finish (not recommended in production code).
    time.Sleep(time.Second)
}

func printNumbers() {
    for i := 1; i <= 5; i++ {
        fmt.Printf("%d ", i)
        time.Sleep(100 * time.Millisecond)
    }
}

func printLetters() {
    for char := 'a'; char <= 'e'; char++ {
        fmt.Printf("%c ", char)
        time.Sleep(100 * time.Millisecond)
    }
}

def get_coordinates():
x = 10
y = 20
return (x, y)

void getCoordinates(int &x, int &y) {
    x = 10;
    y = 20;
}

public struct Coordinates {
    public int x;
    public int y;
}

public Coordinates GetCoordinates() {
    Coordinates coords;
    coords.x = 10;
    coords.y = 20;
    return coords;
}

function getCoordinates() {
    let x = 10;
    let y = 20;
    return [x, y];
}

const [x, y] = getCoordinates();

package main
import (
    "strings"
)

func main() {
    var builder strings.Builder

    // You can use the WriteString method to append strings efficiently
    builder.WriteString("Hello, ")
    builder.WriteString("world!")

    result := builder.String()

    fmt.Println(result) // Output: Hello, world!
}

import "fmt"
func main() {
    str1 := "Hello, "
    str2 := "world!"
    result := str1 + str2
    fmt.Println(result) // Output: Hello, world!
}

const (
    Sunday    = 0
    Monday    = 1
    Tuesday   = 2
    Wednesday = 3
    Thursday  = 4
    Friday    = 5
    Saturday  = 6
)

def swap(a, b):
temp = a
a = b
b = temp
return a, b
 
x, y = 10, 20
x, y = swap(x, y)
print(f'x: {x}, y: {y}')  # Output: x: 20, y: 10

#include <stdio.h>
void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int main() {
    int x = 10, y = 20;
    swap(&x, &y);
    printf("x: %d, y: %d\n", x, y); // Output: x: 20, y: 10
    return 0;
}

function swap(a, b) {
    let temp = a;
    a = b;
    b = temp;
    return [a, b];
}

let x = 10, y = 20;
[x, y] = swap(x, y);
console.log( x: ${x}, y: ${y} ); // Output: x: 20, y: 10

public class Main {
    public static void main(String[] args) {
        String a = "Hello";
        String b = "World";

        // Swapping
        String temp = a;
        a = b;
        b = temp;

        System.out.println("a: " + a); // Output: a: World
        System.out.println("b: " + b); // Output: b: Hello
    }
}

data = {'b': 2, 'a': 1}
for key in sorted(data.keys()):
    print(f'{key}: {data[key]}')
 

Output:
 
a: 1
b: 2
 

 Go: 
 
import (
    "fmt"
    "sort"
)
     
data := map[string]int{
    "b": 2,
    "a": 1,
}

keys := make([]string, 0, len(data))
for key := range data {
    keys = append(keys, key)
}
sort.Strings(keys)

for _, key := range keys {
    fmt.Printf("%s: %d\n", key, data[key])
}
 

Output:
 
a: 1
b: 2

import "fmt"
type FixedOrderMap struct {
    keys   []string
    values map[string]int
}
func (f *FixedOrderMap) Insert(key string, value int) {
    f.keys = append(f.keys, key)
    f.values[key] = value
}
func main() {
    data := FixedOrderMap{
        values: make(map[string]int),
    }
    data.Insert("b", 2)
    data.Insert("a", 1)
    for _, key := range data.keys {
        fmt.Printf("%s: %d\n", key, data.values[key])
    }
}
 
Output:
 
b: 2
a: 1

import (
    "fmt"
    "time"
)

func main() {
    fmt.Println("Start")
    time.Sleep(2 * time.Second) // Sleep for 2 seconds
    fmt.Println("End")
}

import "fmt"
func printNames(names ...string) {
    for _, name := range names {
        fmt.Println(name)
    }
}
func main() {
    printNames("Alice", "Bob")
    printNames("Charlie")
    printNames() // No names provided
}    

package main
import "fmt"
type PrinterOptions struct {
    Prefix string
}
type PrinterOption func(*PrinterOptions)
func WithPrefix(prefix string) PrinterOption {
    return func(opts *PrinterOptions) {
        opts.Prefix = prefix
    }
}
func PrintWithPrefix(message string, options ...PrinterOption) {
    opts := &PrinterOptions{
        Prefix: "[Default]",
    }
    for _, option := range options {
        option(opts)
    }
    fmt.Printf("%s %s\n", opts.Prefix, message)
}
func main() {
    PrintWithPrefix("Hello")
    PrintWithPrefix("World", WithPrefix("[Custom]"))
}

numbers := []int{1, 2, 3, 4, 5}
for index, value := range numbers {
    fmt.Printf("Index: %d, Value: %d\n", index, value)
}         

   person := map[string]string{
    "name":  "Alice",
    "age":   "30",
    "city":  "New York",
}

for key, value := range person {
    fmt.Printf("Key: %s, Value: %s\n", key, value)
}

dataChannel := make(chan int)
go func() {
    dataChannel <- 1
    dataChannel <- 2
    close(dataChannel)
}()
for data := range dataChannel {
    fmt.Printf("Received: %d\n", data)
}

person := Person{"John", "Doe", 30}

personPtr := new(Person)
personPtr.FirstName = "Jane"
personPtr.LastName = "Smith"
personPtr.Age = 25         

person := Person{
    FirstName: "Alice",
    LastName:  "Johnson",
}

import (
    "fmt"
    "github.com/spf13/viper"
)

func main() {
    viper.SetConfigFile("config.yaml")
    viper.ReadInConfig()

    databaseURL := viper.GetString("database.url")
    fmt.Printf("Database URL: %s\n", databaseURL)
}

import (
    "flag"
    "fmt"
)

func main() {
    var configFile string
    flag.StringVar(&configFile, "config", "config.yaml", "Path to the config file")
    flag.Parse()

    fmt.Printf("Using config file: %s\n", configFile)
}

type AppConfig struct {
    DatabaseURL string  json:"database_url" 
    LogLevel    string  json:"log_level" 
}

func main() {
    config := AppConfig{
        DatabaseURL: "mysql://localhost:3306/mydb",
        LogLevel:    "info",
    }

    // Read and merge configuration data from various sources into the config struct
} 

done := make(chan struct{})
// Start a goroutine
go func() {
    // Do some work
    // Signal that the work is done
    close(done)
}()
// Wait for the signal
<-done

mySet := make(map[string]struct{})
// Add items to the set
mySet["item1"] = struct{}{}
mySet["item2"] = struct{}{}
// Check if an item exists
if _, exists := mySet["item1"]; exists {
    fmt.Println("item1 exists in the set")
}   

type MyInterface interface {
    DoSomething()
}

func main() {
    var myInstance MyInterface
    myInstance = struct{}{} // Placeholder instance
}

package main
import "fmt"
func main() {
    myMap := map[string]int{
        "apple":  1,
        "banana": 2,
        "cherry": 3,
    }

    // Check if "banana" key exists
    value, exists := myMap["banana"]

    if exists {
        fmt.Printf("Value for 'banana': %d\n", value)
    } else {
        fmt.Println("'banana' key does not exist")
    }

    // Check if "grape" key exists
    value, exists = myMap["grape"]

    if exists {
        fmt.Printf("Value for 'grape': %d\n", value)
    } else {
        fmt.Println("'grape' key does not exist")
    }
}

    y := 20 // Declare a new variable y and assign the value 20 with type inference

type User struct {
    ID       uint    gorm:"primary_key" 
    Username string  gorm:"unique" 
    Email    string  gorm:"unique" 
}      

type User struct {
    Username string  validate:"required,min=3,max=20" 
    Email    string  validate:"required,email" 
}

type Person struct {
    FirstName string  doc:"First name of the person" 
    LastName  string  doc:"Last name of the person" 
}

type Person struct {
    Name  string  customtag:"name" 
    Age   int     customtag:"age" 
}

type Product struct {
    Name     string  custom:"product_name" 
    Category string  custom:"category_name" 
}

import (
    "fmt"
    "reflect"
)

func main() {
    slice1 := []int{1, 2, 3}
    slice2 := []int{1, 2, 3}

    if reflect.DeepEqual(slice1, slice2) {
        fmt.Println("Slices are equal")
    } else {
        fmt.Println("Slices are not equal")
    }
}

package mypackage
import "fmt"
var globalVar int

func init() {
    fmt.Println("This is the init() function of mypackage.")
    globalVar = 42
}

func GetGlobalVar() int {
    return globalVar
}