GO for Beginners

package main

import "fmt"

func main() {
    fmt.Println("Hello, Go World!")
}

package main  // Single-line comment

import "fmt"

/* This is a multi-line comment in Go
   It spans multiple lines
   Useful for longer descriptions and notes */

func main() {  
    fmt.Println("Hello, Go World!") // This line prints "Hello, Go World!"
}

package main

import "fmt"

func main() {
    fmt.Println("Hello, Go World!")
}

var numOfMountainPeaks int // We declare a variable, similar to buying a ticket
numOfMountainPeaks = 14 // We then assign it a value
fmt.Println(numOfMountainPeaks) // Finally, we validate its contents. It outputs: 14

var numOfMountainPeaks = 14 // declaring and assigning the variable at once
fmt.Println(numOfMountainPeaks)

numOfMountainPeaks := 14 // creating and assigning the variable with shorthand
fmt.Println(numOfMountainPeaks)

// Correct variable naming
var myWeight int = 72
var district9Population int = 10000
myAge := 20

// Incorrect variable naming (commented intentionally)
// var 0zero = 0;
// var ?questionMark = 1;

var constellations = 88 // We secure a ticket, label it, and assign a value
fmt.Println(constellations) // We check the content. It outputs: 88

constellations = 77 // We modify the value of the variable
fmt.Println(constellations) // We review the updated content. It outputs: 77

const DAYS_IN_WEEK = 7 // We define a constant, similar to etching a fact on a monument
fmt.Println(DAYS_IN_WEEK) // We examine our immutable fact. It outputs: 7

// DAYS_IN_WEEK = 6; // This will not compile

var daysInWeek int = 7
fmt.Println(daysInWeek)  // This will print: 7

var maxInt64 int = 9223372036854775807
fmt.Println(maxInt64)  // This will print: 9223372036854775807

var pi float64 = 3.1415926
fmt.Println(pi)  // This will print: 3.1415926

var isEarthRound bool = true
fmt.Println(isEarthRound)  // This will print: true

var isEarthFlat bool = false
fmt.Println(isEarthFlat) // This will print: false

var firstLetterOfAlphabet byte = 'A'  // must be surrounded by SINGLE quotes
fmt.Println(firstLetterOfAlphabet) // This will print: 65 – the code for "A"

var welcome string = "Welcome to Go!"
fmt.Println(welcome) // This will print: Welcome to Go!

var unknown *string = nil
fmt.Println(unknown)  // This will print: <nil>

var submarineSpeed = 30  // speed in knots
var currentSpeed = 20    // speed in knots 
fmt.Println("Is the submarine faster than the ocean current? ", submarineSpeed > currentSpeed)
// Prints: Is the submarine faster than the ocean current? true

var currentOxygenLevel = 70  // current oxygen level in %
var requiredOxygenLevel = 100  // required oxygen level in %

var isOxygenEnough = currentOxygenLevel == requiredOxygenLevel  // this results in 'false'
var isOxygenLow = currentOxygenLevel != requiredOxygenLevel  // this results in 'true'

var distanceToCaveA = 2000 // distance in meters
var distanceToCaveB = 1000 // distance in meters

var isACloser = distanceToCaveA < distanceToCaveB  // this results in 'false'
var isBCloserOrSame = distanceToCaveA >= distanceToCaveB  // this results in 'true'

package main
import "fmt"

func main() {
    var a int = 10
    var b int = 2
    fmt.Println(a + b) // Outputs: 12
    fmt.Println(a - b) // Outputs: 8
    fmt.Println(a * b) // Outputs: 20
    fmt.Println(a / b) // Outputs: 5
    fmt.Println(a % b) // Outputs: 0
}

package main
import "fmt"

func main() {
    fmt.Println(true && true) // true
    fmt.Println(true && false) // false
    fmt.Println(false && true) // false
    fmt.Println(false && false) // false

    fmt.Println(true || true) // true
    fmt.Println(true || false) // true
    fmt.Println(false || true) // true
    fmt.Println(false || false) // false

    fmt.Println(!true) // false
    fmt.Println(!false) // true
}

package main
import "fmt"

func main() {
    var speed int = 60
    var minSpeed int = 30
    var maxSpeed int = 70
    // Check if the speed is within the accepted range.
    fmt.Println(speed > minSpeed && speed < maxSpeed); // Prints: true
}

package main
import "fmt"
import "math"

func main() {
    var maxInt int = math.MaxInt32 // the maximum integer, equivalent to 2^31 - 1
    var overflow int = maxInt + 1 // causes an overflow, there's no integer after the maximal one.
    fmt.Println(overflow) // Prints: -2147483648, which is -2^31 - the minimum integer number
}

package main

import (
    "fmt"
    "strconv"
)

func main() {
    // Temperature reading in Kelvin
    tempReading := 15000.95

    // Convert the temperature from a float64 to a string
    tempString := strconv.FormatFloat(tempReading, 'f', -1, 64)

    // Output the temperature as string
    fmt.Println("Log entry - Temperature reading:", tempString, "K")
}

var d float64 = 10.25  // a double number
var i int = int(d)  // casting the float64 to int

fmt.Println("The value of i:", i)  // Output: The value of i: 10

import (
    "fmt"
    "strconv"
)

var ten int = 10  // an integer with value 10
var tenString string = strconv.Itoa(ten)  // converting int to string
fmt.Println("The value of tenString:", tenString)  // Output: The value of tenString: 10

var twentyFiveString string = "25"
var twentyFive int
twentyFive, _ = strconv.Atoi(twentyFiveString)  // converting string to int
fmt.Println("The value of twentyFive:", twentyFive)  // Output: The value of twentyFive: 25

