80+ C Developer Interview Questions and Answers

Given a string and an integer, create a new string by selecting the smallest character from the first K characters of the input string and repeating the process until the input string is empty.

• Iterate through the input string, selecting the smallest character from the first K characters each time.

• Remove the selected character from the input string and append it to the new string.

• Continue this process until the input string is empty.

• Return the final new string formed.

Merge K sorted arrays into a single sorted array.

• Create a min heap to store the first element of each array along with the array index.

• Pop the top element from the heap, add it to the result array, and push the next element from the same array back to the heap.

• Continue this process until all elements are processed.

• Time complexity can be optimized using a priority queue or merge sort technique.

Sort an array of 0s, 1s, and 2s in linear time complexity.

• Use three pointers to keep track of 0s, 1s, and 2s while iterating through the array.

• Swap elements based on the values encountered to sort the array in-place.

• Ensure to handle edge cases like all 0s, all 1s, and all 2s in the array.

Given an array of digits and an integer K, find the maximum number by swapping digits up to K times.

• Sort the digits in non-increasing order to maximize the number.

• Swap the digits to achieve the maximum number within the given number of swaps.

• Handle cases where there are repeating digits and leading zeros.

Move all zeroes to the end of an unsorted array while maintaining the order of non-zero elements.

• Iterate through the array and keep track of the index to place non-zero elements.

• Once all non-zero elements are placed, fill the rest of the array with zeroes.

• Ensure to maintain the relative order of non-zero elements.

• Example: Input: [0, 1, -2, 3, 4, 0, 5, -27, 9, 0], Output: [1, -2, 3, 4, 5, -27, 9, 0, 0, 0]

Given a preorder traversal of a BST, construct the BST and return its inorder traversal.

• Create a binary search tree from the preorder traversal array

• Return the inorder traversal of the constructed BST

• Ensure each element in the array is distinct

Structures in C++ allow for multiple data types to be grouped together, while unions share the same memory space for all members.

• Structures in C++ can hold multiple data types, each with its own memory allocation.

• Unions in C++ share the same memory space for all members, allowing only one member to be active at a time.

• Structures are used when different types of data need to be stored together, while unions are used when only one type of data needs to be stored at a time.

Dynamic memory allocation in C allows for allocating memory at runtime, enabling flexibility in memory usage.

• Dynamic memory allocation is done using functions like malloc(), calloc(), realloc() in C.

• It allows for allocating memory as needed during program execution.

• Dynamic memory allocation helps in managing memory efficiently by allocating and deallocating memory as required.

• Example: int *ptr = (int*)malloc(5 * sizeof(int)); // Allocates memory for an array of 5 integers

To convert a value from Big Endian to Little Endian format, reverse the order of bytes.

• Iterate through the bytes of the value in reverse order

• Swap the positions of each byte to convert from Big Endian to Little Endian

• Example: Big Endian value 0x12345678 becomes Little Endian value 0x78563412

Const pointer and pointer to const in multithreading

• A const pointer cannot change the memory address it points to, but can change the value at that address

• A pointer to const can change the memory address it points to, but cannot change the value at that address

• In multithreading, const pointers can be used to ensure thread safety by preventing multiple threads from modifying the same memory location

Sorting algorithm time complexity, types of trees and linked list, and implementing linked list in C++.

• Sorting algorithms have different time complexities, such as O(n^2) for bubble sort and O(n log n) for quicksort.

• Trees include binary, AVL, and red-black trees, among others.

• Linked lists are a data structure where each element points to the next one, such as singly and doubly linked lists.

• In C++, linked lists can be implemented using pointers and dynamic memory allocation.

Class is a blueprint for creating objects. Objects are instances of a class with their own set of properties and methods.

• Classes define the properties and methods that objects will have

• Objects are created from a class using the 'new' keyword

• Objects can interact with each other through their methods and properties

• Example: class Car { int speed; void accelerate(); }; Car myCar; myCar.accelerate();

• Example: class Person { string name; int age; void sayHello(); }; Person john; joh...read more

Join is used to wait for a thread to finish execution before continuing with the main thread.

• Join ensures that all the threads finish their execution before the main thread exits.

• It is used to avoid race conditions and deadlocks.

• Join can be used with detach to ensure that the thread is not left running in the background.

• Example: Joining a thread that performs a time-consuming task before continuing with the main thread.

• Example: Joining multiple threads to ensure that all the ...read more

Creating threads using POSIX library and passing parameters.

• POSIX library provides functions for creating and managing threads in C++.

• To create a thread, we use the pthread_create() function.

• The function takes four parameters: a pointer to a pthread_t object, thread attributes, a function pointer to the thread function, and a void pointer to the thread function's argument.

