Must-Know [LATEST] Coding Interview Questions and Answers

Must-Know [LATEST] Coding Interview Questions and Answers

Last updated on 18th Nov 2021, Blog, Interview Questions

About author

Niyati Joshi (Java Software Engineer )

Niyati Joshi is a Java Software Engineer with 5+ years of experience as a Java Specialist. She is an expert in JavaScript, HTML/CSS, SQL, Python, Looker ML, DBT, PDT Looker, Looker API, Lightdash, Snowsight, and CARTO's SQL API.

(5.0) | 19178 Ratings 4204

Coding interviews are a fundamental aspect of technical assessments, especially in the realm of software development and engineering. These interviews are designed to evaluate a candidate’s problem-solving skills, algorithmic proficiency, and coding ability under time constraints. Typically conducted by tech companies during the hiring process, coding interviews assess a candidate’s capability to translate algorithmic concepts into functional code. Candidates are presented with algorithmic challenges or coding problems that require efficient solutions, often emphasizing concepts related to data structures, algorithms, and software design patterns.

1. Describe data structures.


A data structure is a type of storage format that specifies how information is manipulated, stored, and arranged. Trees, graphs, and arrays are a few common types of data structures is a specific type of format used to process, retrieve, store, and organize data. 

2. Describe an array.


An array is sometimes referred to as a collection of objects stored at contiguous memory locations. Arrays are derived data types in the C programming language that are capable of storing primitive data types, including char, double, float, and int. It arranges data to make it simple to sort or search for a linked set of values.

3. Define Linked lists.


A linked list is a linear data structure similar to an array, except the members aren’t always stored in a contiguous fashion. Each node points in the direction of the next node, creating a structure like a chain. Each link carries a link field called next and one or more data fields. Every link is connected to the link after it using the following URL. The last link indicates the end of the list by carrying a null link.

4. What is LIFO?


  • The acronym LIFO stands for Last In First Out.
  • It’s a method for getting to, saving, and using data.
  • First, it retrieves the data that was last stored.
  • The calculation of the cost of products sold uses this approach for cost flow assumption purposes. 

5. Describe a stack.


A linear data structure that executes operations in the Last In, First Out (LIFO) order is referred to as a stack. Elements in a stack can only be accessed, with the element at the top being the last to be visited. is a logical idea made up of a group of related elements. The phrase is frequently used in computer programming and memory organization. Last in, first out (LIFO) is a frequently used kind of data abstraction that consists of two main operations: push and pop.

6. How Do Binary Trees Work?


  • A binary tree is a linked list structure extension in which there are no more than two children per node. 
  • There are always two nodes in a binary tree: a left node and a right node.
  • A binary tree is a non-linear data structure that resembles a tree and can have up to two children for every parent.
  • In a binary tree, each node has the data element and a left and right reference. The root node is the node at the top of a tree’s hierarchy. The parent nodes are those that contain additional sub-nodes.

7. Describe the contents of a binary search tree.


  • Data is stored in a binary search tree so that it may be efficiently accessed. 
  • Nodes whose keys are smaller than their key value are found in the left sub-tree.
  • Nodes with keys larger than or equal to the node’s key value are found in the right subtree.
Binary Search Tree

8. What is the foundation of programming stacks? FIFO?


First In, First Out, or FIFO for short, is an asset-management and valuation method in which assets produced or acquired first are sold, used, or disposed of first. It is a means of accessing, storing, and retrieving data. The data that was stored first is extracted first. 

9. What’s in a linear Data Structure?


A linear data structure that executes operations in FIFO order is referred to as a queue. is open at both ends, and operations are carried out in the First In, First Out (FIFO) sequence; in contrast to a stack, the least recently added elements are eliminated first in a queue. A list that has all additions made at one end and all deletions made at the other is what we refer to as a queue.

10. Explain Recursion.


A function that calls itself in response to a terminating condition is known as a recursive function. The following two questions in the coding interview will test your understanding of OOPs.

This is a potentially very effective tool for algorithm development. Recursion originates in mathematics, where there are numerous instances of expressions that are expressed in terms of one another. The definition of the Fibonacci sequence, for instance, is F(i) = F(i-1) + F(i-2).