var invalidNumber string = "25abc"
var number int
number, _ = strconv.Atoi(invalidNumber)  // Oops! This will throw an error, "25abc" is not a number!

var pi float64 = 3.14159 // a float value

// coverting float to string
var piString string = strconv.FormatFloat(pi, 'f', -1, 64)
fmt.Println("The value of piString:", piString)  // Output: The value of piString: 3.14159

var invalidFloatString string = "3.14abc"
var number float64
number, _ = strconv.ParseFloat(invalidFloatString, 64) // This will throw an error!

package main

import (
    "fmt"
    "strconv"
)

func main() {
    planetNumber := 7.0
    // TODO: Convert the planetNumber float64 to an int using explicit casting.
    var seven int = int(planetNumber)
    // TODO: Convert the int to a string using strconv.Itoa.
    var sevenString string = strconv.Itoa(seven)
    // TODO: Convert the string back to an int using strconv.Atoi.
    var planetCount int
    planetCount, _ = strconv.Atoi(sevenString)
    // Print out the int value after conversion.
    fmt.Println("In our galaxy, the planet count is:", planetCount)
}

package main

import (
    "fmt"
    "strconv"
)

func main() {
    var asteroidSize float64 = 9.75  // size of asteroid in kilometers
    // TODO: Convert the asteroidSize float value to a string without losing precision and store it in sizeString.
    var sizeString string = strconv.FormatFloat(asteroidSize, 'f', -1, 64)
    fmt.Println("Asteroid size in text is:", sizeString)  // Output should be: Asteroid size in text is: 9.75
}

if condition {
    // action if condition is true
}

// additionally

if condition {
    // action if condition is true
} else {
    // action if condition is false
}

var oxygenLevel = 78  // The level of oxygen on the planet

if oxygenLevel > 20 {
    fmt.Println("Planet has breathable air!") // Oxygen level is suitable
} else {
    fmt.Println("Oxygen level too low!") // Oxygen level is not high enough
}
// The code prints: Planet has breathable air!

var oxygenLevel = 58
if oxygenLevel > 70 {
    fmt.Println("Excellent Oxygen level!")
} else if oxygenLevel > 50 {
    fmt.Println("Oxygen level is acceptable.")
} else {
    fmt.Println("Oxygen level is too low!")
}
// The code prints: Oxygen level is acceptable.

switch condition {
    case condition_1:
        // do something if condition_1
    case condition_2:
        // do something if condition_2
    default:
        // do something if none of the conditions are met
}

var planet = "Mars"

switch planet {
    case "Earth":
        fmt.Println("Planet is Earth.")
    case "Mars":
        fmt.Println("Planet is Mars.")
    default:
        fmt.Println("Unidentified Planet.")
}
// The code prints: Planet is Mars.

    food := "apple"

    switch food {
        case "apple", "banana", "orange":
            fmt.Println(food, "is a fruit.")
        case "carrot", "broccoli", "radish":
            fmt.Println(food, "is a vegetable.")
        case "chicken", "beef", "fish":
            fmt.Println(food, "is a meat.")
        default:
            fmt.Println("Unknown food category.")
    }

    // Output: apple is a fruit

package main

import "fmt"

func main() {
    cosmicBody := "Mars"
    
    // Checking the type of orbit using a switch case
    switch cosmicBody {
        case "Mercury", "Venus", "Earth", "Mars":
            // TODO: Print that this cosmic body orbits in the inner solar system.
            fmt.Println(cosmicBody, "orbits in the inner solar system.")
        // TODO: define the other case
        case "Jupiter", "Saturn", "Uranus", "Neptune":
            fmt.Println(cosmicBody, "orbits in the outer solar system.")
        default:
             // TODO: Handle the case where the cosmic body is unknown.
            fmt.Println("cosmic body is unknown.")
    }
}

firstName := "Neil"
lastName := "Armstrong"
fullName := firstName + " " + lastName   // Concatenation operation

fmt.Println(fullName)  // Output: Neil Armstrong

name := "Alice"
apples := 5
message := name + " has " + strconv.Itoa(apples) + " apples."  // Explicit conversion of 'int' to 'string'

fmt.Println(message)  // Output: Alice has 5 apples.

import (
    "fmt"
    "strings"
)

var sb strings.Builder
sb.WriteString("Hello, ")
sb.WriteString("World!")
sb.WriteString(" What ")
sb.WriteString("a wonderful ")
sb.WriteString("day out there!")
fmt.Println(sb.String())  // Output: Hello, World! What a wonderful day out there!

age := 3
fmt.Printf("Age: %d years old.\n", age)  // Age: 3 years old.

height := 30.32
fmt.Printf("Height: %.1f cm\n", height)  // Height: 30.3 cm

name := "Cosmo"
fmt.Printf("Name is %s\n", name)  // Name is Cosmo

package main

import (
    "fmt"
    "strings"
)

func main() {
    var sb strings.Builder
    sb.WriteString("Hello, ")
    sb.WriteString("Explorer! ")
    sb.WriteString("Embrace the Go Challenge into the Future course.")
    fmt.Println(sb.String())
}

package main

import (
    "fmt"
    "strconv"
    "strings"
)

func main() {
    userName := "Alex"
    unreadEmails := 23
    
    // TODO: Use the + operator to create a report with userName and unreadEmails.
    report1 := userName + " you have " + strconv.Itoa(unreadEmails) + " unread Mails."
    // Complete this with your concatenation code
    
    var excitement string = " Check your inbox now!"
    var builder strings.Builder
    
    // TODO: Use the strings.Builder to concatenate excitement message to the report.
    builder.WriteString(report1)
    builder.WriteString(excitement) // Replace this with the excitement string
    report2 := builder.String()
    
    fmt.Println(report2)
}

