Java Basics Quiz

Data Types & Variables (10 points)

Answer the following questions about Java data types:

1. What is the difference between int and Integer in Java? When would you use each?
2. Explain autoboxing and unboxing with an example.
3. What will be the output of the following code? Explain why.

   String s1 = "Hello";
   String s2 = "Hello";
   String s3 = new String("Hello");
   
   System.out.println(s1 == s2);
   System.out.println(s1 == s3);
   System.out.println(s1.equals(s3));

Classes & Objects (10 points)

Create a class BankAccount with the following requirements:

• Private fields: accountNumber (String), balance (double), accountHolder (String)
• A parameterized constructor that initializes all fields
• Getters for all fields, setter only for accountHolder
• Methods: deposit(double amount), withdraw(double amount) that returns boolean (false if insufficient funds)
• Override toString() to return account details

Inheritance & Polymorphism (15 points)

Using the BankAccount class from Q2, create:

1. A subclass SavingsAccount that adds an interestRate field and an addInterest() method
2. A subclass CheckingAccount that adds an overdraftLimit field and overrides withdraw() to allow overdraft up to the limit
3. Write a main method that demonstrates polymorphism by creating an array of BankAccount objects containing both types of accounts, then calling methods on each

Collections Framework (15 points)

Write Java code to complete the following tasks:

1. Create an ArrayList<String>, add 5 names, remove duplicates using a HashSet, and print the result
2. Create a HashMap<String, Integer> to store student names and their scores. Write code to:
   • Add 5 students with scores
   • Find the student with the highest score
   • Print all students who scored above average
3. Explain when you would use ArrayList vs LinkedList. Provide a specific use case for each.

Identify Time Complexity (15 points)

Determine the Big O time complexity for each of the following code snippets. Explain your reasoning.

a)

public int sumArray(int[] arr) {
    int sum = 0;
    for (int i = 0; i < arr.length; i++) {
        sum += arr[i];
    }
    return sum;
}

b)

public void printPairs(int[] arr) {
    for (int i = 0; i < arr.length; i++) {
        for (int j = 0; j < arr.length; j++) {
            System.out.println(arr[i] + ", " + arr[j]);
        }
    }
}

c)

public int binarySearch(int[] arr, int target) {
    int left = 0, right = arr.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (arr[mid] == target) return mid;
        else if (arr[mid] < target) left = mid + 1;
        else right = mid - 1;
    }
    return -1;
}

Complex Analysis (15 points)

Analyze the following code and determine both time and space complexity:

public List<List<Integer>> generateSubsets(int[] nums) {
    List<List<Integer>> result = new ArrayList<>();
    result.add(new ArrayList<>());
    
    for (int num : nums) {
        int size = result.size();
        for (int i = 0; i < size; i++) {
            List<Integer> subset = new ArrayList<>(result.get(i));
            subset.add(num);
            result.add(subset);
        }
    }
    return result;
}

1. What is the time complexity? Explain step by step.
2. What is the space complexity? Consider the output as part of the space.
3. How many subsets will be generated for an array of size n?

Best, Average, Worst Case (10 points)

For the following linear search algorithm:

public int linearSearch(int[] arr, int target) {
    for (int i = 0; i < arr.length; i++) {
        if (arr[i] == target) {
            return i;
        }
    }
    return -1;
}

1. What is the best case time complexity? When does it occur?
2. What is the average case time complexity? Explain your reasoning.
3. What is the worst case time complexity? When does it occur?

Compare & Optimize (10 points)

Given two solutions to find if an array contains any duplicates:

Solution A:

public boolean hasDuplicateA(int[] arr) {
    for (int i = 0; i < arr.length; i++) {
        for (int j = i + 1; j < arr.length; j++) {
            if (arr[i] == arr[j]) return true;
        }
    }
    return false;
}

Solution B:

public boolean hasDuplicateB(int[] arr) {
    Set<Integer> seen = new HashSet<>();
    for (int num : arr) {
        if (seen.contains(num)) return true;
        seen.add(num);
    }
    return false;
}

1. What is the time and space complexity of Solution A?
2. What is the time and space complexity of Solution B?
3. Which solution would you prefer and why? Are there scenarios where you might prefer the other?