• Example: pthread_t thread; pthread_create(&thread, NULL, myThreadFunction, (void*)myArgument);

Singleton class ensures only one instance of a class is created and provides a global point of access to it.

• Ensures only one instance of a class is created

• Provides a global point of access to the instance

• Useful for managing global resources or settings

Functions, if blocks, loops, and case structures have a wide scope of logic in C development.

• Functions allow for modular and reusable code.

• If blocks provide conditional logic.

• Loops allow for repetitive tasks.

• Case structures provide a way to handle multiple conditions.

• All of these structures can be combined to create complex logic.

• Proper use of these structures can improve code readability and maintainability.

A template-based stack implementation in C++ that can handle any data type.

• Use templates to define a generic Stack class: `template <typename T>`.

• Implement basic stack operations: push, pop, and top.

• Use a dynamic array (or linked list) to store stack elements.

• Example: `Stack<int> intStack; intStack.push(5);`

• Example: `Stack<std::string> stringStack; stringStack.push("Hello");`

Runtime polymorphism in C++ is achieved through virtual functions, vptr (virtual pointer), and vtable (virtual table).

• Runtime polymorphism allows objects of different classes to be treated as objects of a common superclass.

• Virtual functions are declared in a base class and overridden in derived classes to achieve polymorphism.

• vptr is a pointer that points to the vtable of an object, allowing dynamic binding of virtual functions at runtime.

• vtable is a table of function pointer...read more

Object-oriented programming in C++ is a programming paradigm that uses objects to represent real-world entities.

• Encapsulation, inheritance, and polymorphism are the three main pillars of OOP in C++.

• Classes and objects are the building blocks of OOP in C++.

• OOP in C++ allows for code reusability, modularity, and easier maintenance.

• Example: A car can be represented as an object in C++ with properties like make, model, and color, and methods like start and stop.

• Example: Inheritan...read more

To improve code quality in C++ code, focus on readability, maintainability, performance, and adherence to best practices.

• Use meaningful variable and function names to improve readability.

• Break down complex functions into smaller, more manageable functions.

• Follow coding standards and best practices such as using const-correctness, avoiding magic numbers, and using appropriate data structures.

• Use comments and documentation to explain the purpose and functionality of the code.

• Pe...read more

A zombie process is a process that has completed execution but still has an entry in the process table.

• Zombie processes occur when a child process finishes execution before the parent process can collect its exit status.

• Zombie processes consume system resources and should be cleaned up by the parent process using wait() or waitpid() system calls.

• Zombie processes can be identified using tools like ps command in Unix/Linux systems.

• Example: When a parent process forks a child pr...read more

Multithreading involves multiple threads reading and writing shared data, requiring synchronization to avoid data races.

• Use mutexes to protect shared resources: std::mutex mtx; mtx.lock(); // critical section; mtx.unlock();

• Consider read-write locks (std::shared_mutex) for scenarios with multiple readers and few writers.

• Atomic variables (std::atomic) can be used for simple data types to avoid locking overhead.

• Condition variables (std::condition_variable) can synchronize thread...read more

dynamic_cast is a C++ operator used for safe downcasting of pointers and references in polymorphic classes.

• dynamic_cast is used to safely downcast a pointer or reference from a base class to a derived class.

• It can fail if the object being casted is not of the target type, in which case it returns a null pointer for pointers or throws a std::bad_cast exception for references.

• Dynamic_cast can only be used with pointers or references to polymorphic classes (classes that have at ...read more

Arrays in C are used to store multiple values of the same data type. Public and private variables are used for data encapsulation.

• Arrays can be declared using square brackets, e.g. int arr[5];

• Public variables can be accessed and modified by any part of the program, while private variables can only be accessed and modified within the same class or function.

• Arrays of strings can be declared using char arr[5][10]; where 5 is the number of strings and 10 is the maximum length of ...read more

A class for debit, credit and balance check functionalities

• Create a class with member variables for balance

• Add member functions for debit, credit and balance check

• Ensure proper validation and error handling

• Consider using exception handling for errors

Memory management involves allocating and deallocating memory for variables and objects.

• Variables can be allocated on the stack or heap depending on their scope and lifetime.

• Objects can be created using new operator and must be deleted using delete operator to avoid memory leaks.

• Smart pointers like unique_ptr and shared_ptr can be used to manage object memory automatically.

• Memory leaks can be avoided by properly managing object ownership and using RAII.

• Memory fragmentation ca...read more

A function pointer is a variable that stores the address of a function. Its signature includes the return type and parameter types of the function.

• Function pointers allow for dynamic function calls based on the stored address

• Syntax: return_type (*pointer_name)(parameter_types)

• Example: void (*funcPtr)(int) = &someFunction;