//Slip1
A)Write a program in GO language to
accept user choice and print answers
using arithmetic operators.
package main
import (
"fmt"
)
func main() {
var choice string
fmt.Print("Enter your choice (+/-/*): ")
fmt.Scanln(&choice)
var num1, num2 float64
fmt.Print("Enter first number: ")
fmt.Scanln(&num1)
fmt.Print("Enter second number: ")
fmt.Scanln(&num2)
switch choice {
case "+":
fmt.Printf("Result of addition: %.2f\n", num1+num2)
case "-":
fmt.Printf("Result of subtraction: %.2f\n", num1-num2)
case "*":
fmt.Printf("Result of multiplication: %.2f\n", num1*num2)
case "/":
fmt.Printf("Result Of Division : %.2f\n",num1/num2)
default:
fmt.Println("Invalid choice!")
}
}
B)Write a program in GO language to
accept n student details like roll_no,
stud_name, mark1,mark2, mark3.
Calculate the total and average of
marks using structure.
package main
import (
"fmt"
)
type student struct {
rollNo int
studName string
mark1 float64
mark2 float64
mark3 float64
}
func (s *student) calculateTotal() float64 {
return s.mark1 + s.mark2 + s.mark3
}
func (s *student) calculateAverage() float64 {
return s.calculateTotal() / 3
}
func main() {
var n int
fmt.Println("Enter the number of students:")
fmt.Scanln(&n)
students := make([]student, n)
for i := 0; i < n; i++ {
fmt.Printf("Enter details for student %d:\n", i+1)
fmt.Print("Roll No: ")
fmt.Scanln(&students[i].rollNo)
fmt.Print("Name: ")
fmt.Scanln(&students[i].studName)
fmt.Print("Mark 1: ")
fmt.Scanln(&students[i].mark1)
fmt.Print("Mark 2: ")
fmt.Scanln(&students[i].mark2)
fmt.Print("Mark 3: ")
fmt.Scanln(&students[i].mark3)
}
fmt.Println("\nStudent Details:")
for i, s := range students {
fmt.Printf("Student %d\n", i+1)
fmt.Printf("Roll No: %d\n", s.rollNo)
fmt.Printf("Name: %s\n", s.studName)
fmt.Printf("Mark 1: %.2f\n", s.mark1)
fmt.Printf("Mark 2: %.2f\n", s.mark2)
fmt.Printf("Mark 3: %.2f\n", s.mark3)
fmt.Printf("Total Marks: %.2f\n", s.calculateTotal())
fmt.Printf("Average Marks: %.2f\n\n", s.calculateAverage())
}
}
//slip2
A)Write a program in GO language to
print Fibonacci series of n terms.
package main
// import "fmt"
// func main() {
// var a, b, c, i int
// a = 0
// b = 1
// fmt.Println("Fibonacci Series:")
// fmt.Print(a, " ", b, " ")
// for i = 1; i <= 8; i++ {
// c = a + b
// a = b
// b = c
// fmt.Print(c, " ")
// }
// }
B)Write a program in GO language to print file information.
package main
import (
"fmt"
"os"
)
func main() {
// Prompt the user to enter the file path
fmt.Print("Enter the file path: ")
var filePath string
fmt.Scanln(&filePath)
// Open the file
file, err := os.Open(filePath)
if err != nil {
fmt.Println("Error:", err)
return
}
defer file.Close()
// Get file information
fileInfo, err := file.Stat()
if err != nil {
fmt.Println("Error:", err)
return
}
// Print file information
fmt.Println("File Name:", fileInfo.Name())
fmt.Println("Size (in bytes):", fileInfo.Size())
fmt.Println("Permissions:", fileInfo.Mode())
fmt.Println("Is Directory?", fileInfo.IsDir())
fmt.Println("Last Modified:", fileInfo.ModTime())
}
//slip3
A)Write a program in the GO language
using function to check whether
accepts number is palindrome or
not.
package main
// import "fmt"
// func main() {
// var num, res, sum, originalNum int
// fmt.Println("Enter The Number:")
// fmt.Scanln(&num)
// originalNum = num
// for num > 0 {
// res = num % 10
// sum = sum*10 + res
// num = num / 10
// }
// if originalNum == sum {
// fmt.Println("Number Is Palindrome")
// } else {
// fmt.Println("Number Is Not Palindrome")
// }
// }
B)Write a Program in GO language to
accept n records of employee
information (eno,ename,salary) and
display record of employees having
maximum salary.
package main
import (
"fmt"
)
type employee struct {
eno int
ename string
salary float64
}
func main() {
var n int
fmt.Println("Enter the number of employees:")
fmt.Scanln(&n)
employees := make([]employee, n)
// Accept employee records
for i := 0; i < n; i++ {
fmt.Printf("Enter details for employee %d:\n", i+1)
fmt.Print("Employee Number: ")
fmt.Scanln(&employees[i].eno)
fmt.Print("Employee Name: ")
fmt.Scanln(&employees[i].ename)
fmt.Print("Salary: ")
fmt.Scanln(&employees[i].salary)
}
// Find maximum salary
maxSalary := employees[0].salary
for _, emp := range employees {
if emp.salary > maxSalary {
maxSalary = emp.salary
}
}
// Display employees with maximum salary
fmt.Println("\nEmployees with Maximum Salary:")
for _, emp := range employees {
if emp.salary == maxSalary {
fmt.Printf("Employee Number: %d\n", emp.eno)
fmt.Printf("Employee Name: %s\n", emp.ename)
fmt.Printf("Salary: %.2f\n\n", emp.salary)
}
}
}
slip4
A)Write a program in GO language to
print a recursive sum of digits of a
given number.
package main
import (
"fmt"
)
// Function to calculate the sum of digits recursively
func sumOfDigitsRecursive(number int) int {
// Base case: if the number is less than 10, return the number itself
if number < 10 {
return number
}
// Recursive case: sum the last digit with the sum of digits of the remaining
number
return number%10 + sumOfDigitsRecursive(number/10)
}
func main() {
// Prompt the user to enter the number
fmt.Print("Enter a number: ")
var num int
fmt.Scanln(&num)
// Calculate the recursive sum of digits
sum := sumOfDigitsRecursive(num)
// Print the result
fmt.Printf("Recursive Sum of Digits of %d is %d\n", num, sum)
}
B)Write a program in GO language
to sort array elements in
ascending order.
package main
// import (
// "fmt"
// "sort"
// )
// func main(){
// num :=[]int{22,33,4,1,60,56,78,8}
// sort.Ints(num)
// fmt.Println("After The Sorting Array",num)
// }
slip 5
A)Write a program in GO language program to create Text file
package main
import (
"fmt"
"os"
)
func main() {
// Create a file
file, err := os.Create("employees.txt")
if err != nil {
fmt.Println("Error creating file:", err)
return
}
defer file.Close()
// Write some data to the file
data := []byte("Employee Number, Employee Name, Salary\n")
_, err = file.Write(data)
if err != nil {
fmt.Println("Error writing to file:", err)
return
}
fmt.Println("File 'employees.txt' created successfully.")
}
B)Write a program in GO language to
accept n records of employee
information (eno,ename,salary) and
display records of employees having
minimum salary.
package main
import (
"fmt"
"os"
)
type employee struct {
eno int
ename string
salary float64
}
func main() {
var n int
fmt.Println("Enter the number of employees:")
fmt.Scanln(&n)
employees := make([]employee, n)
var minSalary float64
// Accept employee records
for i := 0; i < n; i++ {
fmt.Printf("Enter details for employee %d:\n", i+1)
fmt.Print("Employee Number: ")
fmt.Scanln(&employees[i].eno)
fmt.Print("Employee Name: ")
fmt.Scanln(&employees[i].ename)
fmt.Print("Salary: ")
fmt.Scanln(&employees[i].salary)
// Initialize minSalary with the salary of the first employee
if i == 0 || employees[i].salary < minSalary {
minSalary = employees[i].salary
}
}
// Display employees with minimum salary
fmt.Println("\nEmployees with Minimum Salary:")
for _, emp := range employees {
if emp.salary == minSalary {
fmt.Printf("Employee Number: %d\n", emp.eno)
fmt.Printf("Employee Name: %s\n", emp.ename)
fmt.Printf("Salary: %.2f\n\n", emp.salary)
}
}
}
slip 6
A)Write a program in GO language to
accept two matrices and display its
multiplication
package main
import "fmt"
func multiplyMatrices(matrix1 [][]int, matrix2 [][]int) [][]int {
rows1 := len(matrix1)
cols1 := len(matrix1[0])
cols2 := len(matrix2[0])
result := make([][]int, rows1)
for i := range result {
result[i] = make([]int, cols2)
}
for i := 0; i < rows1; i++ {
for j := 0; j < cols2; j++ {
for k := 0; k < cols1; k++ {
result[i][j] += matrix1[i][k] * matrix2[k][j]
}
}
}
return result
}
func displayMatrix(matrix [][]int) {
for _, row := range matrix {
fmt.Println(row)
}
}
func main() {
var rows1, cols1, rows2, cols2 int
fmt.Println("Enter the number of rows and columns of first matrix:")
fmt.Scanln(&rows1, &cols1)
fmt.Println("Enter the number of rows and columns of second matrix:")
fmt.Scanln(&rows2, &cols2)
if cols1 != rows2 {
fmt.Println("Matrices cannot be multiplied. Number of columns of first
matrix must be equal to number of rows of second matrix.")
return
}
matrix1 := make([][]int, rows1)
matrix2 := make([][]int, rows2)
fmt.Println("Enter elements of first matrix:")
for i := 0; i < rows1; i++ {
matrix1[i] = make([]int, cols1)
for j := 0; j < cols1; j++ {
fmt.Printf("Enter element [%d][%d]: ", i, j)
fmt.Scanln(&matrix1[i][j])
}
}
fmt.Println("Enter elements of second matrix:")
for i := 0; i < rows2; i++ {
matrix2[i] = make([]int, cols2)
for j := 0; j < cols2; j++ {
fmt.Printf("Enter element [%d][%d]: ", i, j)
fmt.Scanln(&matrix2[i][j])
}
}
result := multiplyMatrices(matrix1, matrix2)
fmt.Println("Result of matrix multiplication:")
displayMatrix(result)
}
B)Write a program in GO language to
copy all elements of one array into
another using a method.
package main
import "fmt"
func copyArray(source []int, destination []int) {
for i, val := range source {
destination[i] = val
}
}
func main() {
source := []int{1, 2, 3, 4, 5}
destination := make([]int, len(source))
copyArray(source, destination)
fmt.Println("Source Array:", source)
fmt.Println("Destination Array:", destination)
}
slip7
Write a program in GO language to
create structure student. Writea
method show() whose receiver is a
pointer of struct student.
package main
// import (
// "fmt"
// )
// type student struct {
// Name string
// Age int
// Gender string
// }
// func (s *student) show() {
// fmt.Println("Name:", s.Name)
// fmt.Println("Age:", s.Age)
// fmt.Println("Gender:", s.Gender)
// }
// func main() {
// s := student{
// Name: "Sahid Shaikh",
// Age: 20,
// Gender: "Male",
// }
// s.show()
// }
slip8
A) Write a program in GO language to
accept the book details such as
BookID, Title, Author, Price. Read
and display the details of ‘n’ number
of books
package main
// import (
// "fmt"
// )
// type book struct {
// BookID int
// Title string
// Author string
// Price float64
// }
// func main() {
// var n int
// fmt.Println("Enter the number of books:")
// fmt.Scan(&n)
// books := make([]book, n)
// for i := 0; i < n; i++ {
// fmt.Printf("Enter details for book %d:\n", i+1)
// fmt.Print("BookID: ")
// fmt.Scan(&books[i].BookID)
// fmt.Print("Title: ")
// fmt.Scan(&books[i].Title)
// fmt.Print("Author: ")
// fmt.Scan(&books[i].Author)
// fmt.Print("Price: ")
// fmt.Scan(&books[i].Price)
// }
// fmt.Println("Book Details:")
// for i, b := range books {
// fmt.Printf("Book %d:\n", i+1)
// fmt.Println("BookID:", b.BookID)
// fmt.Println("Title:", b.Title)
// fmt.Println("Author:", b.Author)
// fmt.Println("Price:", b.Price)
// fmt.Println()
// }
// }
B) Write a program in GO language to
create an interface shape that
includes area and perimeter.
Implements these methods in circle
and rectangle type.
package main
import (
"fmt"
"math"
)
// Shape interface
type Shape interface {
Area() float64
Perimeter() float64
}
// Circle type
type Circle struct {
Radius float64
}
// Rectangle type
type Rectangle struct {
Length float64
Width float64
}
// Method to calculate area of circle
func (c Circle) Area() float64 {
return math.Pi * c.Radius * c.Radius
}
// Method to calculate perimeter of circle
func (c Circle) Perimeter() float64 {
return 2 * math.Pi * c.Radius
}
// Method to calculate area of rectangle
func (r Rectangle) Area() float64 {
return r.Length * r.Width
}
// Method to calculate perimeter of rectangle
func (r Rectangle) Perimeter() float64 {
return 2 * (r.Length + r.Width)
}
func main() {
// Create a circle with radius 5
circle := Circle{Radius: 5}
fmt.Println("Circle - Area:", circle.Area())
fmt.Println("Circle - Perimeter:", circle.Perimeter())
// Create a rectangle with length 4 and width 3
rectangle := Rectangle{Length: 4, Width: 3}
fmt.Println("Rectangle - Area:", rectangle.Area())
fmt.Println("Rectangle - Perimeter:", rectangle.Perimeter())
}
slip9
A) Write a program in GO language to
create an interface and display its
values with the help of type
assertion.
package main
import "fmt"
// Shape interface
type Shape interface {
Area() float64
}
// Circle type
type Circle struct {
Radius float64
}
// Rectangle type
type Rectangle struct {
Length float64
Width float64
}
// Method to calculate area of circle
func (c Circle) Area() float64 {
return 3.14 * c.Radius * c.Radius
}
// Method to calculate area of rectangle
func (r Rectangle) Area() float64 {
return r.Length * r.Width
}
func main() {
// Define a slice of shapes
shapes := []Shape{
Circle{Radius: 5},
Rectangle{Length: 4, Width: 3},
}
// Display areas of shapes using type assertion
for _, shape := range shapes {
switch s := shape.(type) {
case Circle:
fmt.Printf("Circle - Area: %.2f\n", s.Area())
case Rectangle:
fmt.Printf("Rectangle - Area: %.2f\n", s.Area())
}
}
}
B) Write a program in GO language
to read and write Fibonacci series
to the using channel.
package main
// import "fmt"
// func fibonacci(c chan<- int, n int) {
// a, b := 0, 1
// for i := 0; i < n; i++ {
// c <- a
// a, b = b, a+b
// }
// close(c)
// }
// func main() {
// ch := make(chan int)
// go fibonacci(ch, 10)
// for num := range ch {
// fmt.Print(num, " ")
// }
// }
slip 10
A) Write a program in GO language to
check whether the accepted number
is two digit or not.
package main
// import "fmt"
// func main(){
// var num int
// fmt.Println("Enter The Number")
// fmt.Scan(&num)
// if num>=10 && num<100{
// fmt.Println("Number Is Two Digit")
// } else {
// fmt.Println("Number Is Not Two Digit")
// }
// }
slip 12
A) Write a program in GO language to print
sum of all even and odd numbers
separately between 1 to 100.
// package main
// import "fmt"
// func swap(x *int, y *int) {
// var temp int
// temp = *x
// *x = *y
// *y = temp
// }
// func main() {
// var a, b int
// a = 10
// b = 20
// swap(&a, &b)
// fmt.Println("Swapping of 10 and 20 Is :",a,b)
// }
slip 13
A) Write a program in GO language to print
sum of all even and odd numbers
separately between 1 to 100.
package main
// import "fmt"
// func main(){
// var evensum,oddsum,i int
// for i=0;i<=100;i++{
// if i%2==0 {
// evensum+=i
// }else {
// oddsum+=i
// }
// }
// fmt.Println("Even Sum Is :",evensum)
// fmt.Println("ODD Sum Is :",oddsum)
// }
B) Write a function in GO language to
find the square of a number and
write a benchmark for it.
package main
import (
"testing"
)
// Function to find the square of a number
func Square(num int) int {
return num * num
}
// Benchmark for Square function
func BenchmarkSquare(b *testing.B) {
// Run the Square function b.N times
for i := 0; i < b.N; i++ {
Square(10) // You can change the input number as needed
}
}
go test -bench=.
slip14
Write a program in GO language to
demonstrate working of slices (like
append, remove, copy etc.)
package main
// import "fmt"
// func main() {
// slice := []int{1, 2, 3, 4, 5}
// fmt.Println("After Appending", append(slice, 6, 7, 8))
// copySlice := make([]int, len(slice))
// copy(copySlice, slice)
// fmt.Println("After Copy", copySlice)
// removeIndex := 2
// slice = append(slice[:removeIndex], slice[removeIndex+1:]...)
// fmt.Println("After Remove",slice)
// }
slip15
package main
// import (
// "fmt"
// "time"
// )
// func main() {
// for i := 0; i <= 10; i++ {
// fmt.Println(i)
// delay(250 * time.Millisecond)
// }
// }
// func delay(duration time.Duration) {
// time.Sleep(duration)
// }
slip16
AA) Write a program in GO language to
illustrate the concept of returning
multiple values from a function. (
Add, Subtract, Multiply, Divide)
package main
// import "fmt"
// func multiple(a,b int)(int , int , int , int){
// sum:=a+b
// sub:=a-b
// mul:=a*b
// div:=a/b
// return sum,sub,mul,div
// }
// func main(){
// sum,sub,mul,div:=multiple(50,25)
// fmt.Println("Sum IS :",sum)
// fmt.Println("Sub IS :",sub)
// fmt.Println("Mul IS :",mul)
// fmt.Println("Division IS :",div)
// }
B) Write a program in GO language to
read XML file into structure and
display structure
package main
import (
"encoding/xml"
"fmt"
"io/ioutil"
"os"
)
// Employee structure to represent employee information
type Employee struct {
XMLName xml.Name `xml:"employee"`
ID int `xml:"id"`
FirstName string `xml:"firstname"`
LastName string `xml:"lastname"`
Department string `xml:"department"`
}
func main() {
// Open the XML file
file, err := os.Open("employees.xml")
if err != nil {
fmt.Println("Error opening file:", err)
return
}
defer file.Close()
// Read the XML content
xmlData, err := ioutil.ReadAll(file)
if err != nil {
fmt.Println("Error reading file:", err)
return
}
// Create a variable to hold the decoded XML data
var employees []Employee
// Unmarshal the XML data into the employees variable
err = xml.Unmarshal(xmlData, &employees)
if err != nil {
fmt.Println("Error decoding XML:", err)
return
}
// Display the employee information
for _, emp := range employees {
fmt.Println("Employee ID:", emp.ID)
fmt.Println("First Name:", emp.FirstName)
fmt.Println("Last Name:", emp.LastName)
fmt.Println("Department:", emp.Department)
fmt.Println()
}
}
slip 18
A) Write a program in GO language to print a
multiplication table of number using
function.
package main
// import "fmt"
// func multiplication(num int){
// var i int
// for i=1;i<=10;i++{
// fmt.Println(num*i)
// }
// }
// func main(){
// multiplication(12)
// }
B) Write a program in GO language using
a user defined package calculator
that performs one calculator
operation as per the user's choice.
// calculator.go
package calculator
// Add returns the sum of two numbers
func Add(a, b float64) float64 {
return a + b
}
// Subtract returns the difference between two numbers
func Subtract(a, b float64) float64 {
return a - b
}
// Multiply returns the product of two numbers
func Multiply(a, b float64) float64 {
return a * b
}
// Divide returns the division of two numbers
func Divide(a, b float64) float64 {
if b == 0 {
panic("division by zero")
}
return a / b
}
// main.go
package main
import (
"fmt"
"calculator"
)
func main() {
var choice int
var a, b float64
fmt.Println("Choose operation:")
fmt.Println("1. Add")
fmt.Println("2. Subtract")
fmt.Println("3. Multiply")
fmt.Println("4. Divide")
fmt.Print("Enter your choice (1-4): ")
fmt.Scanln(&choice)
fmt.Print("Enter first number: ")
fmt.Scanln(&a)
fmt.Print("Enter second number: ")
fmt.Scanln(&b)
var result float64
switch choice {
case 1:
result = calculator.Add(a, b)
case 2:
result = calculator.Subtract(a, b)
case 3:
result = calculator.Multiply(a, b)
case 4:
result = calculator.Divide(a, b)
default:
fmt.Println("Invalid choice")
return
}
fmt.Println("Result:", result)
}
slip19
A) Write a program in GO language
to illustrate the function returning
multiple values(add, subtract).
package main
// import "fmt"
// func multiple(a, b int) (int, int) {
// sum := a + b
// sub := a - b
// return sum, sub
// }
// func main() {
// num1,num2:=50,20
// sum,sub:=multiple(num1,num2)
// fmt.Println("Sum Is : ",sum)
// fmt.Println("Sub Is :",sub)
// }
B) Write a program in the GO
language program to open a file in
READ only mode.
package main
import (
"fmt"
"os"
)
func main() {
// Open the file in read-only mode
file, err := os.Open("example.txt")
if err != nil {
fmt.Println("Error:", err)
return
}
defer file.Close()
fmt.Println("File opened successfully.")
}
slip 20
A) Write a program in Go language to
add or append content at the end of a
text file.
package main
import (
"fmt"
"os"
)
func main() {
// Open the file in append mode, create it if it doesn't exist
file, err := os.OpenFile("example.txt", os.O_WRONLY|os.O_APPEND|os.O_CREATE,
0644)
if err != nil {
fmt.Println("Error:", err)
return
}
defer file.Close()
// Write content to the file
content := "This is new content to be added."
_, err = file.WriteString(content + "\n")
if err != nil {
fmt.Println("Error:", err)
return
}
fmt.Println("Content appended successfully.")
}
B) Write a program in Go language how to
create a channel and illustrate how
to close a channel using for range
loop and close function.
package main
import (
"fmt"
)
func main() {
// Create a channel of type int
ch := make(chan int)
// Producer: send values to the channel
go func() {
defer close(ch)
for i := 1; i <= 5; i++ {
ch <- i
}
}()
// Consumer: receive values from the channel
for num := range ch {
fmt.Println("Received:", num)
}
fmt.Println("Channel closed.")
}
