Python

Problem 1: Write a Python function that calculates the square of a number.

Code:


    def square(number):
        """
        This function calculates the square of a number.
        """
        return number * number

Problem 2: Write a Python program to find the sum of all even numbers from 1 to N.

Solution:


    N = 10
    sum_even = sum([x for x in range(1, N + 1) if x % 2 == 0])
    print("Sum of even numbers from 1 to", N, "is", sum_even)

Problem 3: Write a Python program to calculate the average of a list of numbers.

Solution:


            numbers = [10, 20, 30, 40, 50]
            average = sum(numbers) / len(numbers)
            print("Average:", average)

Problem 4: Write a Python program to find the Nth Fibonacci number.

Solution:


        def fibonacci(n):
            if n <= 0:
                return 0
            elif n == 1:
                return 1
            else:
                return fibonacci(n - 1) + fibonacci(n - 2)

        n = 6
        result = fibonacci(n)
        print("Fibonacci number at position", n, "is", result)

Problem 5: Write a Python program to check if a given number is prime or not.

Solution:


        import math
    
        def is_prime(number):
            if number <= 1:
                return False
            for i in range(2, int(math.sqrt(number)) + 1):
                if number % i == 0:
                    return False
            return True
    
        num = 17
        if is_prime(num):
            print(num, "is prime.")
        else:
            print(num, "is not prime.")

Problem 6: Write a Python program to find the Greatest Common Divisor (GCD) of two numbers.

Solution:


        def gcd(a, b):
            while b:
                a, b = b, a % b
            return a
    
        num1, num2 = 24, 36
        result = gcd(num1, num2)
        print("GCD of", num1, "and", num2, "is", result)

Problem 7: Write a Python program to reverse the words in a sentence.

Solution:


        def reverse_words(sentence):
            words = sentence.split()
            reversed_sentence = ' '.join(reversed(words))
            return reversed_sentence
    
        input_sentence = "Hello World"
        result = reverse_words(input_sentence)
        print("Reversed sentence:", result)

Problem 8: Write a Python program to generate prime numbers up to a given limit N.

Solution:


        def generate_primes(limit):
            sieve = [True] * (limit + 1)
            sieve[0] = sieve[1] = False
            primes = []
    
            for p in range(2, int(limit**0.5) + 1):
                if sieve[p]:
                    for i in range(p * p, limit + 1, p):
                        sieve[i] = False
    
            for p in range(2, limit + 1):
                if sieve[p]:
                    primes.append(p)
            return primes
    
        limit = 20
        result = generate_primes(limit)
        print("Prime numbers up to", limit, "are:", result)

Problem 9: Find the Longest Common Subsequence

Solution:


    def longest_common_subsequence(str1, str2):
        m, n = len(str1), len(str2)
        dp = [[0] * (n + 1) for _ in range(m + 1)]
    
        for i in range(1, m + 1):
            for j in range(1, n + 1):
                if str1[i - 1] == str2[j - 1]:
                    dp[i][j] = dp[i - 1][j - 1] + 1
                else:
                    dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
    
        # Reconstruct LCS
        lcs = []
        i, j = m, n
        while i > 0 and j > 0:
            if str1[i - 1] == str2[j - 1]:
                lcs.append(str1[i - 1])
                i -= 1
                j -= 1
            elif dp[i - 1][j] > dp[i][j - 1]:
                i -= 1
            else:
                j -= 1
    
        return ''.join(reversed(lcs))
    
    str1 = "AGGTAB"
    str2 = "GXTXAYB"
    result = longest_common_subsequence(str1, str2)
    print("Longest Common Subsequence:", result)

Problem 10: Generate Parentheses

Solution:


def generate_parentheses(n):
    def backtrack(s, left, right):
        if len(s) == 2 * n:
            combinations.append(s)
            return
        if left < n:
            backtrack(s + '(', left + 1, right)
        if right < left:
            backtrack(s + ')', left, right + 1)

    combinations = []
    backtrack('', 0, 0)
    return combinations

n = 3
result = generate_parentheses(n)
print("Valid Parentheses Combinations:", result)

Data Structures and Algorithms

Problem 1: Find the Kth Element from the End of a Linked List

Solution (in C):


#include 
#include 

struct Node {
    int data;
    struct Node* next;
};