package main

import "fmt"

func main() {
    planet := "Earth"
    number := 7
    // TODO: Use fmt.Printf to state the planet's name and its number from the Sun using placeholders.
    fmt.Printf("state of planet %s and its %d from the Sun using placeholders.\n", planet, number)
}

package main

import (
    "fmt"
)

func main() {
    score := 93.2
    // TODO: Use fmt.Printf to format 'score' as a floating-point number with one decimal place and concatenate it with a custom message.
    //Output should be: Your score is 93.2%
    fmt.Printf("Your score is %.1f%%n", score)
}

var arrayName [Size]Type

var hoursStudied = [7]int{2, 3, 4, 5, 6, 3, 4}

firstDayHours := hoursStudied[0]
fmt.Println("You studied", firstDayHours, "hours on the first day")


fmt.Println("You studied", hoursStudied[1], "hours on the second day")

fmt.Println("You studied for", len(hoursStudied), "days")

firstName := "Neil"
lastName := "Armstrong"
fullName := firstName + " " + lastName   // Concatenation operation

fmt.Println(fullName)  // Output: Neil Armstrong

name := "Alice"
apples := 5
message := name + " has " + strconv.Itoa(apples) + " apples."  // Explicit conversion of 'int' to 'string'

fmt.Println(message)  // Output: Alice has 5 apples.

import (
    "fmt"
    "strings"
)

var sb strings.Builder
sb.WriteString("Hello, ")
sb.WriteString("World!")
sb.WriteString(" What ")
sb.WriteString("a wonderful ")
sb.WriteString("day out there!")
fmt.Println(sb.String())  // Output: Hello, World! What a wonderful day out there!

age := 3
fmt.Printf("Age: %d years old.\n", age)  // Age: 3 years old.

height := 30.32
fmt.Printf("Height: %.1f cm\n", height)  // Height: 30.3 cm

name := "Cosmo"
fmt.Printf("Name is %s\n", name)  // Name is Cosmo

var chocolates [3][3]string

var chocolates = [3][3]string {
  {"dark", "white", "milk"},
  {"hazelnut", "almond", "peanut"},
  {"caramel", "mint", "coffee"}}

selectedChoc := chocolates[0][2]
fmt.Println("Selected chocolate: ", selectedChoc)  // white

package main

import "fmt"

func main() {
    // TODO: Declare and initialize a two-dimensional array with your favorite sweets
    var sweets = [3][2]string { 
    // The array should have 3 rows and 2 columns
    {"dark", "white"},
    {"coffee", "milk"},
    {"caucus", "mindal"}}

    // TODO: Access and print a sweet of your choice from the array using its row and column indices
    fmt.Println("my choice from sweets", sweets[0][1])
}

var numbers []int // nil slice
fmt.Println(len(numbers))  // Output: 0  
fmt.Println(cap(numbers))  // Output: 0  

numbers := make([]int, 5)  // A slice of five integers
fmt.Println(numbers)       // Output: [0 0 0 0 0]

numbers := []int{1, 2, 3, 4, 5}  // Directly initializing a slice with elements
fmt.Println(numbers)             // Output: [1 2 3 4 5]

subSlice := numbers[1:4]         // Creating a sub-slice, slicing from 1 to 3 index
fmt.Println(subSlice)            // Output: [2 3 4]

numbers = append(numbers, 6, 7) // Appending new elements
fmt.Println(numbers)            // Output: [1 2 3 4 5 6 7]

// Removing the element at index 2
numbers = append(numbers[:2], numbers[3:]...)  // Creates a new slice by appending elements after index 2 to those before index 2
fmt.Println(numbers)                           // Output: [1 2 4 5 6 7]

moreNumbers := make([]int, len(numbers))  // Creating a new slice
copy(moreNumbers, numbers)                // Copying elements from numbers to moreNumbers
fmt.Println(moreNumbers)                  // Output: [1 2 4 5 6 7]

package main

import "fmt"

func main() {
    // Imagine managing a restaurant menu: we start with some dishes and append new ones
    menu := []string{"Pizza", "Burger", "Salad"}
    fmt.Println(menu) // Output: [Pizza Burger Salad]

    // Adding a new dish to the menu
    menu = append(menu, "Pasta")
    fmt.Println(menu) // Output: [Pizza Burger Salad Pasta]

    // Removing the 'Burger' from the menu
    menu = append(menu[:1], menu[2:]...)
    fmt.Println(menu) // Output: [Pizza Salad Pasta]
}

package main

import (
    "fmt"
)

func main() {
    // Restaurant Menu Management
    menu := []string{"Pizza", "Pasta", "Salad", "Burger"}   // Initial menu
    fmt.Println("Original Menu:", menu)
    
    // Removing the 'Salad' from the menu
    indexToRemove := 2
    lastItemIndex := 2
    menu = append(menu[:indexToRemove], menu[indexToRemove+1:]...) // Bug introduced here

    
    fmt.Println("Updated Menu:", menu)
    fmt.Println("Last menu item:", menu[lastItemIndex]) // Attempt to access the last menu item
}

// Using the make function
var grades1 = make(map[string]int)

// Using composite literal syntax
var grades2 = map[string]int{}

// Pre-populated map using composite literal syntax
var grades3 = map[string]int{"John": 85, "Jane": 90}

