10 Must Ask C++ Interview Questions For Hiring Managers

int main() {

    std::cout << “Hello, World!” << std::endl;

    return 0;

}

using namespace std;

class Rectangle {

    public:

        int width, height;

        Rectangle(int w, int h) : width(w), height(h) {}

        int area() { return width * height; }

};

int main() {

    Rectangle rect(10, 20);

    cout << “Area: ” << rect.area() << endl;

    return 0;

}

• The first line contains an integer n, the size of the first sorted array.
• The second line contains n space-separated integers, elements of the first sorted array.
• The third line contains an integer m, the size of the second sorted array.
• The fourth line contains m space-separated integers, elements of the second sorted array.

1 3 5

4

2 4 6 8

#include <vector>

using namespace std;

vector<int> mergeSortedArrays(const vector<int>& a, const vector<int>& b) {

    vector<int> result;

    int i = 0, j = 0;

    while (i < a.size() && j < b.size()) {

        if (a[i] < b[j]) {

            result.push_back(a[i++]);

        } else {

            result.push_back(b[j++]);

        }

    }

    while (i < a.size()) result.push_back(a[i++]);

    while (j < b.size()) result.push_back(b[j++]);

    return result;

}

int main() {

    int n, m, temp;

    vector<int> a, b;

    cin >> n;

    for(int i = 0; i < n; i++) {

        cin >> temp;

        a.push_back(temp);

    }

    cin >> m;

    for(int i = 0; i < m; i++) {

        cin >> temp;

        b.push_back(temp);

    }

    vector<int> merged = mergeSortedArrays(a, b);

    for(int i : merged) {

        cout << i << ” “;

    }

    cout << endl;

    return 0;

}

• Not handling the case where the sizes of the input arrays are different.
• Failing to maintain the sorted order while merging.
• Forgetting to include edge cases where one array is empty.

• How can you modify this solution to handle arrays with duplicate elements?
• Can you improve the space complexity of this solution?

• Use C++ programming language features effectively to demonstrate inheritance and polymorphism.
• Ensure that the area function is overridden appropriately in each derived class.

Area of Rectangle: 20

#include <cmath>

using namespace std;

class Shape {

public:

    virtual double area() const = 0; // Pure virtual function

};

class Circle : public Shape {

private:

    double radius;

public:

    Circle(double r) : radius(r) {}

    double area() const override {

        return M_PI * radius * radius;

    }

};

class Rectangle : public Shape {

private:

    double width, height;

public:

    Rectangle(double w, double h) : width(w), height(h) {}

    double area() const override {

        return width * height;

    }

};

int main() {

    Shape* shapes[2];

    shapes[0] = new Circle(5); // Radius of the circle is 5

    shapes[1] = new Rectangle(4, 5); // Width and height of the rectangle are 4 and 5

    cout << “Area of Circle: ” << shapes[0]->area() << endl;

    cout << “Area of Rectangle: ” << shapes[1]->area() << endl;

    delete shapes[0];

    delete shapes[1];

    return 0;

}

• Forgetting to declare the area function in the base class as virtual, which is essential for achieving polymorphism.
• Incorrectly calculating the area in the derived classes.
• Not using the override keyword in the derived class functions, which helps with readability and compile-time checking.

• How would you extend this program to include more shapes, like a triangle or a square?
• Discuss how you would handle errors, such as negative dimensions for shapes.

#include <string>

using namespace std;

bool isPalindrome(const string& str, int start, int end) {

    if (start >= end) return true;

    if (str[start] != str[end]) return false;

    return isPalindrome(str, start + 1, end – 1);

}

int main() {

    string s;

    cin >> s;

    cout << (isPalindrome(s, 0, s.length() – 1) ? “Yes” : “No”) << endl;

    return 0;

}

• Not handling the base case correctly, which could lead to infinite recursion.
• Forgetting to consider the case sensitivity of characters or spaces in the string.

• How would you modify this function to ignore spaces, punctuation, and case sensitivity?
• Discuss the time complexity of your solution.

using namespace std;

void fillAndPrintArray(int size) {

    int* arr = new int[size];

    for (int i = 0; i < size; ++i) {

        arr[i] = i + 1;

        cout << arr[i] << ” “;

    }

    cout << endl;

    delete[] arr;

}

int main() {

    int n;

    cin >> n;

    fillAndPrintArray(n);

    return 0;

}

• Forgetting to deallocate the dynamically allocated memory, leading to memory leaks.
• Off-by-one errors when filling the array or printing its contents.
• Using delete instead of delete[] for deallocating arrays.

• Discuss the importance of memory management in C++ and how it compares to garbage-collected languages.
• How would you modify this function to handle potential exceptions during memory allocation?

• The first line contains an integer n, the number of integers in the list.
• The second line contains n space-separated integers representing the elements of the list.

1 2 3 4 5

#include <vector>

#include <algorithm> // For std::reverse

using namespace std;

int main() {

    int n;

    cin >> n;

    vector<int> vec(n);

    for (int i = 0; i < n; ++i) {

        cin >> vec[i];

    }

    // Reverse the vector using STL algorithm

    reverse(vec.begin(), vec.end());

    // Print the reversed vector

    for (int i : vec) {

        cout << i << ” “;

    }

    cout << endl;

    return 0;

}

• Not including the <algorithm> header, which is required for std::reverse.
• Incorrectly using std::reverse (e.g., reversing elements manually instead of using the STL function).
• Errors in handling input/output, such as incorrect loop bounds or misinterpreting the input format.

• How would you modify this program to remove duplicate elements from the vector before reversing it?
• Can you discuss the time complexity of your solution and the std::reverse function?

