K.R.

MANGALAM UNIVERSITY

Practical File
New Age Programming Languages
COURSE CODE: ENSP465

SUBMITTED TO: SUBMITTED BY:

Mr. Deepak Kaushik AKSHAY DIXIT
Assistant Professor MCA Sem 3rd
(SOET) 2301560116
Sr No. Program Name Page No. Signature
1 Program 1: Implement a Go program to perform basic 4-6
arithmetic operations.
2 Program 2: Implement a program using control 7-8
structures to check if a given number is prime.

3 Program 3: Implement a program Using arrays and 9-10

strings to reverse a string entered by the user.
4 Program 4: Implement a program Using structs to store 11-12
and display employee details.
5 Program 5: Implement a program to read and display 13-14
content from a file.
6 Program 6: Implement a program Using basic functions 15-16
to calculate simple interest.
7 Program 7: Implement a program using list operations to 17-18
find the maximum number in a list.
8 Program 8: Implement a program to create a recursive 19-20
function to calculate the factorial of a number.
9 Program 9: Implement a program to determine if a given 21
input is positive, negative, or zero using pattern
matching
10 Program 10: Implement a program to display a greeting 22
message after a delay using asynchronous programming.

11 Program 11: Implement a program using sequences and 23-24

functions to compute squares.
12 Program 12: Implement a program to store and display 25-26
information using a map.
13 Program 13: Implement a program to filter out even 27-28
numbers from a given list.
14 Program 14: Implement a program to handle division by 29-30
zero using exception handling.
15 Program 15: Implement a program to merge two lists 31
into one and display the result

16 Program 16: Implement a program using basic string 32-33

operations to check if a string is a palindrome.

2
17 Program 17: Implement a program using loops and lists 34
to calculate the sum of elements.
18 Program 18: Implement a program design a `Student` 35-36
class with properties and display student details.

19 Program 19: Implement a program to demonstrate the 37-38

use of safe calls and the Elvis operator.
20 Program 20: Implement a program to display a message 39-40
after a delay using coroutines.

3
Program 1: Basic Calculator
Objective and Problem Statement: Use functions for arithmetic
operations. Implement a Go program to perform basic arithmetic
operations.
package main

import (
"fmt"
)

// Function for addition

func add(a, b float64) float64 {
return a + b
}

// Function for subtraction

func subtract(a, b float64) float64 {
return a - b
}

// Function for multiplication

func multiply(a, b float64) float64 {
return a * b
}

// Function for division

func divide(a, b float64) (float64, error) {
if b == 0 {
return 0, fmt.Errorf("division by zero is not allowed")
}
return a / b, nil

4
}

func main() {
var a, b float64
var operator string

// Taking user input

fmt.Println("Enter first number:")
fmt.Scanln(&a)

fmt.Println("Enter second number:")

fmt.Scanln(&b)

fmt.Println("Enter operator (+, -, *, /):")

fmt.Scanln(&operator)

// Perform the selected operation

switch operator {
case "+":
fmt.Printf("Result: %.2f\n", add(a, b))
case "-":
fmt.Printf("Result: %.2f\n", subtract(a, b))
case "*":
fmt.Printf("Result: %.2f\n", multiply(a, b))
case "/":
result, err := divide(a, b)
if err != nil {
fmt.Println("Error:", err)
} else {
fmt.Printf("Result: %.2f\n", result)
}
default:

5
 fmt.Println("Invalid operator")
}
}

Output:

6
Program 2: Check Prime Number
Objective and Problem Statement: Use control structures to check if a
given number is prime.
package main

import (
"fmt"
"math"
)

// Function to check if a number is prime

func isPrime(number int) bool {
if number <= 1 {
return false // 0 and 1 are not prime numbers
}
if number == 2 {
return true // 2 is the only even prime number
}
if number%2 == 0 {
return false // even numbers greater than 2 are not prime
}
// Check divisors from 3 to the square root of the number
for i := 3; i <= int(math.Sqrt(float64(number))); i += 2 {
if number%i == 0 {
return false
}
}
return true
}

func main() {

7
 var number int

// Taking user input

fmt.Println("Enter a number:")
fmt.Scanln(&number)

// Check if the number is prime

if isPrime(number) {
fmt.Printf("%d is a prime number.\n", number)
} else {
fmt.Printf("%d is not a prime number.\n", number)
}
}

Output:

8
Program 3: String Reversal
Objective and Problem Statement: Use arrays and strings to reverse a
string entered by the user.
package main