int findKthFromEnd(struct Node* head, int k) {
    struct Node* fast = head;
    struct Node* slow = head;

    // Move the fast pointer K nodes ahead
    for (int i = 0; i < k; i++) {
        if (fast == NULL) {
            return -1; // K is greater than the length of the list
        }
        fast = fast->next;
    }

    // Move both pointers until fast reaches the end
    while (fast != NULL) {
        fast = fast->next;
        slow = slow->next;
    }

    return slow->data;
}

Problem 2: Find the Maximum Element in a Stack

Solution (in C):


#include 
#include 

// Structure for a stack node
struct StackNode {
    int data;
    struct StackNode* next;
};

// Structure for the stack
struct Stack {
    struct StackNode* top;
};

// Function to create a new stack node
struct StackNode* newNode(int data) {
    struct StackNode* stackNode = (struct StackNode*)malloc(sizeof(struct StackNode));
    stackNode->data = data;
    stackNode->next = NULL;
    return stackNode;
}

// Function to create an empty stack
struct Stack* createStack() {
    struct Stack* stack = (struct Stack*)malloc(sizeof(struct Stack));
    stack->top = NULL;
    return stack;
}

// Function to push an element onto the stack
void push(struct Stack* stack, int data) {
    struct StackNode* stackNode = newNode(data);
    stackNode->next = stack->top;
    stack->top = stackNode;
}

// Function to pop an element from the stack
int pop(struct Stack* stack) {
    if (stack->top == NULL) {
        return -1; // Stack is empty
    }
    int data = stack->top->data;
    struct StackNode* temp = stack->top;
    stack->top = stack->top->next;
    free(temp);
    return data;
}

// Function to get the maximum element in the stack
int getMax(struct Stack* stack) {
    if (stack->top == NULL) {
        return -1; // Stack is empty
    }
    int max = stack->top->data;
    struct StackNode* current = stack->top->next;
    while (current != NULL) {
        if (current->data > max) {
            max = current->data;
        }
        current = current->next;
    }
    return max;
}

int main() {
    struct Stack* stack = createStack();

    push(stack, 5);
    push(stack, 10);
    push(stack, 3);
    push(stack, 7);

    printf("Max Element: %d\n", getMax(stack)); // Output: Max Element: 10

    pop(stack);
    pop(stack);

    printf("Max Element: %d\n", getMax(stack)); // Output: Max Element: 5

    return 0;
}

Problem 3: Implement a Queue using Stacks

Solution (in C):


#include 
#include 
#include 

// Structure for a stack node
struct StackNode {
    int data;
    struct StackNode* next;
};

// Structure for a stack
struct Stack {
    struct StackNode* top;
};

// Function to create a new stack node
struct StackNode* newNode(int data) {
    struct StackNode* stackNode = (struct StackNode*)malloc(sizeof(struct StackNode));
    stackNode->data = data;
    stackNode->next = NULL;
    return stackNode;
}

// Function to create an empty stack
struct Stack* createStack() {
    struct Stack* stack = (struct Stack*)malloc(sizeof(struct Stack));
    stack->top = NULL;
    return stack;
}

// Function to push an element onto the stack
void push(struct Stack* stack, int data) {
    struct StackNode* stackNode = newNode(data);
    stackNode->next = stack->top;
    stack->top = stackNode;
}

// Function to pop an element from the stack
int pop(struct Stack* stack) {
    if (stack->top == NULL) {
        return -1; // Stack is empty
    }
    int data = stack->top->data;
    struct StackNode* temp = stack->top;
    stack->top = stack->top->next;
    free(temp);
    return data;
}

// Structure for implementing a queue using two stacks
struct QueueWithStacks {
    struct Stack* stack1; // For enqueue operation
    struct Stack* stack2; // For dequeue operation
};

// Function to create an empty queue with stacks
struct QueueWithStacks* createQueueWithStacks() {
    struct QueueWithStacks* queue = (struct QueueWithStacks*)malloc(sizeof(struct QueueWithStacks));
    queue->stack1 = createStack();
    queue->stack2 = createStack();
    return queue;
}

// Function to enqueue an element into the queue
void enqueue(struct QueueWithStacks* queue, int data) {
    push(queue->stack1, data);
}

