Top 58 Coding Interview Questions & Answers 2024 [For Freshers & Experienced]

In coding interviews, a solid understanding of fundamental data structures like arrays, binary trees, hash tables, and linked lists is crucial. Combine that with a good grasp of essential algorithms and proficiency in programming languages such as Java, and you’ve got a recipe for success in tackling any technical challenge that comes your way. But theory can only take you so far; it’s practice that really hones your skills. By diving into coding problems headfirst and working through them tirelessly, you build the confidence and expertise needed to excel. 

 That’s why I always advocate for continuous learning and keeping up with the latest developments. You can check out free courses offered by upGrad in Management, Data Science, Machine Learning, Digital Marketing, and Technology.   

 With some dedication, practice, and the right resources, you’ll be all set to crush those coding interviews and show off your skills in the competitive world of 2024. In this article, I’ll walk you through 50+ of those questions & answers (both for freshers and experienced individuals) setting you up for success. Let’s get started! 

Read more to know coding questions for interview with answers in details.

Good foundations of data structures such as arrays, binary trees, hash tables, and linked lists are essential. You must be aware of essential algorithms, and methods. And have a good hold over programming languages such as Java, especially if you are applying for programming jobs. You can learn the answers to important coding questions for beginners, like “Explain OOP concepts” or “What is recursion?”, by exploring interview solutions. Practicing these extensively is highly recommended.
 

You can also check out our free courses offered by upGrad in Management, Data Science, Machine Learning, Digital Marketing, and Technology. 

Coding Interview Questions and Answers for Freshers

If you are a fresher who is trying to enter into a career in software development, then we have prepared a set of 25 programming questions for freshers to ace the first interview of your career.

1.What is Object-Oriented Programming (OOPS)? 

Object-Oriented Programming (OOPS) is a programming paradigm that revolves around the concept of objects. Objects encapsulate data and behaviors, and classes serve as blueprints for creating these objects. OOPS emphasizes key principles such as encapsulation, inheritance, polymorphism, and abstraction. Encapsulation involves bundling data and methods within a class, while inheritance enables a class to inherit properties from another class. Polymorphism allows objects of different types to be treated as a common type, promoting flexibility in code design. Abstraction simplifies complex systems by modeling classes based on essential properties and behaviors. 

2.What are Classes and Functions? 

In OOPS, classes are blueprint templates defining the structure and behavior of objects. They encapsulate data and methods to operate on that data. Functions within classes, known as methods, represent the behaviors of objects. Methods define the actions an object can perform, promoting code modularity and reusability. 

3.Explain Inheritance with respect to Object-Oriented Programming? 

Inheritance is a crucial Object-oriented programming System (OOPS) concept where a new class inherits properties and behaviors from an existing class. This promotes code reuse, as the new class (subclass) can leverage the attributes of the existing class (superclass). Inheritance establishes an “is-a” relationship between classes, enhancing the organization and extensibility of code. 

4.Explain Polymorphism with respect to Object-Oriented Programming? 

Polymorphism in OOPS allows objects of different types to be treated as objects of a common type. It is achieved through method overloading and overriding. Method overloading involves defining multiple methods with the same name but different parameters, while method overriding allows a subclass to provide a specific implementation of a method defined in its superclass. Polymorphism enhances code flexibility and adaptability. 

5.What are Public, Private, and Static Classes? 

Public Class: A class declared as public can be accessed from any other class. It provides visibility to classes across the entire program. 

 Private Class: In Java, classes cannot be explicitly declared as private. However, class members (fields and methods) can be private, restricting access to within the class itself. 

Static Class: In Java, classes cannot be declared as static. However, static nested classes exist, associated with the outer class rather than an instance. They are often used for grouping related functionality. 

6.What is Debugging? 

Debugging is the systematic process of identifying and resolving errors or bugs in a program. It involves using debugging tools, setting breakpoints, and stepping through code to analyze its behavior. Debugging helps programmers understand the flow of their code, identify logical or syntactical errors, and ensure the program operates as intended. It is an essential skill in software development for maintaining code quality and improving program reliability. 

7.Could you explain the Difference Between Integer and Float Data Types? 

The main difference lies in their representation and precision. Integer represents whole numbers without decimals, while Float represents floating-point numbers with decimals. Integers are precise but limited to whole values, while Float allows for decimal precision, making it suitable for a broader range of numeric values. 

// Declaration and Initialization of an Integer 

int myInteger = 10; 

// Declaration and Initialization of a Float 

float myFloat = 3.14f; // Note: "f" denotes that the literal is a float 

 8.What is String Data Type? 

String is a data type representing a sequence of characters. In Java, strings are objects of the String class. They are widely used for text manipulation and provide various methods for string operations, such as concatenation, substring extraction, and length retrieval. 

// Declaration and Initialization of a String 

String myString = "Hello, World!"; 

9.What is Array Data Type? 

An array is a data type that stores elements of the same type in contiguous memory locations. It allows efficient access using indices. Arrays provide a structured way to organize and manipulate collections of data, making them fundamental for many algorithms and data structures. 

// Declaration and Initialization of an Array 

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

10.Explain Boolean Data Type. 