char str2[] = “World!”;

char* result = concatenateStrings(str1, str2);

cout << result; // Expected output: “Hello, World!”

delete[] result; // Remember to free the allocated memory

using namespace std;

char* concatenateStrings(const char* str1, const char* str2) {

    int length1 = 0;

    while (str1[length1] != ‘\0’) ++length1;

    int length2 = 0;

    while (str2[length2] != ‘\0’) ++length2;

    char* result = new char[length1 + length2 + 1]; // +1 for the null terminator

    for (int i = 0; i < length1; ++i) {

        result[i] = str1[i];

    }

    for (int i = 0; i < length2; ++i) {

        result[length1 + i] = str2[i];

    }

    result[length1 + length2] = ‘\0’;

    return result;

}

int main() {

    char str1[] = “Hello, “;

    char str2[] = “World!”;

    char* result = concatenateStrings(str1, str2);

    cout << result << endl;

    delete[] result; // Free the allocated memory

    return 0;

}

• Forgetting to allocate an extra byte for the null terminator, leading to undefined behavior.
• Failing to free the dynamically allocated memory, resulting in a memory leak.
• Off-by-one errors in array indexing or length calculations.

• How would you modify this function to handle UTF-8 encoded strings?
• Discuss how you could improve the efficiency of this function.

• Assume a reasonable limit for the number of elements the stack will hold (e.g., not exceeding 106106 elements).
• The stack will only store integer values.

• The class does not directly produce output but should provide methods to push, pop, and get the minimum element.

minStack.push(3);

minStack.push(5);

cout << minStack.getMin() << endl; // Expected output: 3

minStack.push(2);

minStack.push(1);

cout << minStack.getMin() << endl; // Expected output: 1

minStack.pop();

cout << minStack.getMin() << endl; // Expected output: 2

#include <stack>

using namespace std;

class MinStack {

private:

    stack<int> s1; // Main stack to store elements

    stack<int> s2; // Stack to store minimum elements

public:

    void push(int x) {

        s1.push(x);

        if (s2.empty() || x <= getMin()) s2.push(x);

    }

    void pop() {

        if (s1.top() == getMin()) s2.pop();

        s1.pop();

    }

    int top() {

        return s1.top();

    }

    int getMin() {

        return s2.top();

    }

};

int main() {

    MinStack minStack;

    minStack.push(3);

    minStack.push(5);

    cout << minStack.getMin() << endl; // 3

    minStack.push(2);

    minStack.push(1);

    cout << minStack.getMin() << endl; // 1

    minStack.pop();

    cout << minStack.getMin() << endl; // 2

    return 0;

}

• Not updating the minimum element correctly upon pop operations, especially when the minimum element is removed.
• Forgetting to check if stacks are empty before calling top on s2.

• How would you modify this class to also be able to return the maximum element in constant time?
• Discuss the space complexity of your implementation.

• The number of nodes in the linked list will not exceed 104104.
• Node values will be integer numbers.

using namespace std;

class ListNode {

public:

    int val;

    ListNode *next;

    ListNode(int x) : val(x), next(nullptr) {}

};

bool hasCycle(ListNode *head) {

    if (head == nullptr) return false;

    ListNode *slow = head, *fast = head;

    while (fast->next != nullptr && fast->next->next != nullptr) {

        slow = slow->next;

        fast = fast->next->next;

        if (slow == fast) {

            return true;

        }

    }

    return false;

}

// Example usage is omitted as per the new instructions.

• Not handling the case where the list is empty or contains only one node.
• Incorrectly updating the slow and fast pointers, leading to infinite loops or missed detections.

• The first line contains an integer n, the number of elements in the rotated sorted array.
• The second line contains n space-separated integers representing the elements of the rotated sorted array.
• The third line contains the target value target to search for in the array.

4 5 6 7 0 1 2

0

#include <vector>

using namespace std;

int search(vector<int>& nums, int target) {

    int left = 0, right = nums.size() – 1;

    while (left <= right) {

        int mid = left + (right – left) / 2;

        if (nums[mid] == target) return mid;

        // Check if the left side is sorted

        if (nums[left] <= nums[mid]) {

            if (target >= nums[left] && target < nums[mid]) {

                right = mid – 1;

            } else {

                left = mid + 1;

            }

        }

        // Otherwise, the right side must be sorted

        else {

            if (target > nums[mid] && target <= nums[right]) {

                left = mid + 1;

            } else {

                right = mid – 1;

            }

        }

    }

    return -1;

}

int main() {

    vector<int> nums = {4, 5, 6, 7, 0, 1, 2};

    int target = 0;

    cout << search(nums, target) << endl;

    return 0;

}

• Failing to correctly identify which half of the array is sorted.
• Incorrectly adjusting the search boundaries, especially near the pivot point of rotation.
• Overlooking edge cases, such as arrays with only one element or when the target is equal to the midpoint.

• The first line contains an integer n, the number of elements in the array.
• The second line contains n space-separated integers representing the elements of the array.
• The third line contains an integer k, the index of the largest element to find (zero-based).

3 2 1 5 6 4

2

#include <vector>

#include <algorithm>

using namespace std;

int findKthLargest(vector<int>& nums, int k) {

    sort(nums.begin(), nums.end(), greater<int>());

    return nums[k];

}

int main() {

    vector<int> nums = {3, 2, 1, 5, 6, 4};

    int k = 2; // Looking for the 2nd largest element

    cout << findKthLargest(nums, k) << endl;

    return 0;

}

• Misunderstanding the zero-based indexing and returning the wrong element.
• Using an inefficient sorting method or failing to consider more efficient selection algorithms.