import (
"fmt"
)

func reverseString(input string) string {

// Convert the string to a slice of runes to handle multi-byte characters
runes := []rune(input)
n := len(runes)

// Reverse the slice of runes

for i := 0; i < n/2; i++ {
runes[i], runes[n-i-1] = runes[n-i-1], runes[i]
}

// Convert the reversed slice of runes back to a string

return string(runes)
}

func main() {
var input string

// Taking user input

fmt.Println("Enter a string:")
fmt.Scanln(&input)

// Reverse the string

9
 reversed := reverseString(input)

// Print the reversed string

fmt.Println("Reversed string:", reversed)
}

Output:

10
Program 4: Manage Employee Data
Objective and Problem Statement: Use structs to store and display
employee details.
package main

import (
"fmt"
)

type Employee struct {

firstName string
lastName string
age int
salary int
}

func main() {
emp6 := Employee{
firstName: "Shyam",
lastName: "Shyam",
age: 22,
salary: 20000,
}
fmt.Println("First Name:", emp6.firstName)
fmt.Println("Last Name:", emp6.lastName)
fmt.Println("Age:", emp6.age)
fmt.Printf("Salary: $%d\n", emp6.salary)
emp6.salary = 30000
fmt.Printf("New Salary: $%d", emp6.salary)
}

11
Output:

12
Program 5: Simple File Reader
Objective and Problem Statement: Read and display content from a
file.
package main

import (
"bufio"
"fmt"
"os"
)

func main() {
// Ask the user for the file name
fmt.Print("Enter the file name to read: ")
var fileName string
fmt.Scanln(&fileName)

// Open the file

file, err := os.Open(fileName)
if err != nil {
fmt.Printf("Error opening file: %v\n", err)
return
}
defer file.Close() // Ensure the file is closed when the program ends

// Read and display the file content line by line

fmt.Println("\nFile Content:")
scanner := bufio.NewScanner(file)
for scanner.Scan() {
fmt.Println(scanner.Text())
}

13
 // Check for scanner errors
if err := scanner.Err(); err != nil {
fmt.Printf("Error reading file: %v\n", err)
}
}

Output:

14
Program 6: Simple Interest Calculator
Objective and Problem Statement: Use basic functions to calculate
simple interest.
package main

import (
"fmt"
)

// Function to calculate simple interest

func calculateSimpleInterest(principal float64, rate float64, time float64) float64 {
return (principal * rate * time) / 100
}

func main() {
var principal, rate, time float64

// Taking user input for principal, rate, and time

fmt.Println("Enter the principal amount:")
fmt.Scanln(&principal)

fmt.Println("Enter the annual interest rate (in percentage):")

fmt.Scanln(&rate)

fmt.Println("Enter the time period (in years):")

fmt.Scanln(&time)

// Calculate simple interest

interest := calculateSimpleInterest(principal, rate, time)

// Display the result

15
 fmt.Printf("The simple interest is: %.2f\n", interest)
}

Output:

16
Program 7: Find Maximum in List
Objective and Problem Statement: Use list operations to find the
maximum number in a list.
package main

import (
"fmt"
)

// Function to find the maximum number in a list

func findMax(numbers []int) int {
if len(numbers) == 0 {
panic("List is empty, cannot find the maximum.")
}

max := numbers[0]
for _, num := range numbers {
if num > max {
max = num
}
}
return max
}

func main() {
var n int
fmt.Println("Enter the number of elements in the list:")
fmt.Scanln(&n)

// Initialize a slice to store the numbers

numbers := make([]int, n)

17
 // Take input for the list
fmt.Println("Enter the numbers:")
for i := 0; i < n; i++ {
fmt.Scanln(&numbers[i])
}

// Find and display the maximum number

max := findMax(numbers)
fmt.Printf("The maximum number in the list is: %d\n", max)
}

Output:

18
Program 8: Factorial Using Recursion
Objective and Problem Statement: Create a recursive function to
calculate the factorial of a number.
package main

import (
"fmt"
)

// Recursive function to calculate factorial

func factorial(n int) int {
if n == 0 || n == 1 {
return 1 // Base case: 0! = 1 and 1! = 1
}
return n * factorial(n-1) // Recursive case
}

func main() {
var num int

// Taking user input

fmt.Println("Enter a number to calculate its factorial:")
fmt.Scanln(&num)

if num < 0 {
fmt.Println("Factorial is not defined for negative numbers.")
} else {
// Calculate factorial using recursion
result := factorial(num)
fmt.Printf("The factorial of %d is: %d\n", num, result)

19
 }
}