// Function to dequeue an element from the queue
int dequeue(struct QueueWithStacks* queue) {
    if (queue->stack1->top == NULL && queue->stack2->top == NULL) {
        return -1; // Queue is empty
    }
    if (queue->stack2->top == NULL) {
        // Transfer elements from stack1 to stack2
        while (queue->stack1->top != NULL) {
            push(queue->stack2, pop(queue->stack1));
        }
    }
    return pop(queue->stack2);
}

int main() {
    struct QueueWithStacks* queue = createQueueWithStacks();

    enqueue(queue, 1);
    enqueue(queue, 2);
    dequeue(queue);
    enqueue(queue, 3);
    dequeue(queue);

    printf("Elements in the queue: [");
    int element;
    while ((element = dequeue(queue)) != -1) {
        printf("%d, ", element);
    }
    printf("]\n"); // Output: Elements in the queue: [1, 2]

    return 0;
}

Problem 4: Find the Intersection of Two Arrays

Solution (in C):


#include 
#include 

// Function to find the intersection of two arrays
int* intersection(int* nums1, int nums1Size, int* nums2, int nums2Size, int* returnSize) {
    // Initialize a result array to store the intersection
    int* result = (int*)malloc(sizeof(int) * (nums1Size > nums2Size ? nums2Size : nums1Size));
    *returnSize = 0;

    // Sort both arrays to efficiently find the intersection
    qsort(nums1, nums1Size, sizeof(int), compare);
    qsort(nums2, nums2Size, sizeof(int), compare);

    int i = 0, j = 0;

    // Find the intersection
    while (i < nums1Size && j < nums2Size) {
        if (nums1[i] == nums2[j]) {
            // Add the common element to the result
            result[(*returnSize)++] = nums1[i];
            i++;
            j++;
        } else if (nums1[i] < nums2[j]) {
            i++;
        } else {
            j++;
        }
    }

    return result;
}

// Function to compare two integers (used for sorting)
int compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

int main() {
    int nums1[] = {1, 2, 2, 1};
    int nums1Size = 4;
    int nums2[] = {2, 2};
    int nums2Size = 2;
    int returnSize;

    int* result = intersection(nums1, nums1Size, nums2, nums2Size, &returnSize);

    printf("Intersection of the arrays: [");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) {
            printf(", ");
        }
    }
    printf("]\n"); // Output: Intersection of the arrays: [2]

    free(result);

    return 0;
}

Problem 5: Reverse a Linked List

Solution (in C):


#include 
#include 

// Definition for singly-linked list
struct ListNode {
    int val;
    struct ListNode* next;
};

// Function to reverse a linked list
struct ListNode* reverseList(struct ListNode* head) {
    struct ListNode* prev = NULL;
    struct ListNode* current = head;
    struct ListNode* next = NULL;

    while (current != NULL) {
        next = current->next;
        current->next = prev;
        prev = current;
        current = next;
    }

    return prev;
}

// Function to create a new node with a given value
struct ListNode* createNode(int value) {
    struct ListNode* newNode = (struct ListNode*)malloc(sizeof(struct ListNode));
    newNode->val = value;
    newNode->next = NULL;
    return newNode;
}

// Function to print a linked list
void printList(struct ListNode* head) {
    struct ListNode* current = head;
    while (current != NULL) {
        printf("%d -> ", current->val);
        current = current->next;
    }
    printf("NULL\n");
}

int main() {
    struct ListNode* head = createNode(1);
    head->next = createNode(2);
    head->next->next = createNode(3);
    head->next->next->next = createNode(4);
    head->next->next->next->next = createNode(5);

    printf("Original Linked List: ");
    printList(head); // Output: Original Linked List: 1 -> 2 -> 3 -> 4 -> 5 -> NULL

    head = reverseList(head);

    printf("Reversed Linked List: ");
    printList(head); // Output: Reversed Linked List: 5 -> 4 -> 3 -> 2 -> 1 -> NULL

    // Clean up memory
    while (head != NULL) {
        struct ListNode* temp = head;
        head = head->next;
        free(temp);
    }

    return 0;
}

Problem 6: Find the Missing Number in an Array