11. What is the idea behind OOPs?


The acronym OOPs refers to the Object-oriented Programming System, a paradigm that offers ideas like inheritance, classes, and objects. OOPs expand the use of pre-existing classes and allow for code reuse. The presence of classes and objects in OOPs makes code easier to maintain than it would be in a restructuring scenario. It also aids in data concealment, maintaining the data and information protected from exposure or leakage.

12. What distinguishes overriding from overloading?


  Feature Method Overloading Method Overriding
Definition Multiple methods of the same class with the same name but different parameters (either different number or type) A subclass method has the same signature (name, return type, and parameters) as a method in its superclass.
Type Occurs within the same class Involves a superclass-subclass relationship
Visibility Can have different access modifiers Must have the same or broader visibility in the subclass (e.g., cannot reduce visibility from public to private)
Return Type May or may not have the same return type Must have the same return type
Example `java public void display(int a) { /* code */ } public void display(double b) { /* code */ }` `java class Animal { void sound() { /* code */ } } class Dog extends Animal { void sound() { /* specific code for Dog’s sound */ } }`

13. What does the phrase “OOPs” mean?


Object-oriented programming is referred to as OOP. The programming paradigm is defined using objects. are thought of as actual examples of classes and other entities with certain traits and actions.

14. Why are OOPs necessary?


Even if consumers are unaware of the real implementation, OOPs make software easier for them to understand. The readability, understandability, and maintainability of the code all increase significantly when using OOPs. make it simple to write and manage even very large software.

15. What ideas are presented in OOPs?


  • Object: A physical thing with a specific state and way of acting. It can be described as a class instance.
  • Class: A logical entity that establishes the template from which an instantiated or produced object can be derived.
  • Inheritance: The idea that an object inherits all of the characteristics and actions of its parent object. It allows for the reuse of code.
  • Polymorphism: An idea that permits multiple approaches to be taken when completing a task. Polymorphism in Java is accomplished through the usage of overloading and overriding methods.

16. What distinguishing qualities do OOPs have?


The four essential components of object-oriented programming, or OOPs, are listed below. Be cautious not to overlook any of them:

  • Succession
  •  Data Abstraction; 
  • Polymorphism; 
  • Encapsulation

17. Why are OOPs so well-liked?


The OOP programming paradigm is regarded as superior to other programming styles. It not only makes developing complex code easier, but it also makes handling and maintaining them easier for users. Furthermore, the primary OOP pillars of Data Abstraction, Encapsulation, Inheritance, and Polymorphism facilitate complicated case-solving for programmers. 

18. Describe a class.


A class can be thought of as a blueprint or template that has some values, referred to as member data or members, and a collection of rules, referred to as behaviors or functions. Thus, the data and functions defined in the class are automatically taken when an object is formed. As a result, the class functions essentially as an object’s blueprint or template. Additionally, an object can be created based on a class in any number of ways.

19. Describe an object.