var grades = make(map[string]int)
grades["John"] = 85   // Store John's grade in the map
grades["Jane"] = 90   // Store Jane's grade

johnGrade := grades["John"]     // Retrieve John's grade
grades["John"] = 95             // Update John's grade

delete(grades, "John")            // Delete John's entry
johnGrade, johnExists := grades["John"]   // Check if John's grade exists
if (johnExists) {
    fmt.Println(johnGrade)  // won't execute, as John was deleted
}

var originalData = map[string]int{"apple": 1, "banana": 2}
var copiedData = originalData
copiedData["apple"] = 100

fmt.Println(originalData)
fmt.Println(copiedData)

package main

import "fmt"

func main() {
  // Classroom management with map structure
  classroomGrades := map[string]int{"Alice": 92, "Bob": 88, "Eve": 79}

  // Updating Eve's grade to an 82
  classroomGrades["Eve"] = 82
  
  // Printing the updated classroom grades
  fmt.Println(classroomGrades)
}

package main

import "fmt"

func main() {
    // Let's simulate a simple classroom grading system.
    classroomGrades := make(map[string]int)
    classroomGrades["Alice"] = 92
    classroomGrades["Bob"] = 85
    classroomGrades["Charlie"] = 78
    
    // TODO: Update Bob's grade to a better one.
    classroomGrades["Bob"] = 90
    // TODO: Print Charlie's grade and Bob's grade to the console.
    fmt.Println("Bob:", classroomGrades["Bob"], "Charlie:", classroomGrades["Charlie"])
}

for condition {
    do some action
}

countdown := 5
for countdown >= 0 {
    // The countdown will print the current number and decrease it by 1 in each loop
    fmt.Println(countdown)
    countdown--
}
// Output:
// 5
// 4
// 3
// 2
// 1
// 0

for condition {
    // process
}

for conditionStillTrue() {
    // process
}

package main

import "fmt"

func main() {
    // Create a slice representing planets in a distant galaxy
    planets := []string{"Zebes", "Hoth", "Coruscant", "Gallifrey", "Vulcan", "Cybertron", "Krypton", "Pandora"}
    
    // Using basic for-loop to iterate through all planets
    for i := 0; i < len(planets); i++ {
        fmt.Println("Visiting planet: " + planets[i])
    }
    fmt.Println()
    
    // Use range clause to visit each planet and print its name
    for _, planet := range planets {
        fmt.Println("Visiting planet: " + planet)
    }
}

package main

import "fmt"

func main() {
    planets := []string{"Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"}
    for i := 0; i < len(planets); i++ {
    
    fmt.Printf("%d -  Exploring planet:%s\n", i+1, planets[i])
    }
}

package main

import "fmt"

func main() {
    // TODO: Create a slice with the names of the planets of our solar system
    // Here is the list: Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune
    planets := []string{"Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"}
    // TODO: Use a for loop to visit (print the name of) each planet, **in reversed order**
    for i := len(planets) - 1; i >= 0; i-- {
        fmt.Println("Visiting planet: " + planets[i])
    }
    // Neptune should go first, then Uranus, etc.
    // Hint: for decrementing the variable in the loop, use `i--`, which is the same as `i = i - 1`
}

package main

import "fmt"

func main() {
    // TODO: Create a variable to keep track of the number of stars collected.
  stars := 0
    // TODO: Write a for loop that simulates the collection of stars until you have 5. 
    for stars <=5 {
        fmt.Println(stars)
        stars++
    }
        // In each iteration, print the current number of stars collected and then increment the count.

}

for i := 0; i < 5; i++ { // Iterates five times
    fmt.Println(i) // Prints 0 to 4
}

i := 0
for i < 5 { // Condition for the loop to continue
    fmt.Println(i) // Prints 0 to 4
    i++ // Increment the counter
}

asteroidsDistance := 10

if asteroidsDistance > 15 {
    fmt.Println("Navigate through the asteroids.")
} else {
    fmt.Println("Steer clear of the asteroids.")
}

for i := 0; i < 6; i++ {
    if i % 2 == 0 {
        fmt.Println(i, "is even.")  // prints for 0, 2, and 4
    } else {
        fmt.Println(i, "is odd.")  // prints for 1, 3, and 5
    }
}   

i := 0
for i < 7 { 
    if i % 3 == 0 {
        fmt.Println(i, "is divisible by 3.")  // will print for 0, 3, 6 
    } else {
        fmt.Println(i, "is not divisible by 3.")  // will print for 1, 2, 4, 5
    }
    i++
}

oxygenReadings := []float64{21.5, 20.9, 19.2, 18.0, 22.1} // Oxygen levels of different stations
safeOxygenLevel := 19.5 // Minimum safe level in percentage

for i, reading := range oxygenReadings {
    if reading < safeOxygenLevel {
        fmt.Printf("Warning! Low oxygen level at Station %d. \n", i+1)
        // will print for stations 3 and 4
    } else {
        fmt.Printf("Station %d oxygen level is safe.\n", i+1)
        // will print for stations 1, 2 and 5
    }
}

import (
    "fmt"
    "math/rand"   
)

score := 0
gameOn := true

for gameOn { 
    isAlienHit := rand.Intn(2) // Random generator for hit (1) or miss (0)

    if isAlienHit == 1 {
        fmt.Println("Alien vessel hit! +10 points")
        score += 10
    } else {
        fmt.Println("Missed! Game Over.")
        gameOn = false
    }
}
fmt.Println("Your score is", score) // Displays the final score when the game ends.

package main

import (
    "fmt"
)