Solution ():


                        #include 

                            int missingNumber(int nums[], int n) {
                                int expectedSum = (n * (n + 1)) / 2;
                                int actualSum = 0;
                            
                                for (int i = 0; i < n; i++) {
                                    actualSum += nums[i];
                                }
                            
                                return expectedSum - actualSum;
                            }
                            
                            int main() {
                                int nums1[] = {3, 0, 1};
                                int n1 = sizeof(nums1) / sizeof(nums1[0]);
                                printf("Missing number: %d\n", missingNumber(nums1, n1));  // Output: 2
                            
                                int nums2[] = {9, 6, 4, 2, 3, 5, 7, 0, 1};
                                int n2 = sizeof(nums2) / sizeof(nums2[0]);
                                printf("Missing number: %d\n", missingNumber(nums2, n2));  // Output: 8
                            
                                return 0;
                            }

Problem 7: Implement a Hash Table

Solution (in C++):


#include 
#include 
#include 

class HashTable {
private:
    std::vector>> data;
    size_t size;

    size_t hash(const std::string& key) {
        size_t hashVal = 0;
        for (char c : key) {
            hashVal = (hashVal * 31 + c) % size;
        }
        return hashVal;
    }

public:
    HashTable(size_t initialSize) : size(initialSize), data(initialSize) {}

    void put(const std::string& key, int value) {
        size_t index = hash(key);
        for (auto& pair : data[index]) {
            if (pair.first == key) {
                pair.second = value;
                return;
            }
        }
        data[index].emplace_back(key, value);
    }

    int get(const std::string& key) {
        size_t index = hash(key);
        for (auto& pair : data[index]) {
            if (pair.first == key) {
                return pair.second;
            }
        }
        return -1;
    }
};

int main() {
    HashTable ht(100);

    ht.put("key1", 100);
    std::cout << "Value for key1: " << ht.get("key1") << std::endl;  // Output: Value for key1: 100

    ht.put("key2", 200);
    std::cout << "Value for key2: " << ht.get("key2") << std::endl;  // Output: Value for key2: 200

    return 0;
}

Problem 9: Find the Topological Sort of a Directed Graph

Solution (in C):


#include 
#include 

// Define a structure for a node in the graph
struct Node {
    int data;
    struct Node* next;
};

// Define a structure for the graph
struct Graph {
    int V;
    struct Node** adjList;
};

// Function to create a new node
struct Node* createNode(int data) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}

// Function to create a graph with V vertices
struct Graph* createGraph(int V) {
    struct Graph* graph = (struct Graph*)malloc(sizeof(struct Graph));
    graph->V = V;
    graph->adjList = (struct Node**)malloc(V * sizeof(struct Node*));
    for (int i = 0; i < V; i++) {
        graph->adjList[i] = NULL;
    }
    return graph;
}

// Function to add an edge to the graph
void addEdge(struct Graph* graph, int src, int dest) {
    struct Node* newNode = createNode(dest);
    newNode->next = graph->adjList[src];
    graph->adjList[src] = newNode;
}

// Function to perform topological sort
void topologicalSortUtil(struct Graph* graph, int v, int visited[], struct Node** stack) {
    visited[v] = 1;

    struct Node* current = graph->adjList[v];
    while (current != NULL) {
        int adjNode = current->data;
        if (!visited[adjNode]) {
            topologicalSortUtil(graph, adjNode, visited, stack);
        }
        current = current->next;
    }

    struct Node* newNode = createNode(v);
    newNode->next = *stack;
    *stack = newNode;
}

void topologicalSort(struct Graph* graph) {
    int* visited = (int*)malloc(graph->V * sizeof(int));
    struct Node* stack = NULL;

    for (int i = 0; i < graph->V; i++) {
        visited[i] = 0;
    }

    for (int i = 0; i < graph->V; i++) {
        if (!visited[i]) {
            topologicalSortUtil(graph, i, visited, &stack);
        }
    }

    while (stack != NULL) {
        printf("%d ", stack->data);
        stack = stack->next;
    }
    printf("\n");
}

int main() {
    int V = 4;
    struct Graph* graph = createGraph(V);
    addEdge(graph, 0, 1);
    addEdge(graph, 0, 2);
    addEdge(graph, 1, 3);
    addEdge(graph, 2, 3);

    printf("Topological Sort: ");
    topologicalSort(graph);  // Output: Topological Sort: 0 1 2 3

    return 0;
}

Java

Problem 1: Write a Java program to implement a binary search algorithm for a sorted array.