An object is a class instance, which includes instances of the elements and behaviors specified in the class model. Classes are merely the blueprint for objects, but objects are actual entities with which users interact in the real world. Thus, the objects have some distinguishing characteristics and take up space.

    Subscribe For Free Demo


    20. What is the difference between runtime and compile time polymorphism?


    Compile-time polymorphism in English enables the usage of numerous methods with the same name but different return types and signatures. Runtime polymorphism can be illustrated via method overriding. Although runtime polymorphism is linked to many classes, it enables us to employ the same technique under various signature names.

    21. What are the benefits of utilizing OOPs?


    • When it comes to solving really complex problems, OOPs are quite useful.
    • Object-oriented programming makes it simple to design, manage, and maintain extremely complex programs.
    • Encourage code reuse, OOPs • OOPs also help conceal extraneous details with the aid of data abstraction, therefore decreasing redundancy.
    • In contrast to the top-down method used by the structural programming paradigm, OOPs are built on a bottom-up approach, and polymorphism provides a great deal of flexibility.

    22. How is polymorphism supported in C++?


    • Programming in C++ is object-oriented, and polymorphism is supported:
    • Compile Time Polymorphism: Templates, function overloading, and default parameters are some of the characteristics that C++ uses to allow compile-time polymorphism.
    • Runtime Polymorphism: Virtual functions and other features in C++ enable Runtime Polymorphism. Virtual functions are resolved at runtime and take on the Structure of the functions depending on the type of Object in reference.

    23. Which are the most popular languages for object-oriented programming?


    Object-oriented programming languages are those that employ and adhere to the OOPs, or object-oriented programming paradigm. Several prominent languages for object-oriented programming are Java, C++, Javascript, Python, and PHP.

    24. What does structured programming entail?


    Programming in Structure The term “structured programming” describes a programming approach that has a fully organized control flow. Here, “structure” refers to a block—such as “if/then/else,” “while and for,” block structures, and subroutines—that has a set of rules and a clear control flow. Structured programming is a feature of almost every programming paradigm, including the OOPs model.

    25. Define encapsulation.


     Encapsulation is the process of placing all necessary components into a capsule and delivering the capsule to the user. Encapsulation, then, is the process of connecting a program’s procedures and data members to accomplish a particular task while hiding unneeded details.

    • Data hiding: Encapsulation is the technique of preventing access to any member of an entity in order to conceal undesired information.
    • Data binding: The process of joining the methods and data members as a class or as a whole is known as encapsulation.

    26. Describe polymorphism.


    The two words “poly,” which means “many,” and “morph,” which means “shapes,” combine to form the word polymorphism. Therefore, something with multiple shapes is referred to as polymorphism.

    The process by which some code, data, procedure, or Object behaves differently under various conditions or settings is referred to as polymorphism in OOPs. Within OOP languages, there are two sorts of polymorphisms: compile-time and runtime.

    27. What Does “Inheritance” Mean?


    “Receiving some quality or behavior from a parent to an offspring” is the definition of “inheritance.” The process of creating an object or class (referred to as a child) from the definition of another object or class (referred to as a parent) is known as inheritance in object-oriented programming. 

    28. Describe Abstraction.


    In Java, Abstraction means revealing to the user only the information that is absolutely required while concealing the implementation specifics of a method. It offers the capacity to reduce complexity and ignore unimportant information in order to simplify complex systems. Java comes with a lot of built-in abstractions and only a few tools for making our own.

    29. Aside from OOPs, what other programming paradigms exist?


    Programming paradigms are the categories used to group programming languages according to their characteristics. Two primary categories of programming paradigms exist:

    • The paradigm of imperative programming: This paradigm describes control flow as statements that alter a program state and concentrate on HOW to carry out program logic.
    • The paradigm of declarative programming: Rather than focusing on a precise control flow, declarative programming specifies WHAT to execute and defines program logic.

    30. What kinds of inheritance are there?


    The many kinds of inheritance consist of • One inheritance • Multiple inheritances:

    • Hierarchical inheritance; 
    • multi-level inheritance
    • Inheritance hybrid

    31. What is the memory use of a class?


    Classes do not use memory. They only serve as a blueprint from which things are made. Currently, objects require memory when they are created since they really initialize the class members and methods. Classes do not use memory. When we define a class, we explicitly state its essence and exact Structure. Classes represent the set of attributes or functions shared by all of the objects in that class.

    32. How Is creating objects from classes always required?


     An item is if the underlying class has non-static methods, they must be constructed. However, objects don’t have to be created if the class contains static methods. Objects from classes do not necessarily need to be created. However, in object-oriented programming, classes are usually used to generate objects because they specify the characteristics and actions of the objects, and accessing the class’s methods and attributes is only available after an object has been formed.

    33. Describe what a constructor is.


    Special methods with the same name as the class are called constructors. The unique function of the constructors is to initialize the objects. Assume, for instance, that there is a class named “MyClass.” To instantiate this class, you pass the following syntax: MyClass myClassObject = new MyClass(). The constructor of this class is the method that is called after the “new” keyword, in this case, MyClass(). This will assist in assigning the member data and methods to the myClassObject Object during the instantiation process.

    34. What kinds of C++ constructors are there?


    The constructors are often categorized as follows:

    Constructor by default: The constructor that doesn’t accept arguments is the default constructor. It is without parameters.

    • class ABC {
    • int x; // Member variable
    • // Constructor
    • ABC() {
    • x = 0;
    • }
    • }

    Parameterized constructor: A constructor is referred to as parameterized if it takes one or more arguments.

    • class ABC {
    • int x; // Member variable
    • // Constructor with a parameter
    • ABC(int y) {
    • x = y;
    • }
    • }

    Copy constructor: A member function that uses another object of the same class to initialize an object is called a copy constructor.

    • class ABC {
    • int x; // Member variable
    • // Parameterized constructor
    • ABC(int y) {
    • x = y;
    • }
    • // Copy constructor
    • ABC(ABC abc) {
    • x = abc.x;
    • }
    • }

    35. What is a constructor of copies?


    One kind of constructor is the copy constructor, which is used to duplicate an object to another. It basically means that if two objects are of the same class, a copy constructor will replicate an object’s values into another object. A member function that initializes an object using another object is called a copy constructor.

    36. Explain what is a destructor?


    Destructors are special procedures as well, in contrast to constructors, which initialize objects and designate space for them. However, destructors release the memory and resources that an object has been using. The destructor is invoked immediately before the Object’s life expires or it goes out of scope. This is done to make sure that all of the resources set aside for the purpose are finally utilized and released for use by other parties.

    Course Curriculum

    Develop Your Skills with JavaScript Certification Training

    Weekday / Weekend BatchesSee Batch Details

    37. What are Structure and class the same?


    A collection of variables with the same name but different data types is called a structure. In C++, a class is a solitary structure that holds a group of associated variables and functions. A structure can be declared using the struct keyword.

    38. Give an example to illustrate inheritance.


    One method to depict actual links between the two is through inheritance. Here are some examples: a car, a bus, and a bike are all classified as vehicles, which is a more general term. As a result, they have inherited the characteristics of class vehicles, meaning that they are all utilized for transit.

    39. What steps are involved in data abstraction?


    Abstract classes or abstract methods are used to help with data abstraction. Abstraction of data using abstract interfaces and classes. Partial or total abstraction can be attained with abstract classes since they have methods with implementations that lead to partial abstraction.

    40. What is an abstract class?


    A unique class with abstract methods is called an abstract class. The fact that an abstract class only has stated, not implemented, abstract methods is significant. Therefore, a subclass must create and implement its abstract methods when it inherits the abstract class and needs to use them.

    41. What distinguishes an interface from an abstract class?


    • Both interfaces and abstract classes have unique class types that don’t include the methods’ implementations—just the declarations. However, the interface differs greatly from an abstract class.
    • The primary distinction between the two is that a subclass must specify every method and supply the implementation for an interface when it is implemented, In object-oriented programming.
    • On the other hand, unless the subclass is explicitly stated as abstract when a subclass inherits from an abstract class that has abstract methods, the subclass is usually expected to provide concrete implementations for every one of those abstract methods in the abstract class.
    • Furthermore, both non-abstract and abstract methods may be found in an abstract class.

    42. How can a string be reversed in Java?


    • State a string.
    • Extract the string’s length.
    • Cycle over the string’s characters.
    • In the new string, add the characters in reverse order.
    • public class ReverseStringExample {
    • public static void main(String[] args) {
    • // The original string
    • String str = “hello”;
    • // Variable to store the reversed string
    • String reverse = “”;
    • // Length of the string
    • int length = str.length();
    • // Loop to reverse the string
    • for (int i = length – 1; i >= 0; i–) {
    • reverse = reverse + str.charAt(i);
    • }
    • // Print the reversed string
    • System.out.println(reverse);
    • }
    • }

    43. Describe a subclass.


    The subclass belongs to the inheritance class. An entity that derives from another class is a subclass. Another name for it is the kid class. A subclass, also known as a derived class, extended class, or kid class, is a class that is derived from another class. A superclass, sometimes known as a base class or a superclass, is the class from which the subclass is derived.

    44. What describes a superclass?


    Inheritance also includes superclass. A superclass is an entity that permits inheritance from child classes or subclasses. A superclass, often known as a base class or parent class, is the class from which the subclass is derived. Every class, with the exception of Object, which has no superclass, has a single direct superclass (single inheritance).

    45. What is An interface?


    Interfaces are ideas and instruments that help Technology developers utilize interfaces as sites of interaction between software and physical components. Interfaces are concepts and techniques. They enable independent operation while facilitating communication between all system components using an input-output system and elaborate protocols.

    46. What does static polymorphism mean?


    The term “compile time polymorphism” is frequently used to refer to static polymorphism. The ability to associate an object with a function or operator based on values found during compilation is known as static polymorphism. Operator overloading or method overloading can be used to achieve static or compile time polymorphism.

    47. How Do Double-Linked Lists Work?


    • Double-linked lists fall within a specific category of linked lists where traversing between the data components is possible in both directions. 
    • Every node has two links: one connects to the node directly next to it and the other to the node that came before it. This is made possible by their presence.

    48. Describe a graph.


    One particular kind of data is a graph.

    Graph is a specific kind of data structure made up of an ordered pair set. In a graph, ordered pairs—also referred to as edges or arcs—are most frequently. It utilized for to link nodes that store and retrieve data.

    49. Distinguish between a nonlinear and a linear data structure.


    • A data structure that is a linear data structure that is not linear
    • Each data element in this structure can connect to more than two adjacent data elements.
    • The data elements in this structure are adjacent to one another. Stacks, queues, arrays, and linked lists are a few types of linear data structures. Nonlinear data structures include trees and graphs.

    50. Describe a Déque.


    • A deque is a bifurcated double-ended queue called a deque. Elements can be added or withdrawn from either end of this construction.
    • Deque is a linear data structure in which both ends are used for insertion and deletion.
    • It is possible to think of deque as a more generalized form of a queue. Even if a deque does not adhere to the FIFO rule, insertions and deletions can occur on either end.

    51. How can one ascertain whether a given string is a palindrome?


    When a string remains unchanged when its character order is reversed, it is called a palindrome. The original string can be reversed first, and then the equality of the reversed string and the original string can be verified.

    • public class PalindromeExample {
    • public static void main(String[] args) {
    • // Original string
    • String str = “hello”;
    • // Reversing the string
    • String reverse = “”;
    • int length = str.length();
    • for (int i = length – 1; i >= 0; i–) {
    • reverse = reverse + str.charAt(i);
    • for (int i = length – 1; i >= 0; i–) {
    • reverse = reverse + str.charAt(i);
    • }
    • // Checking if the string is a palindrome
    • if (str.equals(reverse)) {
    • System.out.println(“Palindrome”);
    • } else {
    • System.out.println(“Not a Palindrome”);
    • }
    • }
    • }

    52. What is the meaning of access specifiers, and what do they do?


    As the name implies, access specifiers are a unique class of keywords that are employed to regulate or define how entities, such as classes, methods, etc., are accessible. “Private,” “public,” and other terms like that are examples of access modifiers or access specifiers. Additionally, these access specifiers are essential to achieve encapsulation, which is one of the main characteristics of OOPs.

    53. What qualifies as an outlier?


    A specific event that is triggered during program execution at runtime and stops the program’s execution might be regarded as an exception. The primary cause of the Exception is a place in the program where the user wishes to perform an action for which there is no program specification, such as entering unwanted data.

    54. What is meant by handling exceptions?


    The program can handle exceptions in advance and keep the execution from halting; the process of determining the undesired states to which the program may come and defining the desired consequences of those situations is known as exception handling. The most popular technique for managing exceptions in programs is try-catch.

    55. In the domain of OOPs, what does “garbage collection” mean?


    The core concept of object-oriented programming is entities, such as objects. Every object uses memory. Hence, there can be more than one class object. Thus, improper handling of these objects and their memories could result in certain memory-related mistakes and system failure.

    This program’s memory management approach is known as garbage collection. Garbage collection removes items that are no longer needed, freeing up unneeded memory.

    56. How Is it possible to run a Java program without using the OOPs concept?


    Java applications can only be implemented with object-oriented programming models, or OOPs, as they are built upon this notion. Conversely, though, C++ does not require OOPs to be implemented because it offers a C-like structural programming model.

    57. What is the best sorting algorithm?


    • There are numerous varieties of sorting algorithms, including radix, bubble, fast, balloon, merge, and more.
    • Since each algorithm is optimized for a particular kind of data structure, it cannot be said to be the fastest or best method overall.

    58. How does the declaration of a variable impact memory?


    • The type of data being stored in that variable determines how much memory needs to be set aside or allocated. 
    • When a variable is designated as “integer type,” for instance, 32 bits of memory storage are set aside specifically for it.

    59. In an integer array, how may the matching elements be obtained?


    • Make an array declaration.
    • To compare the numbers with other numbers in the array, nest a few loops.
    • If matching components are discovered, print them.

    The following code is generated:

    • for (int m = 0; m < a.length; m++):
    • for (int n = m + 1; n < a.length; n++)
    • If (a[m] == a[n]), {
    • } } System.out.print(a[m]);

    60. How can one determine how many vowels and consonants are in a string?


    • Make a loop around the string.
    • Use the if condition to increase the vowel variable by one each time the character is determined to be a vowel. In the event that is not, raise the consonant variable.
    • Print the values for the count of vowels and consonants.

    The following code is executed:

    • for (int k = 0; k < str.length(); k++)
    • char c = str.charAt(k);
    • if (c == ‘a’ || c == ‘e’ || c == ‘i’ || c == ‘o’ || c == ‘u’)
    • Vowels ++;
    • Otherwise,
    • Consonants++;
    • }
    • “Vowel count is ” + vowels;
    • “Consonant count is: ” + consonants”;

    61. What does dynamic polymorphism mean?


    Dynamic polymorphism, often known as runtime polymorphism, is the kind of polymorphism used in OOPs that determines how a function is actually implemented throughout the execution or runtime. Method overriding can be used to achieve runtime or dynamic polymorphism.

    62. What distinguishes an array from a stack?


    The Last In, First Out (LIFO) pattern is adhered to by Stack. This implies that data access must always occur in a specific order, with the most recent data to be stored being the first to be retrieved. However, arrays do not adhere to rather than being accessible or called in a certain order, but rather by referring to the array’s indexed element.

    63. What are data structures that are dynamic?


    One characteristic of dynamic data structures is that they grow and shrink while a program executes. Because it adapts according to the size of the data to be altered, it offers a particularly versatile technique of data manipulation. Shape is flexible enough to adapt to changing data requirements during runtime. Trees, stacks, queues, and linked lists are a few instances of dynamic data structures.

    64. How would the insertion sort algorithm be put into practice?


    It is assumed that the array’s initial element is sorted. The key contains a separate storage for the second element. This arranges the initial two components. Subsequently, you can compare the third element with those on its left. This procedure will continue until the array is sorted.

    65. How can I determine whether the two strings provided are anagrams or not?


    If two strings have the same set of characters but in a different order, they are anagrams.

    • Declare a boolean variable that indicates whether or not the two strings at the end are anagrams.
    • To begin with, make sure that both strings have the same length; otherwise, they cannot be anagrams.
    • Convert each before sorting them; convert the strings to character arrays.
    • Verify the equality of the sorted arrays. Print anagrams if they are equal; otherwise, do not a boolean, is false;

    Course Curriculum

    Get JOB Oriented JavaScript Training for Beginners By MNC Experts

    • Instructor-led Sessions
    • Real-life Case Studies
    • Assignments
    Explore Curriculum

    66. How may an array be reversed?


    • Continue until the array is half its length.
    • Change the numbers at the beginning and finish that correspond to the indexes.

    for (int t = 0; t < a.length / 2; t++) { int tmp = a[t]; a[t] = a[a.length – t – 1]; a[a.length – t- 1] = tmp; } 

    67. How would the bubble sort algorithm be put into practice?


    • Make an array declaration.
    • To compare the numbers in the array, nest a few loops.
    • To sort the array in ascending order, swap out

    if the components are discovered in a different order.

    for (int k = 0; k < a.length; k++)


     int[] a = { 1, 2, 7, 6, 4, 9, 12}

     { a= 0;

     l < a.length – l – 1; l++) 

    If (a[l] > a[l + 1]), 

    then { { int t = a[l];

     a[l] = a[l + 1]; a[l + 1] = t; } }

    68. To swap two numbers without utilizing a third variable, how do you do it?


    • Declare and initialize two variables with respective values.
    • Compute the total of the two numbers, b.
    • Next, swap a by subtracting the total (b) from a.
    • Finally, deduct an amount.

    69. How do you use recursion to print a Fibonacci series?


    • The following integer sequence contains the Fibonacci numbers: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144,…
    • The Fibonacci recursive function’s mathematical formula allows us to compute them.
    • public static The function int Fibonacci(int n) returns n;
    • returns fibonacci(n – 1) + fibonacci(n – 2);
    • if (n <= 1), then n;
    • else, n;
    • public static void main(String args[]) { < System.out.println(Fibonacci(n));
    • int n = 10;
    • }

    70. How can the factorial of an integer be calculated?


    A multiplicative function is called a factorial. Each number that comes after it. Using 5! as an example, 5*4*3*2*1=120.

    • The public static long factorial(long n) function multiplies the numbers until it reaches 1.
    • If (n == 1),
    • it returns 1;
    • otherwise,
    • it returns (n * factorial(n – 1));
    • }

    71. How Can a Linked List Be Reversed?


    • Make a list that is linked.
    • Include items that are linked in the list.
    • Use the linked list and the descending iterator method.

    This causes the linked list’s elemental order to be reversed.

    • LinkedList<`Integer`>
    • System.out.println(ll);
    • LinkedList<`Integer`>; ll = new LinkedList<``>();
    • ll.add(1),
    • ll.add(2),
    • ll.add(3)
    • ll1 = new LinkedList<>();
    • ll.println(ll1);
    • System.out.descendingIterator().
    • forEachRemaining(ll::add);

    72. How might Binary Search be put into practice?


    • Until the element is found, binary search divides the array in half at each iteration step.
    • Because it computes the mid-number by comparing the values of neighboring members, it operates on sorted arrays.
    • The element is absent from the list if, at any point, the low value exceeds the high value.

    73. How can all instances of a specific character be eliminated from the input string?


    Can substitute any other character for a character by using the built-in string method “replace.”, such as white spaces and symbols.

    String str1 = “Australia”; 

    str1 = str1.replace(“a”, “”);


    74. How to Use a program to highlight inheritance?


    By extending the parent class Animal, the class Cat inherits the property color from the Animal class.

    In this manner, if a class Cat wants to inherit the properties of its parent classes, it can have more of them.

    • class Cat extends Animal;
    • class Animal { String color;
    • }
    • void meow()
    • {
    • System.out.println(“Meow”);
    • } }

    75. In an array, how would you determine the second-largest number?


    • Go over the array in a loop.
    • If i is greater than the highest value, record i in the highest variable and the highest value in the second-highest variable.

    private static int locateSecondHighest(int[] array)


    int highest = Integer.MIN_VALUE; 

    int secondHighest = Integer.MIN_VALUE; 

    for (int i: array) { if (i > highest)


    76. How can one determine whether a particular number is prime?


    • To check for each condition independently, use if statements:
    • A number cannot be prime if it is 0 or 1.
    • A number is prime if it is two.
    • A number is prime if it cannot be divided into any other number.

    77. How can the components of an array be added together?


    To traverse through the array and continue adding elements, use a for loop. Within that array.

    for (int i: array) sum += i; 

    int[] array = { 1, 2, 3, 4, 5 };

     int sum = 0;


    78. Can a program help explain overloading and overriding?


    Overloading: Overloaded methods are those in a class that have two or more methods with the same name.

    class Noo { void print(String s) { System.out.println(s); }

        print(void) while (count > 0) print(String s, int count) { System.out.println(s); count–; Counter.out.println(s);

    Overriding: When a method from the superclass is used in the child class as well.

    class Base { void printName() { System.out.println(“Base Class”); } } case of overriding.

    class Youngster stretches out Base @Override void printName() { System.out.println(“Child Class”); } }

    79. How an Array and an Object Differ.


    An array generates a list of data and stores it in a single variable, but an object represents an entity with properties. While we can access, change, and remove items from objects using brackets and dots, we can access and modify items in arrays using a range of built-in methods and zero-based indexing. It is possible to repeatedly iterate over array items and object properties by utilizing different loops (such as for, for…in, for…of, and forEach()).

    80. Define Search an array for the Target Element.


    The array’s size, denoted by the number n, will be the first thing you receive. Subsequently, you will receive n more inputs, one for each array index. After that, you’ll be given a target and required to determine which index in the array target contains the target. If the target is not in the array, print -1.

    81. When is an ArrayStoreException going to occur?


    A runtime error known as Array StoreException is raised, for instance, when you declare a String array and then attempt to add integer components to it.  length variable yields the length of an array or a quantity of items that make up an array and it’s length cannot be altered after initialization. Hence, the length variable can be used to determine an array’s length directly.

    82. What does a Java Jagged Array mean?


    Multidimensional arrays with varying member array sizes are called jagged arrays. For illustration, let’s create a 2D array with three elements in the first array and four elements in the second. Here’s an illustration of the idea behind jagged arrays.

    83. What is the distinction in Java between length and length ()?


    The String class makes use of the Java length attribute. The array class is utilized with the Java length function. The Java length property returns the size of an array. The Java length method yields the text string’s character count.


    • public static void main(String args[])
    • { String str = “Hello, this is InterviewBit”;
    • System.out.println(“This is the length of the string using the length() method: ” + str.length()); }
    • The output of the length() method is 23
    JavaScript Sample Resumes! Download & Edit, Get Noticed by Top Employers! Download

    84. When we discuss arrays, what do you mean by “subscript” and “dimension”?


    • Memory allocation: Memory is allocated at runtime for linked lists, but at compile time for arrays. However, runtime memory allocation also occurs in a dynamically allocated array.
    • Memory efficiency: Because of its node structure, which stores data on each node, the linked list requires more memory to hold the same amount of entries. Together with the data, a pointer to the following node.
    • Execution time: While entries in an array can be accessed directly by using their index, elements in a linked list require traversing all of the preceding elements in order to reach any element. 

    85. How may two sorted arrays be combined into a single sorted array?


    Method 1:

    • The elements from the first array can then be copied into the new one. After that, you can use insertion to iterate through the second array and add elements to the new one.
    • This technique requires O(n1 * n2) time complexity and O(n1 + n2) extra space.

    Method 2 Using Heap:

    • Apply min-heap to the second array: Compare the current element to the top of the generated min_heap as you work through the first array.
    • In this instance, swap the current element of the first array with the heap root and the root of the min_heap if the current element in the first array is greater than the heap top.

    86. Why is the fetching complexity from an array O(1)?


    Objects are kept in a continuous memory region in an array. Thus, if you are aware of the address together with the data, a pointer to the following node. However, when there is a lot of fluctuation in the size of the data items, or when there is ambiguity about size, linked lists may require less memory overall than arrays.

    address(a[i]) is equal to i*size(object) plus address(a[0]).

    Since this term is independent of n, retrieving data from an array has an O(1) temporal complexity.

    87. How may a certain element be eliminated from an array?


    The indexOf() function returns the index of the element in the array that matches the value you pass in for the element you want to delete from your array. Next, remove the element at the returned index by using the splice() technique.

    88. How is the index of an array entry obtained?


    Both binary and linear searches can be used to determine an element’s index. A linear search is a function that iterates over each element in an array until it locates the exact match for the element that is sought. It returns the index once it locates the corresponding element. As a result, the linear search’s time complexity is O(n). You can use linear search on both sorted and unsorted arrays. The binary search’s temporal complexity is O(log n).

    89. How can an array with a range of 1 to 100 be used to find the missing integer?


    • Finding the sum of the missing integers can be used to find the sequences employing this feature: n (n + 1) / 2
    • Only if there are no duplicates in the array or if more than one integer is missing will this function function. You can sort an array to see if two elements are equivalent if it has duplicate elements.

    90. How many times does a character appear in a string?


    Every time you iterate through the string, look for that character to determine how many times it appears. If it is found, the count will be updated.

    • Int count is equal to 0;
    • Char search is equal to ‘a’;
    • I < length; i++) for (int i = 0) {
    • If (i == str.charAt(i)) {
    • count++;
    • ~
    • ~
    • Println.System.out.count;

    Are you looking training with Right Jobs?

    Contact Us

    Popular Courses

    Get Training Quote for Free