Boolean is a data type representing binary values, typically true or false. It is crucial for logical operations and decision-making in programming. Boolean data types are employed in conditions, loops, and comparisons, playing a fundamental role in control flow within programs. 

// Declaration and Initialization of a Boolean 

boolean isJavaFun = true; 

11.Explain the for loop and while loop in Java. 

     – For Loop: Executes a block of code repeatedly for a specified number of iterations. The loop consists of an initialization statement, a condition, and an iteration statement. 

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

           // Code to be executed 

       } 

       ` 

While Loop: Repeatedly executes a block of code as long as a specified condition is true. 

      int i = 0; 

       while (i < 5) { 

           // Code to be executed 

           i++; 

       } 

12.Explain conditional operators. 

Conditional operators (ternary operators) are shorthand for the if-else statement. They evaluate a boolean expression and return one of two values based on whether the expression is true or false. 

int result = (condition) ? valueIfTrue : valueIfFalse; 

13.Explain if and else statements. 

The “if” statement is used to execute a block of code if a specified condition is true. The “else” statement is optional and is executed if the “if” condition is false. 

             if (condition) { 

           // Code to be executed if the condition is true 

       } else { 

           // Code to be executed if the condition is false 

       } 

14.Write a code to iterate over the array and calculate the total sum. 

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

       int sum = 0; 

       for (int num : numbers) { 

           sum += num; 

       } 

       System.out.println("Total Sum: " + sum); 

15.Write a code to reverse a string. 

      String original = "Hello"; 

   char[] charArray = original.toCharArray(); 

   int start = 0; 

   int end = charArray.length - 1; 

   while (start < end) { 

       char temp = charArray[start]; 

       charArray[start] = charArray[end]; 

       charArray[end] = temp; 

       start++; 

       end--; 

   } 

   String reversed = new String(charArray); 

   System.out.println("Reversed String: " + reversed); 

16.How do you reverse a string? 

   String original = "Hello"; 

   char[] charArray = original.toCharArray(); 

   int start = 0; 

   int end = charArray.length - 1; 

   while (start < end) { 

       char temp = charArray[start]; 

       charArray[start] = charArray[end]; 

       charArray[end] = temp; 

       start++; 

       end--; 

   } 

   String reversed = new String(charArray); 

   System.out.println("Reversed String: " + reversed); 

17.How can you check whether a string is a palindrome or not? 

      String str = "level"; 

   char[] charArray = str.toCharArray(); 

   int start = 0; 

   int end = charArray.length - 1; 

   boolean isPalindrome = true; 

   while (start < end) { 

       if (charArray[start] != charArray[end]) { 

           isPalindrome = false; 

           break; 

       } 

       start++; 

       end--; 

   } 

   System.out.println("Is Palindrome: " + isPalindrome); 

18.How can you compute the number of numerals in a string? 

       String str = "Hello123"; 

   int digitCount = 0; 

   for (int i = 0; i < str.length(); i++) { 

       char ch = str.charAt(i); 

       if (ch >= '0' && ch <= '9') { 

           digitCount++; 

       } 

   } 

   System.out.println("Number of Numerals: " + digitCount); 

19.How do you find the count for the occurrence of a particular character in a string? 

     String str = "programming"; 

   char targetChar = 'g'; 

   int charCount = 0; 

   for (int i = 0; i < str.length(); i++) { 

       if (str.charAt(i) == targetChar) { 

           charCount++; 

       } 

   } 

   System.out.println("Count of '" + targetChar + "': " + charCount); 

20.How do you find the non-matching characters in a string? 

   String str1 = "apple"; 

   String str2 = "orange"; 

   StringBuilder nonMatching = new StringBuilder(); 

   for (int i = 0; i < Math.min(str1.length(), str2.length()); i++) { 

       if (str1.charAt(i) != str2.charAt(i)) { 

           nonMatching.append(str1.charAt(i)); 

       } 

   } 

   System.out.println("Non-Matching Characters: " + nonMatching.toString()); 

21.How do you find out if the two given strings are anagrams? 

   String str1 = "listen"; 

   String str2 = "silent"; 

   char[] charArray1 = str1.toCharArray(); 

   char[] charArray2 = str2.toCharArray(); 

   Arrays.sort(charArray1); 

   Arrays.sort(charArray2); 

   boolean areAnagrams = Arrays.equals(charArray1, charArray2); 

   System.out.println("Are Anagrams: " + areAnagrams); 

22. How do you calculate the number of vowels and consonants in a string? 

      String str = "hello"; 

   int vowelCount = 0; 

   int consonantCount = 0; 

   for (int i = 0; i < str.length(); i++) { 

       char ch = Character.toLowerCase(str.charAt(i)); 

       if (ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u') { 

           vowelCount++; 

       } else if (ch >= 'a' && ch <= 'z') { 

           consonantCount++; 

       } 

   } 

   System.out.println("Vowel Count: " + vowelCount); 

   System.out.println("Consonant Count: " + consonantCount);

23. How do you reverse an array? 

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

   int start = 0; 

   int end = arr.length - 1; 

   while (start < end) { 

       int temp = arr[start]; 

       arr[start] = arr[end]; 

       arr[end] = temp; 

       start++; 

       end--; 

   } 

24. How do you find the maximum element in an array? 

   int[] arr = {5, 3, 9, 2, 7}; 

   int max = arr[0]; 

   for (int i = 1; i < arr.length; i++) { 

       if (arr[i] > max) { 

           max = arr[i]; 

       } 

   } 

   System.out.println("Maximum Element: " + max);

25.How do you find the average of numbers in a list? 

   List<Integer> numbers = Arrays.asList(2, 4, 6, 8, 10); 

   int sum = 0; 

   for (int num : numbers) { 

       sum += num; 

   } 

   double average = (double) sum / numbers.size(); 

System.out.println("Average: " + average); 

26. How can you remove duplicates from arrays?

This is one of the important basic coding questions for interview. To answer, you can mention two processes broadly, either by using a temporary array or a separate index. To remove duplicates, the array must be sorted. The process of calling Arrays. sort (arr) method can be used.  Also, you must use the LinkedHashSet (Set Interface) to retain the original insertion order of the elements into the set. You must use loops or recursion functions to solve these coding interview questions.

The main factor we must remember when dealing with arrays of coding questions asked in interview is not the elements with duplicates. The main problem here is removing the duplicates instead. Arrays are static data structures that are of fixed length, thus not possible to be altered. So, to delete elements from arrays, you need to create new arrays and duplicate the content into these new arrays.

Check out Cybersecurity course to upskill yourself and gain an edge.

First, you must convert the arrays into Arraylists and then create LinkedHashSets from these ArrayLists. If input arrays contain a larger number of duplicates then it can result in multiple temporary arrays, thus increasing the cost of importing the content. This restriction enforces that we approach this problem in a manner that requires less memory and processing power.

We must remove the duplicates but not copy them into the resulting arrays, thus not deleting the duplicates entirely but simply replacing them with 0 as the default value.

 

Source

Our learners also read: Learn java online free!

27.How can we check if a number is a prime number?

A prime number is a number greater than 1 and divisible by itself. This is one of the most common coding interview questions that involve finding out if the given number is a prime number or not. These kinds of programs are the foundations of algorithmic thinking as we must come up with solutions that are based on the fact that prime numbers are all natural numbers that cannot be divided by positive numbers other than 1.

We must write code to create loops that check each number starting from 1 to the target number to see if the target number is divisible by any other positive number other than itself or 1.

This function will lead us to the solution. When checking for a number that is especially large, then we can simply check till the square root of N, N being the target number. There is no need to check till N in the case of an eligible square root.

If the number is not divisible by 2, there is no need to check if it is divisible by other even numbers, thus decreasing the time required to find the solution. This is an optimized version of the solution where analysing the number before writing the solution comes in handy. 

If this coding round questions for freshers is asked during c programming interview questions, then mention  can be made in terms that: “ In order to check the status if a number is a prime number or not in C++ then the input should be taken from the user to check if a number is a prime number or not.”

Source

Also, visit upGrad’s Degree Counselling page for all undergraduate and postgraduate programs.

28. How can you check if strings contain only digits?

If you wish to write regular expressions for checking if strings are only numbers or if they contain non-digit characters, you must first get comfortable with using character sets in Java regular expressions. Programming languages such as Java support regular expressions with the help of java.util.regex.Matcher class and java.util.regex.Pattern. Java.util.regex is a dedicated package for this purpose.

In order to validate the existence of only numbers using regular expressions, we can use code to analyse if strings contain a raw integer. We will check if the string contains only digits within 0 – 9. Even if the string contains digits but also other characters, it is not a simple numeric string. Regular expressions only check for integer numbers and do not consider dot characters (.), thus, making decimal numbers and floating points fail the test.

Also, to answer coding round questions for freshers, the function of isdigit() can be used if a string contains only a digit. It returns true for all the characters which contain digits.

29.How can you replace or remove characters from strings? 

Suppose we have a string, ‘Woocommerce’, and we wish to replace the letter ‘r’ with ‘n’, there are multiple methods to achieve this. String classes in Java provide multiple approaches to replace characters inside strings using CharSequence and substrings.

You can easily call a replace method inside the string that will end up replacing the target character and returning the desired character as a result. Strings are immutable in programming languages such as Java.

Thus, every time these operations such as removal or replacements are performed on strings, new string objects are generated by default. There are 4 overloaded methods for replacing strings using Java:

• replace(char oldChar, char newChar)
• replaceAll(String regex, String replacement)
• replace(CharSequence target, CharSequence replacement)
• replaceFirst(String regex, String replacement)

CharSequence is one of the super interfaces for strings, StringBuilder and StringBuffer, allowing us to pass off any of the objects from these as arguments for this replacement method. replaceAll() ends up replacing every single match with replacement strings while replaceFirst() only replaces the first matches.

All in all, all of these are powerful methodologies that accept regular expression. Java.lang.String class allows all these overloaded methods that can easily replace single characters or substrings in Java.

 It is highly recommended to use replaceAll() as this replaces every occurrence of matching characters. Following this approach allows us to expect regular expression patterns, thus garnering more power. This method can also replace every comma with pipes for converting comma-separated files into pile delimited strings.

However, if one wishes to only replace a single character, one can just use the replace() method that takes the old and new given character into consideration. In Python as well, a string can be replaced using stringreplace(), the correct syntax to replace is string_name. It can be written in this format-

replace(old string, new string) where the old string is the recent data and the new string represents the data that will take place of the old string.

Read: Java Interview Questions & Answers

30. c?

For this solution, we must code a function or method that can find the largest or smallest number from arrays that are full-fledged integers. We must first create a source file in Java using the name MaximumMinimumArrayDemo.java and copy the written code here for compilation and execution.

We can use two variables that we can refer to as ‘largest’ and ‘smallest’ to store the maximum and minimum values respectively from the arrays. The smallest number can be initialised using integer.MIN_VALUE and the largest can be initialised using integer.MAX_VALUE.

With every iteration of the loops that you have initiated, you can compare current numbers with ‘largest’ and ‘smallest’ and update them accordingly. Arrays do not override the toString method in Java, so you can use Arrays.toString() for printing the contents of the target arrays.

You can use this static method to directly call the main function. You must then pass the random arrays through this method to check if the maximum and minimum values have been returned accurately. You can also choose to automate this testing through Unit tests in your IDE.

Source

Checkout: Top 4 Computer Skills to Put in Your Resume

These basic programming questions and answers will serve as solid foundation to start with your interviews preparation. 

Coding Interview Questions and Answers for Experienced

For experienced professionals, the interviews are conducted to gauge the intermediate to advanced conceptual understanding along with logical programming questions and answers. Here are 25 such questions for experienced engineers that would help them get an idea and set the turf for their upcoming interviews. 

1. How can you find the first non-repeated character in a word?

To answer this interview coding questions you must first understand what must be done to promote this function. A function that accepts strings and returns the first non-repeated characters needs to be written.

For example, in the word, ‘passage’, ‘p’ is the first non-repeated character or in the word, ‘turtle’, ‘u’ is the first non-repeated character. So, how do we solve this problem? We can create a table for storing the repetitions for all the characters and then select the first entries that are not repeated.

Check out our Java Bootcamp designed to upskill working professionals.

In order to write a code that will return the first non-repeated letters, we can use Linked Hash Map to store the character count. This HashMap follows the order of the insertion and characters are initialized in the same position as in the string. The scanned string must be iterated using Linked Hash Map to choose the required entry with the value of 1. 

Another way to approach this interview coding questions is using the first Nonrepeating Char(String word). This allows the non-repeated character, which appears first, to be identified in a single pass. This approach used two storage to replace an interaction. This method stores non-repeated and repeated characters separately, and when the iteration ends, the required character is the first element in the list.

There is a way to find the first non-repeated characters in Java as well, by using the indexOf() and lastIndexOf() processing method. The return of position of the first occurrence of a character in a string is supported by indexOf(). Whereas, the return of the occurrence of the last character’s position in a string is facilitated by the lastIndexOf().

Check Out upGrad Advanced Certification in DevOps

upGrad’s Exclusive Software and Tech Webinar for you –

SAAS Business – What is So Different?

2. How can you reverse the words in a target sentence without the help of library methods?

This is also one of the very common most asked coding questions in interview. First, we must understand the requirement and how to fill the gap in this requirement. When faced with such questions, we must first ask the right questions. Strings are sentences of decided characters that might contain a single word or multiple words.

A sentence might also be empty. For example, if we are given the sentence, ‘Programming is fun.’, we must reverse it to, ‘Fun is programming.’ effectively. We must use regular expressions in Java to divide the given strings into spaces followed by applying the reverse()method from the Collections utility class.

Once you are able to divide the strings using regex’\\s’, an array of words will be returned as a result. This also takes care of the words separated using multiple spaces. As soon as the array is returned, you can then choose to create ArrayLists from these arrays followed by using the Collections.reverse()method. This reverses ArrayLists and every word will be reinitialised in the reverse order.

Now, all that is left is using StringBuilder to concatenate multiple strings through ArrayList iteration. One must make sure that size is specified as StringBuilder resizing is a costly process in terms of processing power and memory. The resizing ends up creating new arrays by copying the content from the older arrays.

3.How can you append texts to files in programming languages such as Java? 

To crack the most asked coding questions in interview, one needs to explain the answer elaboratively. Appending is very different compared to creating new files and writing data into the new files. In cases of appending, files already exist, and we simply need to add text at the end of the file. This is similar to log files, as they are constantly updated with the system.

Log files are the perfect example of appending text as applications iteratively keep appending log details into these files. Logging frameworks are not required for this problem, but you must know how to append text into existing files. In order to solve this problem, you must be aware of convenience classes to write character files.

The class has constructors that assume the acceptability of default byte-buffer and character encoding. If you wish to specify the values yourself, you can simply construct the OutputStreamWriter using the FileOutputStream. The availability of files depends on the underlying platforms, which determine if the file might be created or not.

A few platforms allow files to be initialised for writing functions using a single FileWrite or multiple file-writing objects. However, constructors from this class will be failing once the involved file is already initialised. FileWriter is used for writing character streams and FileOutputStream can write raw byte streams. The special constructor in  FileWriter accepts a file, once passed true the file can be opened in the append mode. This makes the task easier by enabling adding text at the end of the file. This FileWriter can be used to add text to a file multiple times. One of the benefits to add text using this method is that it maintains the position and length.

Learn Software Development Courses online from the World’s top Universities. Earn Executive PG Programs, Advanced Certificate Programs or Masters Programs to fast-track your career.

4.What is Recursion?

This is another programming questions for freshers. Recursion is a programming technique in which a function calls itself to solve a problem. Recursion involves breaking down a complex problem into smaller, similar subproblems and solving each subproblem using the same approach. Recursive functions have two main components: a base case and a recursive case.

Here’s a breakdown of how recursion works:

Base Case:

When the function stops calling itself and returns a result directly, this is referred to as the base case condition. It provides the exit point for the recursion, preventing infinite loops. Base cases are usually simple cases that can be directly solved without further recursion.

Recursive Case:

In the recursive case, the function calls itself to solve a smaller version of the same problem. This step is crucial for breaking down the problem into smaller, more manageable parts. The recursive call should lead the problem toward the base case.

5.Explain Big O Notation.

 Big O notation is a mathematical representation that describes the upper bound on the asymptotic growth rate of an algorithm’s time complexity. It helps assess how the performance of an algorithm scales with input size. For example, O(n) signifies linear time complexity, indicating that the algorithm’s execution time grows linearly with the input size. It is crucial for understanding and comparing the efficiency of different algorithms when solving a problem. 

6.What is a LinkedList?

A LinkedList is a data structure that consists of nodes, where each node contains data and a reference (or link) to the next node in the sequence. Unlike arrays, LinkedLists allow dynamic memory allocation and efficient insertions or deletions at any position. They come in two types: singly linked lists, where each node points to the next, and doubly linked lists, where each node points to both the next and the previous nodes. 

7.Explain Singly and Doubly Linked List?

  – A singly linked list is a data structure where each node contains data and a reference to the next node. In contrast, a doubly linked list has nodes with references to both the next and the previous nodes. Singly linked lists are simpler and use less memory, but traversing backward is inefficient. Doubly linked lists provide bidirectional traversal but require more memory due to the additional references. 

8.What are Hashmaps?

Hashmaps are data structures that implement an associative array abstract data type. They use a hash function to map keys to indices, allowing efficient retrieval and storage of key-value pairs. Hashmaps offer constant-time average case complexity for basic operations like insertion, deletion, and lookup. However, collisions can occur when multiple keys hash to the same index, which is typically resolved using techniques like chaining or open addressing. 

9.What is a Binary Tree?

A binary tree is a hierarchical data structure where each node has at most two children, referred to as the left and right subtrees. The topmost node is called the root, and nodes with no children are leaves. Binary trees are widely used in computer science for efficient searching, sorting, and retrieval operations. Depending on the specific properties of the tree, such as balance, they can be classified into various types like binary search trees or AVL trees. 

9.What are some differences Between Breadth-First and Depth-First Search?

  – Breadth-First Search (BFS) and Depth-First Search (DFS) are algorithms used to traverse or search through graph-like structures. BFS explores a graph level by level, visiting all neighbors of a node before moving on to the next level. In contrast, DFS explores as deeply as possible along each branch before backtracking. BFS is often used to find the shortest path, while DFS is more memory-efficient and suited for problems involving cycles or connected components. 

10.Explain Recursion with Example.

  – Recursion is a programming concept where a function calls itself directly or indirectly. An example is the calculation of the factorial of a number. The factorial of n (denoted as n!) is the product of all positive integers up to n. The recursive definition is n! = n  (n-1)!, and the base case is 0! = 1. Here’s an example in Java: 

   int factorial(int n) { 

      if (n == 0 || n == 1) { 

          return 1; 

      } else { 

          return n  factorial(n - 1); 

      } 

  } 

 This function calculates the factorial of a number using recursion. 

11.SOLID Principle:

  – SOLID is an acronym representing a set of principles for writing maintainable and scalable software. The principles include: 

     – Single Responsibility Principle (SRP): A class should have only one reason to change. 

     – Open/Closed Principle (OCP): Software entities should be open for extension but closed for modification. 

     – Liskov Substitution Principle (LSP): Subtypes must be substitutable for their base types without altering the correctness of the program. 

     – Interface Segregation Principle (ISP): A class should not be forced to implement interfaces it does not use. 

     – Dependency Inversion Principle (DIP): High-level modules should not depend on low-level modules; both should depend on abstractions. 

  These principles guide developers in creating modular, flexible, and scalable software. 

12.Exception Handling:

  – Exception handling is a programming paradigm used to handle runtime errors or exceptional conditions gracefully. In languages like Java, it involves using try-catch blocks to isolate and handle exceptions. For example: 

   try { 

      // Code that may throw an exception 

      int result = 10 / 0; // Division by zero 

  } catch (ArithmeticException ex) { 

      // Handle the exception 

      System.out.println("Cannot divide by zero"); 

  } 

 In this example, if a division by zero occurs, the catch block handles the exception, preventing the program from crashing and allowing for proper error handling. 

13.Explain Stack and Queue with Real-world Example.

Stack and queue are abstract data types with specific rules for adding and removing elements. A real-world example of a stack is the undo mechanism in software applications. Each action is pushed onto the stack, allowing users to undo in reverse order. A real-world example of a queue is a printer queue, where print jobs are processed in the order they are received. Both data structures play a crucial role in managing tasks efficiently based on their respective principles. 

14.How to Find the Second Largest Number in an Array?

To find the second-largest number in an array, you can iterate through the array while maintaining two variables to track the largest and second-largest numbers. Here’s a Java implementation: 

   int findSecondLargest(int[] arr) { 

      int firstLargest = Integer.MIN_VALUE; 

      int secondLargest = Integer.MIN_VALUE; 

      for (int num : arr) { 

          if (num > firstLargest) { 

              secondLargest = firstLargest; 

              firstLargest = num; 

          } else if (num > secondLargest && num != firstLargest) { 

              secondLargest = num; 

          } 

      } 

      return secondLargest; 

  } 

  This algorithm ensures correct handling of cases with duplicate numbers. 

15.How Do You Find Duplicate Numbers in an Array with Multiple Duplicates?

  – To find duplicate numbers in an array with multiple duplicates, you can use a HashSet to keep track of unique elements while iterating through the array. If an element is already present in the HashSet, it is a duplicate. Here’s a Java example: 

   void findDuplicates(int[] arr) { 

      Set<Integer> set = new HashSet<>(); 

      Set<Integer> duplicates = new HashSet<>(); 

      for (int num : arr) { 

          if (!set.add(num)) { 

              duplicates.add(num); 

          } 

      } 

      System.out.println("Duplicate Numbers: " + duplicates); 

  } 

 This approach has a time complexity of O(n) and efficiently identifies all duplicate numbers. 

16.How Do You Implement Bubble Sort?

 Bubble Sort is a simple sorting algorithm that repeatedly steps through the list, compares adjacent elements, and swaps them if they are in the wrong order. The process is repeated 

until the list is sorted. Here’s a Java implementation: 

  void bubbleSort(int[] arr) { 

      int n = arr.length; 

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

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

              if (arr[j] > arr[j + 1]) { 

                  // Swap arr[j] and arr[j+1] 

                  int temp = arr[j]; 

                  arr[j] = arr[j + 1]; 

                  arr[j + 1] = temp; 

              } 

          } 

      } 

  } 

Bubble Sort has a time complexity of O(n^2) and is not the most efficient sorting algorithm for large datasets. 

17.How Do You Implement a Binary Search Tree?

A Binary Search Tree (BST) is a tree data structure where each node has at most two children, and the left child is less than or equal to the parent, while the right child is greater. Here’s a Java implementation: 

   class TreeNode { 

      int val; 

      TreeNode left, right; 

      public TreeNode(int val) { 

          this.val = val; 

          this.left = this.right = null; 

      } 

  } 

  class BinarySearchTree { 

      TreeNode root; 

      void insert(int key) { 

          root = insertRec(root, key); 

      } 

      TreeNode insertRec(TreeNode root, int key) { 

          if (root == null) { 

              root = new TreeNode(key); 

              return root; 

          } 

          if (key < root.val) { 

              root.left = insertRec(root.left, key); 

          } else if (key > root.val) { 

              root.right = insertRec(root.right, key); 

          } 

          return root; 

      } 

  } 

 This code defines a basic Binary Search Tree with an insert operation. 

18.Write a Code to Find the Maximum Depth of a Binary Tree.

To find the maximum depth of a binary tree, you can use a recursive approach, calculating the depth of the left and right subtrees and returning the maximum. Here’s a Java implementation: 

   class TreeNode { 

      int val; 

      TreeNode left, right; 

      public TreeNode(int val) { 

          this.val = val; 

          this.left = this.right = null; 

      } 

  } 

  int maxDepth(TreeNode root) { 

      if (root == null) { 

          return 0; 

      } 

      int leftDepth = maxDepth(root.left); 

      int rightDepth = maxDepth(root.right); 

      return Math.max(leftDepth, rightDepth) + 1; 

  } 

  This code calculates the maximum depth of a binary tree using recursion. 

19.How Do You Reverse a Linked List?

  – To reverse a linked list, you can iteratively reverse the links between nodes. Here’s a Java implementation: 

   class ListNode { 

      int val; 

      ListNode next; 

      public ListNode(int val) { 

          this.val = val; 

          this.next = null; 

      } 

  } 

  ListNode reverseList(ListNode head) { 

      ListNode prev = null; 

      ListNode current = head; 

      ListNode next; 

      while (current != null) { 

          next = current.next; 

          current.next = prev; 

          prev = current; 

          current = next; 

      } 

      return prev; 

  } 

This code iteratively reverses a linked list by updating the next pointers. 

20.How Do You Add an Element to the Middle of a Linked List?

To add an element to the middle of a linked list, you need to find the middle node and insert the new node after it. Here’s a Java implementation: 

   class ListNode { 

      int val; 

      ListNode next; 

      public ListNode(int val) { 

          this.val = val; 

          this.next = null; 

      } 

  } 

  void insertMiddle(ListNode head, int value) { 

      ListNode slow = head; 

      ListNode fast = head; 

      while (fast != null && fast.next != null) { 

          slow = slow.next; 

          fast = fast.next.next; 

      } 

      ListNode newNode = new ListNode(value); 

      newNode.next = slow.next; 

      slow.next = newNode; 

  } 

  This code finds the middle node using the slow and fast pointer technique and inserts a new node after it. 

21. Check if the Following Number Is an Armstrong Number.

 An Armstrong number is a number that is the sum of its own digits, each raised to the power of the number of digits. To check if a number is an Armstrong number, you can use the following Java code: 

  boolean isArmstrong(int num) { 

      int originalNum = num; 

      int n = String.valueOf(num).length(); 

      int sum = 0; 

      while (num > 0) { 

          int digit = num % 10; 

          sum += Math.pow(digit, n); 

          num /= 10; 

      } 

      return sum == originalNum; 

  } 

 This code calculates the sum of the digits raised to the power of the number of digits and checks if it equals the original number. 

22. Given an Unsorted Array of Integers, Find the Length of the Longest Consecutive Elements Sequence.

 To find the length of the longest consecutive elements sequence in an unsorted array, you can use a HashSet to efficiently track elements and their consecutive sequences. Here’s a Java implementation: 

 int longestConsecutive(int[] nums) { 

      Set<Integer> set = new HashSet<>(); 

      for (int num : nums) { 

          set.add(num); 

      } 

      int longestStreak = 0; 

      for (int num : set) { 

          if (!set.contains(num - 1)) { 

              int currentNum = num; 

              int currentStreak = 1; 

              while (set.contains(currentNum + 1)) { 

                  currentNum++; 

                  currentStreak++; 

              } 

              longestStreak = Math.max(longestStreak, currentStreak); 

          } 

      } 

      return longestStreak; 

  } 

 This code utilizes a HashSet to efficiently check for consecutive elements and find the length of the longest sequence.

23. How Do You Check if Two Strings Are a Rotation of Each Other:

  To check if two strings are rotations of each other, you can concatenate one string with itself and see if the other string is a substring of the concatenated string. Here’s a Java implementation: 

   boolean areRotations(String str1, String str2) { 

      if (str1.length() != str2.length()) { 

          return false; 

      } 

      String concatenated = str1 + str1; 

      return concatenated.contains(str2); 

  } 

This code checks if the length of the two strings is the same and if one string is a rotation of the other.

24. How to Find the Length of the Longest Substring Without Repeating Characters:

 To find the length of the longest substring without repeating characters, you can use the sliding window technique with a HashSet to track unique characters. Here’s a Java implementation: 

   int lengthOfLongestSubstring(String s) { 

      Set<Character> set = new HashSet<>(); 

      int left = 0, right = 0, maxLength = 0; 

      while (right < s.length()) { 

          if (!set.contains(s.charAt(right))) { 

              set.add(s.charAt(right)); 

              maxLength = Math.max(maxLength, right - left + 1); 

              right++; 

          } else { 

              set.remove(s.charAt(left)); 

              left++; 

          } 

      } 

      return maxLength; 

  } 

This code uses a sliding window to efficiently find the length of the longest substring without repeating characters.

25.How to Find All Permutations of a String:

 To find all permutations of a string, you can use a recursive approach where each character is fixed at the beginning, and permutations of the remaining characters are recursively generated. Here’s a Java implementation: 

   List<String> permutations(String s) { 

      List<String> result = new ArrayList<>(); 

      generatePermutations("", s, result); 

      return result; 

  } 

  void generatePermutations(String prefix, String remaining, List<String> result) { 

      int n = remaining.length(); 

      if (n == 0) { 

          result.add(prefix); 

      } else { 

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

              generatePermutations(prefix + remaining.charAt(i), 

                                    remaining.substring(0, i) + remaining.substring(i + 1), 

                                    result); 

          } 

      } 

  } 

This code generates all permutations of a string using recursion. 

26.How to rotate an array left and right by a given number K?

  To rotate an array left and right by a given number `K`, you can use various approaches. Here, I’ll provide examples in Java for both left and right rotations. 

Left Rotation: 

public class LeftRotation { 

   static void leftRotate(int[] arr, int k) { 

       int n = arr.length; 

       k = k % n; // To handle cases where k is greater than array length 

       reverse(arr, 0, k – 1); 

       reverse(arr, k, n – 1); 

       reverse(arr, 0, n – 1); 

   } 

   static void reverse(int[] arr, int start, int end) { 

       while (start < end) { 

           int temp = arr[start]; 

           arr[start] = arr[end]; 

           arr[end] = temp; 

           start++; 

           end–; 

       } 

   } 

   public static void main(String[] args) { 

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

       int rotationCount = 2; 

       System.out.println(“Original Array: ” + Arrays.toString(array)); 

       leftRotate(array, rotationCount); 

       System.out.println(“Left Rotated Array: ” + Arrays.toString(array)); 

   } 

} 

Right Rotation: 

public class RightRotation { 

   static void rightRotate(int[] arr, int k) { 

       int n = arr.length; 

       k = k % n; // To handle cases where k is greater than array length 

       reverse(arr, 0, n - 1); 

       reverse(arr, 0, k - 1); 

       reverse(arr, k, n - 1); 

   } 

   static void reverse(int[] arr, int start, int end) { 

       while (start < end) { 

           int temp = arr[start]; 

           arr[start] = arr[end]; 

           arr[end] = temp; 

           start++; 

           end--; 

       } 

   } 

   public static void main(String[] args) { 

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

       int rotationCount = 2; 

       System.out.println("Original Array: " + Arrays.toString(array)); 

       rightRotate(array, rotationCount); 

       System.out.println("Right Rotated Array: " + Arrays.toString(array)); 

   } 

} 

In both cases, the `leftRotate` and `rightRotate` functions use a helper function `reverse` to reverse a portion of the array. This ensures an efficient rotation by reversing sections of the array based on the given rotation count `K`.

27.Find the Index of Two Array Elements Whose Sum Is Equal to the Given Value.

 To find the index of two array elements whose sum is equal to a given value, you can use a HashMap to store the complement of each element. Here’s a Java implementation: 

  int[] findTwoSum(int[] nums, int target) { 

      Map<Integer, Integer 

> map = new HashMap<>(); 

      for (int i = 0; i < nums.length; i++) { 

          int complement = target - nums[i]; 

          if (map.containsKey(complement)) { 

              return new int[]{map.get(complement), i}; 

          } 

          map.put(nums[i], i); 

      } 

      return new int[]{-1, -1}; 

  } 

This code efficiently finds the indices of two array elements whose sum is equal to the given value using a HashMap.

28.How Do You Find All Pairs of an Integer Array Whose Sum Is Equal to a Given Number?

 To find all pairs of an integer array whose sum is equal to a given number, you can use the two pointers approach with sorting. Here’s a Java implementation: 

   List<int[]> findPairsWithSum(int[] nums, int target) { 

      List<int[]> result = new ArrayList<>(); 

      Arrays.sort(nums); 

      int left = 0, right = nums.length - 1; 

      while (left < right) { 

          int sum = nums[left] + nums[right]; 

          if (sum == target) { 

              result.add(new int[]{nums[left], nums[right]}); 

              left++; 

              right--; 

          } else if (sum < target) { 

              left++; 

          } else { 

              right--; 

          } 

      } 

      return result; 

  } 

  This code efficiently finds all pairs of an integer array whose sum is equal to a given number using two pointers and sorting. 

 What is the Best Way to Prepare for a Coding Interview?

Preparing for a coding interview questions for freshers requires a combination of technical knowledge, problem-solving skills, basic coding questions for interview, and effective communication so that you can clear it and get your dream job. Here’s a comprehensive plan to help you to prepare programming questions for freshers for an interview: –

• Understand the Basics

First, review fundamental data structures (arrays, linked lists, stacks, queues, trees, graphs) and algorithms (sorting, searching, recursion, dynamic programming). Brush all the above things on time and space complexity analysis.

• Practice Coding

Solve various coding interview questions with solutions on platforms like LeetCode, HackerRank, and CodeSignal.

On top of that, focus on different categories: arrays, strings, linked lists, trees, graphs, dynamic programming, etc. if you want to crack the interview, you have to aim for both easy and hard problems to cover a wide range of difficulties.

• Study Problem Patterns

Recognize common problem-solving patterns such as sliding windows, two-pointers, greedy algorithms, and divide and conquer. Moreover, learn to identify the appropriate pattern for different types of problems.

• Mock Interviews

Practice with mock interviews to simulate the actual interview experience. Use platforms like Pramp or interviewing.io to practice real-time coding and communication.

• System Design (if applicable)

Suppose your coding interview questions with solutions interview includes a system design component and study system design principles and patterns. Also, practice designing scalable and maintainable systems.

• Review Key Concepts

Review object-oriented programming (OOP) principles and design patterns. Furthermore, understand database concepts, networking, and web technologies if relevant.

• Whiteboard Coding

Practice coding on a whiteboard or a code editor without the help of an IDE. Also, focus on clarity, step-by-step explanation, and code correctness.

• Time Management

Work on improving your problem-solving speed. Set time limits for each problem and prioritize efficiency in both code and approach.

• Learn from Mistakes

Analyze your mistakes and suboptimal solutions to learn from them and understand why certain approaches failed and how to improve them.

• Stay Updated

Keep up with new coding trends, languages, and libraries by following blogs, online forums, and YouTube channels related to coding interviews.

• Communication Skills

Practice explaining your thought process clearly while solving problems. Additionally, articulate your approach, considerations, and trade-offs.

• Behavioral Questions

Prepare for behavioral questions that might be part of the interview and use the STAR method (Situation, Task, Action, Result) to structure your responses.

• Rest and Relaxation

Get sufficient rest before the interview day and stay relaxed to manage stress during the interview.

• Interview Day Preparation

Review your notes, key concepts, and problem-solving strategies. Apart from that, keep a positive attitude and stay focused during the interview.

Remember, consistent and focused practice is key to success in coding interviews along with basic coding questions for interview. It’s not just about memorizing solutions but developing a strong problem-solving mindset. Practice regularly, learn from your mistakes, and adapt your strategies based on your experiences.

Conclusion

The art of answering is a skill to polish, it is important to be ready for the questions which are relevant to the job profile. This set of coding interview questions is an attempt to take you toward the first step of cracking the coding interview. Courses that are focused on programming are not just great for solving problems but also additionally increase your chances of being selected when applying for jobs. If you wish to learn more about Java programming and more advanced coding problems, you can enrol yourself into a comprehensive course such as upGrad’s Master of Science in Computer Science or the Full Stack Development Course.