Output:

20
Program 9: Pattern Matching Example
Objective and Problem Statement: Determine if a given input is
positive, negative, or zero using pattern matching
package main

import (
"fmt"
)

func main() {
var num int

// Taking user input

fmt.Println("Enter a number:")
fmt.Scanln(&num)

// Pattern matching using switch

switch {
case num > 0:
fmt.Println("The number is positive.")
case num < 0:
fmt.Println("The number is negative.")
default:
fmt.Println("The number is zero.")
}
}

Output:

21
Program 10: Asynchronous Greeting
Objective and Problem Statement: Display a greeting message after a
delay using asynchronous programming.
package main

import (
"fmt"
"time"
)

// Function to display a greeting message

func displayGreeting() {
// Introduce a delay of 3 seconds
time.Sleep(3 * time.Second)
fmt.Println("Hello! This is your greeting message after a delay.")
}

func main() {
// Launch the displayGreeting function asynchronously using a goroutine
go displayGreeting()

// Main function continues executing other code

fmt.Println("Processing... Please wait for the greeting message.")

// Wait for the goroutine to finish before the program exits

// Adding a sleep here to keep the main program running while waiting for the goroutine
time.Sleep(4 * time.Second)
}

Output:

22
Program 11: Square of Numbers in a List
Objective and Problem Statement: Use sequences and functions to
compute squares.
package main

import (
"fmt"
)

// Function to compute the square of a number

func square(num int) int {
return num * num
}

func main() {
// Define a list of numbers
numbers := []int{1, 2, 3, 4, 5, 6}

// Compute and display the square of each number using the square function
fmt.Println("Squares of numbers in the list:")
for _, num := range numbers {
fmt.Printf("The square of %d is %d\n", num, square(num))
}
}

Output:

23
24
Program 12: Simple Map Example
Objective and Problem Statement: Store and display information
using a map.
package main

import (
"fmt"
)

func main() {
// Creating a map to store employee details
employees := make(map[int]map[string]string)

// Adding employee details to the map

employees[101] = map[string]string{
"Name": "Alice",
"Position": "Developer",
}
employees[102] = map[string]string{
"Name": "Bob",
"Position": "Manager",
}
employees[103] = map[string]string{
"Name": "Charlie",
"Position": "Designer",
}

// Displaying employee details

fmt.Println("Employee Details:")
for id, details := range employees {
fmt.Printf("Employee ID: %d\n", id)

25
 for key, value := range details {
fmt.Printf("%s: %s\n", key, value)
}
fmt.Println() // Add a blank line for separation
}
}

Output:

26
Program 13: Even Numbers Filter
Objective and Problem Statement: Filter out even numbers from a
given list.
package main

import (
"fmt"
)

// Function to filter out even numbers and return only odd numbers
func filterEvenNumbers(numbers []int) []int {
var oddNumbers []int
for _, num := range numbers {
if num%2 != 0 {
oddNumbers = append(oddNumbers, num)
}
}
return oddNumbers
}

func main() {
// Define a list of numbers
numbers := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

// Filter out even numbers and get the odd numbers

oddNumbers := filterEvenNumbers(numbers)

// Display the odd numbers

fmt.Println("Odd numbers (even numbers filtered out):")
for _, num := range oddNumbers {
fmt.Println(num)

27
 }
}

Output:

28
Program 14: Handle Division by Zero
Objective and Problem Statement: Handle division by zero using
exception handling.
package main

import (
"fmt"
"errors"
)

// Function to divide two numbers with error handling for division by zero
func divide(a, b float64) (float64, error) {
if b == 0 {
// Return an error if the divisor is zero
return 0, errors.New("division by zero is not allowed")
}
return a / b, nil
}

func main() {
var num1, num2 float64

// Taking user input

fmt.Println("Enter the first number (dividend):")
fmt.Scanln(&num1)

fmt.Println("Enter the second number (divisor):")

fmt.Scanln(&num2)

// Call the divide function

result, err := divide(num1, num2)

29
 if err != nil {
// If there was an error (i.e., division by zero), print the error
fmt.Println("Error:", err)
} else {
// Otherwise, print the result
fmt.Printf("The result of %.2f / %.2f is %.2f\n", num1, num2, result)
}
}

Output:

30
Program 15: Combine Two Lists
Objective and Problem Statement: Merge two lists into one and
display the result
package main