func main() {
    for star := 1; star <= 5; star++ {
        if star % 2 == 0 {
            fmt.Println("Star", star, "is a Binary Star!")
        } else {
            fmt.Println("Star", star, "is a Pulsar.")
        }
    }
}

package main

import (
    "fmt"
)

// TODO: Define a struct to represent a book. Include fields like Title, Author, and Year.
type Book struct {
    Title  string
    Author string
    Year   int
}

func main (){
// TODO: Create a slice to represent a collection of books within a library.
    library := []Book{
        {Title: "The Hobbit", Author: "J.R.R. Tolkien", Year: 1937},
    }
// TODO: Add a couple of books to your library collection.
    library = append(library, Book{
        Title: "WW2",
        Author: "Mister Pister",
        Year: 2026,  
        }) 
    // TODO: Use a loop to iterate through each book and print its details to the console.
    for _, book := range library {
    fmt.Printf("Book: %s, Author: %s, Year: %d\n", book.Title, book.Author, book.Year)
    }
       
}

package main

import "fmt"

type Automobile struct {
    model string
    year  int
}

// Method to display the information of the Automobile
func (a Automobile) displayInfo() {
    fmt.Println("Model:", a.model, "Year:", a.year)
}

func main() {
    car := Automobile{"Model X", 2021}
    car.displayInfo()  // Should display: Model: Model X Year: 2021
}

package main

import "fmt"

// Car struct represents an automobile with a model and mileage
type Car struct {
    model   string
    mileage int
}

// drive method increases the mileage of the Car when it is driven
func (c *Car) drive(miles int) {
    // Increase mileage
    c.mileage += miles
}

func main() {
    myCar := Car{"Thunderbolt", 20000}

    // вызываем метод drive
    myCar.drive(150)

    // печатаем структуру
    fmt.Println(myCar)
}

package main

import "fmt"

func main() {
    temperatures := []int{21, 19, 20, 22, 18, 17, 19}
    for _, temp := range temperatures {
        // TODO: Check if the temperature is between 18 and 22 degrees inclusive and print the appropriate message.
        if temp <= 22 && temp >= 18{
            fmt.Println(temp, "degrees - Keep your helmet on.")
        }
        
    }
}

package main

import "fmt"

func main() {
    temperatures := []int{21, 19, 20, 22, 18, 17, 19}
    for _, temp := range temperatures {
        // TODO: Check if the temperature is between 18 and 22 degrees inclusive and print the appropriate message.
        if temp >=18 && temp <= 22 {
             fmt.Println(temp, "the temperature is between 18 and 22 degrees.")
        } else {
             fmt.Println(temp, "degrees - Keep your helmet on.")
        }
        
    }
}

package main

import (
	"fmt"
)

func main() {
    // TODO: Set a slice of fuel levels for each day of the week (7 elements)
     fuelLevels := []int{85, 70, 55, 74, 68, 88, 100}
    // TODO: Use a for loop to go through each day of the week
    for index, fuel := range fuelLevels {
         // TODO: Use an if-else statement to check if the fuel levels are enough for the mission
         // Let's say that the acceptable minimum fuel level is 80        
        if fuel < 80 {
         // TODO: Print the day and whether the fuel levels are not enough or satisfactory
            fmt.Printf("Day %d: %d - Not enough fuel\n", index+1, fuel)
        } else {
            fmt.Printf("Day %d: %d - Fuel level is satisfactory\n", index+1, fuel)
        }
    }
}

package main

import (
    "fmt"
)

func main() {
    meals := []string{"Breakfast", "Lunch", "Dinner"}
    tasks := []string{"Plan", "Cook"}

    for _, meal := range meals {
        // TODO: Loop through the tasks and output "<Task> <Meal>", e.g. "Plan Breakfast"
        for _, task := range tasks {
            fmt.Printf(" : %s %s \n", task, meal)
        }
    }
}

for initialization; condition; iteration {
    // outer loop code
    for initialization; condition; iteration {
        // inner loop code
    }
}

for i := 0; i < 5; i++ {
    for j := 0; j <= i; j++ {
        fmt.Print("* ") // print "* "
    }
    fmt.Println() // move to the next line
}
// Prints:
// *
// * *
// * * *
// * * * *
// * * * * * 

i := 5
for i > 0 {
    j := i
    for j > 0 {
        fmt.Print(j, " ") // print the number
        j--
    }
    fmt.Println() // move to the next line
    i--
}
// Prints:
// 5 4 3 2 1
// 4 3 2 1
// 3 2 1
// 2 1 
// 1 

intArray := [][]int{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}

for i := 0; i < len(intArray); i++ { // iterates over rows
    for j := 0; j < len(intArray[i]); j++ { // iterates over columns
        fmt.Print(intArray[i][j], " ") // prints each element
    }
    fmt.Println() // moves to the next line
}
// Prints:
// 1 2 3
// 4 5 6
// 7 8 9

intArray := [][]int{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}
searchNumber := 7
isFound := false

for i := 0; i < len(intArray); i++ { // iterates over rows
    for j := 0; j < len(intArray[i]); j++ { // iterates over columns
        if intArray[i][j] == searchNumber {
            fmt.Println("Number", searchNumber, "found at [", i, ", ", j, "]")
            isFound = true
        }
    }
}

if !isFound {
    fmt.Println("Number", searchNumber, "not found in the array.")
}
// Prints: Number 7 found at [ 2 , 0 ]

package main

import (
    "fmt"
)

