NEC National Sales Manager Interview Questions and Answers

Oops concepts in Java

• Encapsulation - hiding implementation details

• Inheritance - reusing code and creating parent-child relationships

• Polymorphism - multiple forms of a method or object

• Abstraction - creating abstract classes and interfaces

• Example: Encapsulation - using private variables and public methods

• Example: Inheritance - creating a subclass that inherits from a superclass

• Example: Polymorphism - using method overloa...read more

Altering columns in databases involves modifying the structure of a table by adding, deleting or modifying columns.

• Use ALTER TABLE statement to modify columns

• Add new columns using ADD COLUMN

• Delete columns using DROP COLUMN

• Modify columns using MODIFY COLUMN

• Changing column data type may result in data loss

Reversing a number in Java

• Convert the number to a string

• Use StringBuilder to reverse the string

• Convert the reversed string back to a number

To extract words from a line in Java, split the line using whitespace as delimiter.

• Use the split() method of String class

• Pass the whitespace regex as argument to split() method

• Iterate over the resulting array to get individual words

Count the number of '-' characters in a string and return 1 if it matches the given number, else return 0.

• Use a loop to iterate through each character in the string and count the number of '-' characters.

• Compare the count with the given number and return 1 if they match, else return 0.

• Handle edge cases such as empty string or negative number input.

Functions to create and delete nodes in a stack

• To create a stack, initialize a top pointer to null

• To push a node, create a new node and set its next to the current top, then set top to the new node

• To pop a node, set top to its next and return the popped node

• To delete the stack, pop all nodes until top is null

Code for producer-consumer problem using mutex

• Create a shared buffer with a fixed size

• Create a mutex to control access to the buffer

• Create a semaphore to keep track of the number of items in the buffer

• Create a producer thread that adds items to the buffer

• Create a consumer thread that removes items from the buffer

• Use mutex to lock the buffer while adding or removing items

• Use semaphore to signal when the buffer is full o

Mutex and Semaphore are synchronization primitives used in multi-threaded environments.

• Mutex is used to provide mutual exclusion to a shared resource, allowing only one thread to access it at a time.

• Semaphore is used to control access to a shared resource, allowing multiple threads to access it at a time.

• Mutex is binary, meaning it has only two states - locked and unlocked, while Semaphore can have multiple states.

• Mute...read more

Virtual addressing is a memory management technique that allows a process to use a range of memory addresses independent of physical memory.

• Virtual addresses are mapped to physical addresses by the memory management unit (MMU)

• Virtual addresses are allocated to a process during its execution

• Virtual addressing allows for efficient use of physical memory by allowing multiple processes to share the same physical memory

• Exam...read more

Deadlock is a situation where two or more processes are unable to proceed because they are waiting for each other to release resources.

• Prevent deadlock by using a proper resource allocation strategy

• Avoid holding onto resources for too long

• Use timeouts to release resources if they are not being used

• Implement a deadlock detection and recovery mechanism

• Avoid circular wait by imposing a total ordering of all resource types

Program to find the only duplicate in an array

• Create a hash set to store elements as they are encountered

• If an element is already in the hash set, it is a duplicate

• Return the duplicate element

Virtual memory is still needed even with large physical memory. Paging helps manage memory efficiently.

• Virtual memory allows for larger programs to run than physical memory can handle

• Paging helps manage memory efficiently by swapping out unused pages to disk

• Virtual memory also allows for memory protection and sharing between processes

• Examples of programs that require virtual memory include video editing software and la

To find the middle of a linked list, use two pointers - one moving at twice the speed of the other.

• Initialize two pointers - slow and fast

• Move the slow pointer one step at a time and the fast pointer two steps at a time

• When the fast pointer reaches the end of the list, the slow pointer will be at the middle

Time complexity of building a heap using linked list and arrays

• Building a heap using linked list takes O(nlogn) time complexity

• Building a heap using arrays takes O(n) time complexity

• Linked list implementation is slower than array implementation