import (
"fmt"
)

// Function to merge two lists (slices) into one

func mergeLists(list1, list2 []int) []int {
return append(list1, list2...) // Merge lists using append
}

func main() {
// Define two lists (slices)
list1 := []int{1, 2, 3, 4}
list2 := []int{5, 6, 7, 8}

// Merge the lists

mergedList := mergeLists(list1, list2)

// Display the merged list

fmt.Println("Merged list:", mergedList)
}

Output:

31
Program 16: Check Palindrome String
Objective and Problem Statement: c
package main

import (
"fmt"
"strings"
)

// Function to check if a string is a palindrome

func isPalindrome(str string) bool {
// Remove spaces and convert to lowercase for case-insensitive comparison
str = strings.ReplaceAll(str, " ", "")
str = strings.ToLower(str)

// Compare characters from start to end

start, end := 0, len(str)-1
for start < end {
if str[start] != str[end] {
return false
}
start++
end--
}
return true
}

func main() {
var input string

// Taking user input

32
 fmt.Println("Enter a string to check if it's a palindrome:")
fmt.Scanln(&input)

// Check if the string is a palindrome

if isPalindrome(input) {
fmt.Println("The string is a palindrome.")
} else {
fmt.Println("The string is not a palindrome.")
}
}

Output:

33
 Program 17: Sum of List Elements
Objective and Problem Statement: Use loops and lists to calculate the
sum of elements.
package main

import (
"fmt"
)

// Function to calculate the sum of elements in a list

func sumOfElements(numbers []int) int {
sum := 0
for _, num := range numbers {
sum += num // Add each number to sum
}
return sum
}

func main() {
// Define a list of numbers
numbers := []int{1, 2, 3, 4, 5, 6}

// Calculate the sum of elements using the sumOfElements function

result := sumOfElements(numbers)

// Display the result

fmt.Println("The sum of elements in the list is:", result)
}

Output:

34
Program 18: Create and Use Classes
Objective and Problem Statement: Design a `Student` class with
properties and display student details.
package main

import "fmt"

// Define the Student struct

type Student struct {
Name string
Age int
Grade string
RollNo int
}

// Method to display student details

func (s Student) DisplayDetails() {
fmt.Println("Student Details:")
fmt.Println("Name:", s.Name)
fmt.Println("Age:", s.Age)
fmt.Println("Grade:", s.Grade)
fmt.Println("Roll Number:", s.RollNo)
}

func main() {
// Creating an instance of Student
student1 := Student{
Name: "Alice",
Age: 22,
Grade: "A",
RollNo: 22,

35
 }

// Displaying student details

student1.DisplayDetails()
}

Output:

36
Program 19: Safe Call Example
Objective and Problem Statement: Demonstrate the use of safe calls
and the Elvis operator.
package main

import "fmt"

// Define the Student struct

type Student struct {
Name string
Grade *string // Grade is a pointer to simulate a possible nil value
}

// Safe call to retrieve the student's grade or default value if nil

func GetGrade(s *Student) string {
if s == nil || s.Grade == nil {
// Elvis-like operator, return default value if nil
return "N/A"
}
return *s.Grade
}

func main() {
// Create a student with a grade
grade := "A"
student1 := Student{
Name: "Bob",
Grade: &grade,
}

// Create a student with no grade (nil)

37
 student2 := Student{
Name: "Ram",
Grade: nil,
}

// Using the safe call approach with Elvis-like behavior

fmt.Printf("Student: %s, Grade: %s\n", student1.Name, GetGrade(&student1)) // Grade:
A
fmt.Printf("Student: %s, Grade: %s\n", student2.Name, GetGrade(&student2)) // Grade:
N/A
}

Output:

38
Program 20: Simple Coroutine Example
Objective and Problem Statement: Display a message after a delay
using coroutines.
package main

import (
"fmt"
"time"
)

// Function to display a message after a delay

func displayMessageAfterDelay(delay time.Duration, message string, done chan bool) {
// Simulate delay
time.Sleep(delay)
// Display the message after the delay
fmt.Println(message)
// Notify that the task is done
done <- true
}

func main() {
// Create a channel to signal when the task is done
done := make(chan bool)

// Start a goroutine to display a message after a 3-second delay

go displayMessageAfterDelay(3*time.Second, "Hello, this message was delayed!", done)

// Wait for the goroutine to finish

<-done

// Main function ends

39
 fmt.Println("Main function ends.")
}

Output:

40