func main() {
    // Daily meal preparation routine for three days
    days := []string{"Monday", "Tuesday", "Wednesday"}
    meals := []string{"Breakfast", "Lunch", "Dinner"}

    for i := 0; i < len(days); i++ {
        fmt.Println("Day:", days[i])
        for j := 0; j < len(meals); j++ {
            fmt.Println(" - Preparing", meals[j])
        }
    }
}

package main

import "fmt"

func main() {
    for i := 5; i > 0; i-- {
        fmt.Println("Countdown", i, ":")
        for j := i; j > 0; j-- {
            fmt.Println("- ", j)
        }
    }
}

package main

import "fmt"

func main() {
    i := 5
    for i > 0 {
        fmt.Println("Countdown", i, ":")
        j:= i
        for j > 0 {
            fmt.Println("- ", j)
            j--
        }
        i--
    }
}

package main

import "fmt"

func main() {
    daysOfWeek := []string{"Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"}
    mealsOfTheDay := []string{"Breakfast", "Lunch", "Dinner"}

    // Outer loop for days of the week
    for i := 0; i < len(daysOfWeek); i++ {
        // Inner loop for each meal of the day
        for j := 0; j < len(mealsOfTheDay); j++ {
            fmt.Println("Day:", daysOfWeek[i] + ", Meal:", mealsOfTheDay[j])
        }
    }
}

for i := 0; i < 10; i++ {
    if i == 7 { // When `i` reaches 7
        fmt.Println("7 found! Break!") // Message before the break
        break                           // Terminating the loop
    }
    fmt.Println("Number:", i) // Print i until we hit "break"
}
// Prints:
// Number: 0
// Number: 1
// Number: 2
// Number: 3
// Number: 4
// Number: 5
// Number: 6
// 7 found! Break!

for j := 1; j <= 10; j++ {
    if j == 4 || j == 7 { // Skip the 4th and 7th buildings
        continue
    }
    fmt.Println("Admiring building number:", j) // Continue with the rest
}
// Prints:
// Admiring building number: 1
// Admiring building number: 2
// Admiring building number: 3
// Admiring building number: 5
// Admiring building number: 6
// Admiring building number: 8
// Admiring building number: 9
// Admiring building number: 10

for i := 1; i <= 5; i++ {
    fmt.Print(i, ": ")
    for j := 1; j <= 5; j++ {
        if i == 3 && j == 3 {
            // break the inner loop
            break
        }
        fmt.Print(j, " ")
    }
    fmt.Println()
}
// Prints:
// 1: 1 2 3 4 5
// 2: 1 2 3 4 5
// 3: 1 2
// 4: 1 2 3 4 5
// 5: 1 2 3 4 5

for i := 1; i <= 5; i++ {
    fmt.Print(i, ": ")
    for j := 1; j <= 5; j++ {
        if i == 3 && j == 3 {
            continue
        }
        fmt.Print(j, " ")
    }
    fmt.Println()
}
// Prints:
// 1: 1 2 3 4 5
// 2: 1 2 3 4 5
// 3: 1 2 4 5
// 4: 1 2 3 4 5
// 5: 1 2 3 4 5

package main

import (
    "fmt"
)

func main() {
    // Digital Excursion Loop Controller
    var totalLoops = 10
    var loop = 1
    for loop <= totalLoops {
        // TODO: Bypass the glitchy loop #4
        if loop == 4 {
            loop++
            continue
        }
        fmt.Printf("Navigating loop number: %d\n", loop)
        // TODO: Initiate cool-down procedure and terminate loop after loop #7
        if loop == 7 {
            fmt.Printf(" loop stoping %d\n", loop)
            break
        }
        loop++
    }
}

package main

// TODO: Implement your main function below
import "fmt"


func main() {
    // TODO: Create a loop for the amusement park rides from 1 to 10
    for i := 1; i <= 10; i++ {
    // TODO: Skip ride #6, it's under maintenance right now
        if i == 6 {
            continue
        }
        // TODO: End your day early when reaching ride #9
        if i == 9 {
            break
        }
        // TODO: Print out the ride numbers that visitors enjoy on the way
        fmt.Println("out the ride numbers that visitors enjoy on the way", i)
        continue
        
    }
   
}

package main

import (
    "fmt"
)

func main() {
    earthMass := 5.97e24
    celestialBodyMass := map[string]float64{"Mars": 6.39e23, "Jupiter": 1.898e27}

    // TODO: Calculate the earth-to-mars mass ratio and handle a potential missing key error for Mars
    marsMass, ok := celestialBodyMass["Mars"]
    if ok {
        fmt.Printf("The mass ratio of Earth to Mars is: %g\n", earthMass/marsMass)
    } else {
        fmt.Println("Error: The mass of Mars is not available in the map.")
    }
}

package main

import "fmt"

func main() {
    var hello = "Hello, "
    var world = "World!"
    var greeting = hello + world

    fmt.Println(greeting) // "Hello, World!"
}

package main

import "fmt"

func main() {
    var firstWord = "Hello"
    var secondWord = "Hello"
    var areEqual = firstWord == secondWord

    fmt.Println(areEqual) // Outputs: true
}

package main

import "fmt"

func main() {
    var firstWord = "Apple"
    var secondWord = "Banana"
    var isLess = firstWord < secondWord
    
    fmt.Println(firstWord, "is less than", secondWord, "?", isLess) // Outputs: Apple is less than Banana? true
}

package main

import "fmt"

func main() {
    var word = "Hello"
    var length = len(word)

    fmt.Println(length) // 5
}

package main

import (
    "fmt"
    "strings"
)

func main() {
    var word = "Hello"
    var lowerCaseWord = strings.ToLower(word)
    var upperCaseWord = strings.ToUpper(word)

    fmt.Println(lowerCaseWord) // "hello"
    fmt.Println(upperCaseWord) // "HELLO"
}