Solution (Java):


public class BinarySearch {
    public int binarySearch(int[] arr, int target) {
        int left = 0;
        int right = arr.length - 1;
        
        while (left <= right) {
            int mid = left + (right - left) / 2;
            
            if (arr[mid] == target) {
                return mid; // Element found
            } else if (arr[mid] < target) {
                left = mid + 1; // Search in the right half
            } else {
                right = mid - 1; // Search in the left half
            }
        }
        
        return -1; // Element not found
    }
}

Problem 2: Write a Java program to calculate the factorial of a given integer using recursion.

Solution (Java):


public class Factorial {
    public int calculateFactorial(int n) {
        if (n == 0) {
            return 1;
        } else {
            return n * calculateFactorial(n - 1);
        }
    }
}

Problem 3: Write a Java program to find the sum of all prime numbers within a given range.

Solution (Java):


public class PrimeSum {
    public int sumPrimesInRange(int start, int end) {
        int sum = 0;
        for (int num = start; num <= end; num++) {
            if (isPrime(num)) {
                sum += num;
            }
        }
        return sum;
    }

    public boolean isPrime(int num) {
        if (num <= 1) {
            return false;
        }
        for (int i = 2; i * i <= num; i++) {
            if (num % i == 0) {
                return false;
            }
        }
        return true;
    }
}

Problem 4: Write a Java program to count the frequency of each element in an array.

Solution (Java):


import java.util.HashMap;
import java.util.Map;

public class ElementFrequencyCounter {
    public Map countElementFrequency(int[] arr) {
        Map frequencyMap = new HashMap<>();
        
        for (int num : arr) {
            frequencyMap.put(num, frequencyMap.getOrDefault(num, 0) + 1);
        }
        
        return frequencyMap;
    }
}

Problem 5: Write a Java program to count the frequency of each element in an array.

Solution (Java):


import java.util.HashMap;
import java.util.Map;

public class ElementFrequencyCounter {
    public Map countElementFrequency(int[] arr) {
        Map frequencyMap = new HashMap<>();
        
        for (int num : arr) {
            frequencyMap.put(num, frequencyMap.getOrDefault(num, 0) + 1);
        }
        
        return frequencyMap;
    }
}

Problem 6: Write a Java program to determine if a string has all unique characters.

Solution (Java):


public class UniqueCharactersChecker {
    public boolean hasUniqueCharacters(String str) {
        boolean[] charSet = new boolean[256];
        
        for (char c : str.toCharArray()) {
            if (charSet[c]) {
                return false;
            }
            charSet[c] = true;
        }
        
        return true;
    }
}

Problem 7: Write a Java program to find the shortest path in a maze using Breadth-First Search (BFS).

Solution (Java):


import java.util.LinkedList;
import java.util.Queue;

public class MazeSolver {
    public static int[][] findShortestPath(int[][] maze, int[] start, int[] end) {
        // Implement BFS algorithm to find the shortest path
        // ...
        // Return the shortest path as a 2D array
        return new int[1][1]; // Placeholder
    }

    public static void main(String[] args) {
        int[][] maze = {
            {1, 1, 0, 0, 0},
            {0, 1, 1, 0, 1},
            {0, 0, 1, 1, 1},
            {1, 0, 0, 1, 0},
            {1, 1, 1, 1, 1}
        };

        int[] start = {0, 0};
        int[] end = {4, 4};

        int[][] shortestPath = findShortestPath(maze, start, end);

        // Print or display the shortest path
        // ...
    }
}

Problem 8: Write a Java program to implement a stack using two queues.

Solution (Java):


import java.util.LinkedList;
import java.util.Queue;

public class MyStack {
    private Queue q1;
    private Queue q2;
    private int top;

    public MyStack() {
        q1 = new LinkedList<>();
        q2 = new LinkedList<>();
    }

    public void push(int x) {
        q1.add(x);
        top = x;
    }

    public int pop() {
        while (q1.size() > 1) {
            top = q1.remove();
            q2.add(top);
        }
        int element = q1.remove();
        Queue temp = q1;
        q1 = q2;
        q2 = temp;
        return element;
    }

    public int top() {
        return top;
    }

    public boolean empty() {
        return q1.isEmpty();
    }