package main

import (
    "fmt"
    "strings"
)

func main() {
    var sentence = " Hello, World!   "
    var trimmedSentence = strings.TrimSpace(sentence)

    fmt.Println(trimmedSentence) // "Hello, World!"
}

package main

import (
    "fmt"
    "strings"
)

func main() {
    // A book title in mixed case
    var bookTitle = "Golang For Beginners"
    var catalogTitle = strings.ToUpper(bookTitle) // TODO: Use the appropriate function to convert `bookTitle` to uppercase
    var searchKey =  strings.ToLower(bookTitle) // TODO: Use the appropriate function to convert `bookTitle` to lowercase

    fmt.Println(catalogTitle)
    fmt.Println(searchKey)
}

package main

import "fmt"

func main() {
    // Below string represents a simple formatted text editing
    // that might be seen in a document editor.
    // It uses the newline and tab special character sequences.
    fmt.Println("Title:\tGo String Manipulation\n\nContent:\n\tGo strings are powerful.\n\tThey can contain \"special characters\" like newline (\\n) and tab (\\t).")
}

package main

import "fmt"

func main() {
    // TODO: Display the document title, followed by sections with appropriate tabulations and a conclusion, all separated by newlines.
    // Here is an example of the output:
    // Title: Go String Manipulations
    //     - Introduction
    //     - Special Characters
    //     - Practice Exercises
    // Conclusion: Mastery of Go strings!
    fmt.Println("Title: Go String Manipulations\n \t- Introduction\n \t- Special Characters\n \t- Practice Exercises\nConclusion: Mastery of Go strings!")
}

package main

import (
    "fmt"
    "strings"
)

func main() {
    // A message in an online chat room:
    message := "Go is great, but please refrain from using bad words."

    // Moderating the chat by finding and replacing inappropriate language:
    moderatedMessage := strings.ReplaceAll(message, "bad words", "****")
    // Do one more change to replace "refrain from" with "avoid"
    moderatedMessage = strings.ReplaceAll(moderatedMessage, "refrain from", "avoid")
    // Display the moderated message:
    fmt.Println(moderatedMessage)
}

package main

import (
    "fmt"
    "strings"
)

func main() {
    chatMessage := "Go is cool! But sometimes, go can be challenging."

    // TODO: Add a condition to check if 'chatMessage' contains the word "go" (case insensitive)
    if strings.Contains(strings.ToLower(chatMessage), "go") {
        chatMessage = strings.ReplaceAll(chatMessage, "go", "Go")
    }
        // TODO: If it does contain, add a line to replace all occurrences of this word "go" with "Go"
    
    fmt.Println(chatMessage) // Should replace and output: "Go is cool! But sometimes, Go can be challenging."
}

package main

import (
    "fmt"
    "strings"
)

func main() {
    message := "The quick brown fox jumps over the lazy dog."
    forbiddenWord := "lazy"
    // TODO: Check if the message contains the forbidden word.
    if strings.Contains(message, forbiddenWord) {
        message = strings.ReplaceAll(message, forbiddenWord, "****")
    }
    // TODO: If it does, replace the forbidden word with "****".
    // TODO: Print the censored message.
    fmt.Println(message)
}

package main

import (
    "fmt"
    "strings"
)

func main() {
    chatMessage := "That was epic! epic win! so epic!"
    // TODO: Update the chat message by replacing the first instance of "epic" with "amazing"
    chatMessage = strings.Replace(chatMessage, "epic", "amazing", 1)
    fmt.Println(chatMessage) // This line remains unchanged. Update the variable 'chatMessage' above.
}

package main

import (
    "fmt"
    "strings"
)

func main() {
    quote := "To be, or not to be: that is the question."
    
    // TODO: Split the quotation into a slice of words
    slice := strings.Split(quote, " ")

    // TODO: Use strings.Join() to concatenate the last three words into a short snippet
    last := strings.Join(slice[7:10], " ")    
    // TODO: Now, print out the snippet of the joined three last words
    fmt.Println(last)
}

package main

import (
	"fmt"
	"strings"

	
)

func main() {
    bookQuote := "To be or not to be that is the question"

    // TODO: Use the strings.Split function to divide the quote into individual words and store them in a slice.
    words := strings.Split(bookQuote, " ")
    // TODO: Replace the last word ("question") with the word "boolean"
    words[len(words)-1] = "boolean"
    // TODO: Use the strings.Join function to recreate the quote from the slice of words.
    formattedQuote := strings.Join(words, " ")
    fmt.Println(formattedQuote) // Should print "To be or not to be that is the boolean"
}

package main

import (
    "fmt"
)

// TODO: Define a function that calculates the total price of an order
func calculateTotal(cosmicBurger float64, nebulaFries float64, starlightDrink float64) float64 {
   // This function should take three arguments: the price of a cosmic burger, nebula fries, and a starlight drink
  // TODO: Specify the prices for a cosmic burger, nebula fries, and a starlight drink
    return cosmicBurger + nebulaFries + starlightDrink   
}


// TODO: Call your function with the prices of the items and assign the result to a variable
func main() {
    // TODO: Print out the total cost of the order
    total := calculateTotal(10.00, 5.00, 3.00)
    fmt.Println(total)
}

package main

import "fmt"

func checkOxygenLevel(level int) string {
    if level > 95 {
        return "Oxygen level is good for launch."
    }
    return "Oxygen level is too low for launch!"
}

func prepareForLaunch() {
    fmt.Println("Pre-launch check:")
    oxygenStatus := checkOxygenLevel(98)  // We use a constant value for the example
    fmt.Println(oxygenStatus)
}

func main() {
    prepareForLaunch()
}

package main

import "fmt"

func checkSuitabilityForLaunch(temperature int) bool {
    return temperature >= 15 && temperature <= 35
}

func launchReadinessCheck() {
    temperature := 20 // This is a constant value for the temperature
    // TODO: Implement the function call that checks if the temperature is suitable for launch
    if checkSuitabilityForLaunch(temperature) {
        fmt.Println("Launch is allowed ")
    } else {
        fmt.Println("Launch is not allowed")
    }
}
func main() {
    launchReadinessCheck()
}

package main

import (
    "fmt"
    "sort"
)

func main() {
    planetDistances := []float64{0.39, 0.72, 1.0, 1.52, 5.2, 9.58, 19.2, 30.05} // distances from the Sun in astronomical units
    sort.Float64s(planetDistances) // Sorting in ascending order
    fmt.Println(planetDistances) // Output: [0.39, 0.72, 1.0, 1.52, 5.2, 9.58, 19.2, 30.05]
}

package main

import (
    "fmt"
    "math"
    "sort"
)

func main() {
    planets := []string{"Mercury", "Venus", "Earth", "Mars"}
    orbitDistances := []float64{57.9, 108.2, 149.6, 227.9} // distances in million kilometers

    fmt.Println(len(planets))
    // TODO: Sort the orbitDistances in ascending order
    sort.Float64s(orbitDistances)
    // TODO: Round the first element in orbitDistances to the nearest whole number and print it
    fmt.Println(math.Round(orbitDistances[0]))
    // TODO: Print the sorted orbit distances
    fmt.Println(orbitDistances)
}

package main

import "fmt"

// TODO: Define a 'Car' struct with 'model' (string) and 'year' (int) fields
type Car struct {
    model string
    year int
}

// TODO: Define a 'displayInfo' method for the 'Car' struct that returns a string
func (c Car) displayInfo() string {
    // return a formatted string here
    return fmt.Sprintf("Model: %s, Year: %d", c.model, c.year)
}
        
func main() {
    // TODO: Create an instance of 'Car' with model "Roadrunner" and year 1968
    car := Car{"Roadrunner", 1968}
    

    // TODO: Call the 'displayInfo' method on your car instance and print the result
    fmt.Println(car.displayInfo())
}

package main

import "fmt"

type Athlete interface {
    Train()
}

type Swimmer struct {
    StrokeStyle string
}

func (s Swimmer) Train() {
    fmt.Println("Training with style:", s.StrokeStyle)
}

func main() {
    var michael Athlete = Swimmer{"Butterfly"}
    michael.Train() // Output: Training with style: Butterfly
}

package main

import (
    "fmt"
)

// TODO: Define the Coach interface with TrainAthlete and GiveMotivation methods
type Coach interface {
    TrainAthlete()
    GiveMotivation()
}
// TODO: Define the AthleticCoach struct
type AthleticCoach struct {
    Name string
}

// TODO: Implement the Coach interface for AthleticCoach
func (ac AthleticCoach) TrainAthlete() {
    fmt.Println(ac.Name, "is training athletes!")
}

func (ac AthleticCoach) GiveMotivation(){
    fmt.Println(ac.Name, "Says: You can do it!")
}



func main() {
    // TODO: Create an instance of AthleticCoach and call its methods through the Coach interface
    var c Coach = AthleticCoach{Name: "Coach Carter"}
    c.TrainAthlete()
    c.GiveMotivation()
}

package main

import "fmt"

// Defining the Athlete interface with the method Train
type Athlete interface {
    Train()
}

// Runner struct represents an athletic discipline
type Runner struct {
    Distance int // distance in meters
}

// Swimmer struct represents another athletic discipline
type Swimmer struct {
    Style string
}

// Implementing the Train method for Runner
func (r Runner) Train() {
    fmt.Printf("Training for a %dm run.\n", r.Distance)
}

// TODO: Implement the Train method for Swimmer in such a manner that it prints out the swimmer's training style.
func (s Swimmer) Train() {
    fmt.Printf("Training for a %s swimming.\n", s.Style)
}


func main() {
    var athlete Athlete

    // Runner implements Athlete interface
    athlete = Runner{Distance: 5000}
    athlete.Train()

    // Swimmer also implements Athlete interface
    athlete = Swimmer{Style: "freestyle"}
    // TODO: Call the Train method for the Swimmer instance
    athlete.Train()
}

package main

import "fmt"

type School struct {
    Name    string
    Address string
}

type Student struct {
    School           // Embedding School struct into Student
    Name      string
    Age       int
}

func main() {
    eagleHigh := School{
        Name:    "Eagle High School",
        Address: "123 Bird St",
    }

    studentAlex := Student{
        School:      eagleHigh,
        Name: "Alex",
        Age:  15,
    }

    fmt.Println(studentAlex.School.Name) // Output: Eagle High School
}

package main

import "fmt"

// Animal interface
type Animal interface {
    Behavior() string
}

// Lion struct
type Lion struct{}

// Monkey struct
type Monkey struct{}

// Behavior method for Lion
func (l Lion) Behavior() string {
    return "Roar!"
}

// Behavior method for Monkey
func (m Monkey) Behavior() string {
    return "Screech!"
}

func main() {
    var animal Animal = Lion{}
    fmt.Println(animal.Behavior()) // This will print "Roar!"

    animal = Monkey{}
    fmt.Println(animal.Behavior()) // This will print "Screech!"
}