    public static void main(String[] args) {
        MyStack stack = new MyStack();
        
        // Push elements onto the stack
        stack.push(1);
        stack.push(2);

        // Pop the top element
        System.out.println("Pop: " + stack.pop()); // Should return 2

        // Get the top element
        System.out.println("Top: " + stack.top()); // Should return 1
    }
}

Problem 9: Write a Java program to implement a basic inventory management system for a store.

Solution:


import java.util.HashMap;
import java.util.Map;

class InventoryManager {
    private Map<String, Product> inventory;

    public InventoryManager() {
        inventory = new HashMap<>();
    }

    public void addProduct(String name, double price, int quantity) {
        // Implement product addition logic here
        // ...
    }

    public Product searchProduct(String name) {
        // Implement product search logic here
        // ...
    }

    public boolean updateQuantity(String name, int newQuantity) {
        // Implement quantity update logic here
        // ...
    }

    public void generateSalesReport() {
        // Implement sales report generation logic here
        // ...
    }
}

class Product {
    private String name;
    private double price;
    private int quantity;

    // Constructor, getters, and setters for Product class
    // ...
}

public class Main {
    public static void main(String[] args) {
        InventoryManager manager = new InventoryManager();
        
        // Perform inventory management operations and test the system
        // ...
    }
}

Problem 10: Write a Java program to implement a simple library management system.

Solution:


import java.util.HashMap;
import java.util.Map;

class LibraryManager {
    private Map<String, Book> library;
    private Map<String, String> borrowerList;

    public LibraryManager() {
        library = new HashMap<>();
        borrowerList = new HashMap<>();
    }

    public void addBook(String title, String author, String isbn) {
        // Implement book addition logic here
        // ...
    }

    public Book searchBook(String title) {
        // Implement book search logic here
        // ...
    }

    public boolean borrowBook(String title, String borrower) {
        // Implement book borrowing logic here
        // ...
    }

    public boolean returnBook(String title, String borrower) {
        // Implement book return logic here
        // ...
    }

    public void generateBorrowerList() {
        // Implement borrower's list generation logic here
        // ...
    }
}

class Book {
    private String title;
    private String author;
    private String isbn;
    private boolean isBorrowed;

    // Constructor, getters, and setters for Book class
    // ...
}

public class Main {
    public static void main(String[] args) {
        LibraryManager manager = new LibraryManager();
        
        // Perform library management operations and test the system
        // ...
    }
}

C++

Problem 1: Write a C++ program to implement a simple calculator.

Solution (C++):


#include 

int main() {
    double num1, num2;
    char operation;

    // Input
    std::cout << "Enter first number: ";
    std::cin >> num1;
    std::cout << "Enter an operation (+, -, *, /): ";
    std::cin >> operation;
    std::cout << "Enter second number: ";
    std::cin >> num2;

    // Calculate and output the result based on the operation
    switch (operation) {
        case '+':
            std::cout << "Addition result: " << num1 + num2 << std::endl;
            break;
        case '-':
            std::cout << "Subtraction result: " << num1 - num2 << std::endl;
            break;
        case '*':
            std::cout << "Multiplication result: " << num1 * num2 << std::endl;
            break;
        case '/':
            if (num2 != 0) {
                std::cout << "Division result: " << num1 / num2 << std::endl;
            } else {
                std::cout << "Error: Division by zero is not allowed." << std::endl;
            }
            break;
        default:
            std::cout << "Error: Invalid operation." << std::endl;
    }

    return 0;
}

Problem 2: Write a C++ program to find the sum of all prime numbers between two given integers.

Solution (C++):


#include 

bool isPrime(int n) {
    if (n <= 1) return false;
    for (int i = 2; i * i <= n; ++i) {
        if (n % i == 0) return false;
    }
    return true;
}

int sumPrimesInRange(int start, int end) {
    int sum = 0;
    for (int i = start; i <= end; ++i) {
        if (isPrime(i)) {
            sum += i;
        }
    }
    return sum;
}

int main() {
    int start = 10;
    int end = 50;

    int result = sumPrimesInRange(start, end);

    std::cout << "Sum of prime numbers between " << start << " and " << end << " is " << result << std::endl;

    return 0;
}

Problem 3: Write a C++ program to implement a stack that supports the following operations:

Push: Add an element to the top of the stack.
Pop: Remove the element from the top of the stack.
Top: Get the element at the top of the stack without removing it.
IsEmpty: Check if the stack is empty.

Solution (C++):


#include 
#include 

int main() {
    std::stack<int> customStack;
    
    // Push operation
    customStack.push(5);
    customStack.push(10);
    
    // Top operation
    int topElement = customStack.top();
    std::cout << "Top element: " << topElement << std::endl;
    
    // IsEmpty operation
    bool isEmpty = customStack.empty();
    
    if (isEmpty) {
        std::cout << "Stack is empty" << std::endl;
    } else {
        std::cout << "Stack is not empty" << std::endl;
    }
    
    // Pop operation
    customStack.pop();
    
    // IsEmpty operation after a pop
    isEmpty = customStack.empty();
    
    if (isEmpty) {
        std::cout << "Stack is empty" << std::endl;
    } else {
        std::cout << "Stack is not empty" << std::endl;
    }
    
    return 0;
}

Problem 4: Write a C++ program to implement a simple student grading system.

Solution (C++):


#include 
#include 
#include 
#include 

class Student {
public:
    Student(const std::string &name, int id) : name(name), id(id), totalCredits(0), totalGradePoints(0) {}

    void addGrade(const std::string &course, double grade, int credits) {
        grades[course] = std::make_pair(grade, credits);
        totalCredits += credits;
        totalGradePoints += grade * credits;
    }

    double calculateGPA() const {
        if (totalCredits == 0) {
            return 0.0;
        }
        return totalGradePoints / totalCredits;
    }

    int getID() const {
        return id;
    }

private:
    std::string name;
    int id;
    std::map> grades;
    int totalCredits;
    double totalGradePoints;
};

class GradingSystem {
public:
    void addStudent(const std::string &name, int id) {
        students[id] = Student(name, id);
    }

    bool addGrade(int id, const std::string &course, double grade, int credits) {
        if (students.find(id) != students.end()) {
            students[id].addGrade(course, grade, credits);
            return true;
        }
        return false;
    }

    double calculateGPA(int id) const {
        if (students.find(id) != students.end()) {
            return students.at(id).calculateGPA();
        }
        return 0.0;
    }

private:
    std::map students;
};

int main() {
    GradingSystem gradingSystem;
    
    // Test cases
    gradingSystem.addStudent("Alice", 1);
    gradingSystem.addStudent("Bob", 2);
    
    gradingSystem.addGrade(1, "Math", 3.7, 4);
    gradingSystem.addGrade(1, "Science", 4.0, 3);
    
    gradingSystem.addGrade(2, "History", 3.5, 3);
    gradingSystem.addGrade(2, "English", 3.2, 4);
    
    double gpa1 = gradingSystem.calculateGPA(1);
    double gpa2 = gradingSystem.calculateGPA(2);
    
    std::cout << "Alice's GPA: " << gpa1 << std::endl;
    std::cout << "Bob's GPA: " << gpa2 << std::endl;
    
    return 0;
}

Problem 5: Two Sum Given an array of integers, find two numbers such that they add up to a specific target number. Return the indices of the two numbers as an array. You may assume that each input has exactly one solution, and you may not use the same element twice.

Solution (C++):


                    #include 
                        #include 
                        #include 
                        
                        std::vector twoSum(std::vector& nums, int target) {
                            std::unordered_map numIndices;
                        
                            for (int i = 0; i < nums.size(); i++) {
                                int complement = target - nums[i];
                                if (numIndices.find(complement) != numIndices.end()) {
                                    return {numIndices[complement], i};
                                }
                                numIndices[nums[i]] = i;
                            }
                        
                            return {}; // Return an empty vector if no solution is found
                        }
                        
                        int main() {
                            std::vector nums1 = {2, 7, 11, 15};
                            int target1 = 9;
                            std::vector result1 = twoSum(nums1, target1);
                        
                            std::vector nums2 = {3, 2, 4};
                            int target2 = 6;
                            std::vector result2 = twoSum(nums2, target2);
                        
                            // Display the results
                            std::cout << "Result 1: [" << result1[0] << ", " << result1[1] << "]" << std::endl;
                            std::cout << "Result 2: [" << result2[0] << ", " << result2[1] << "]" << std::endl;
                        
                            return 0;
                        }