<\/span><\/h2>\n\n\n\nPreparing for an IBM coding interview offers a great opportunity to showcase your skills, especially for experienced professionals. To help you excel, here are 15 commonly asked IBM coding interview questions, along with their solutions covering a range of topics.<\/p>\n\n\n\n
Q31. Write a program to check if a string is a palindrome.<\/h3>\n\n\n\n
Sample Answer: <\/strong>This method uses two pointers, left and right, which start at the beginning and end of the string, respectively. It compares the characters at these two positions. If they are different, the string is not a palindrome, and the method returns false. The pointers then move towards the center, and this process continues until the pointers meet or cross. It returns true if no mismatch can be found, indicating the string is palindrome.<\/p>\n\n\n\nHere\u2019s a code to check if a string is a palindrome:<\/p>\n\n\n\n
public boolean isPalindrome(String str) \r\n{ int left = 0; \r\nint right = str.length() - 1; \r\n\r\nwhile (left < right) { \r\nif (str.charAt(left) != str.charAt(right)) {\r\nreturn false;\r\n} \r\nleft++; \r\nright--; \r\n} \r\nreturn true; \r\n}\r<\/code><\/pre>\n\n\n\nQ32. How do you implement a custom thread pool in Java?<\/h3>\n\n\n\n
Sample Answer: <\/strong>A custom thread pool can be implemented using the ExecutorService interface and the ThreadPoolExecutor class, which defines core pool size, maximum pool size, and keeping threads alive, among other things. Here\u2019s a code:<\/p>\n\n\n\nExecutorService executorService = new ThreadPoolExecutor(5, 10, 60, TimeUnit.SECONDS, new\r\nLinkedBlockingQueue<>());\r\nexecutorService.submit(new RunnableTask());\r<\/code><\/pre>\n\n\n\nQ33. Explain \u2018immutability\u2019 in Java. How would you create an immutable class?<\/h3>\n\n\n\n
Sample Answer: <\/strong>An immutable class is a class whose objects, once created, cannot be modified. The fields of an immutable class are typically declared as final and private, and the class provides no setter methods to alter its state. The object’s state is set only during construction through a constructor, and after that, it remains constant. This ensures thread safety and consistency, as the object’s data cannot be changed accidentally or maliciously after creation. <\/p>\n\n\n\nTo create an immutable class, you need to perform the following steps:<\/p>\n\n\n\n
\n- All fields are final and private. No setter methods should be there. <\/li>\n\n\n\n
- The object is completely initialized through the constructor, and its state cannot be modified afterward. <\/li>\n\n\n\n
- This ensures immutability, where the object’s data remains consistent and unchangeable once it is created. The following code demonstrates the implementation of an immutable class in Java, where the object’s state cannot be changed after initialization.<\/li>\n<\/ul>\n\n\n\n
Here\u2019s a code:<\/p>\n\n\n\n
public final class ImmutableClass{\r\nprivate final int value;\r\npublic ImmutableClass(int value) {\r\n}\r\nthis.value = value;\r\npublic int getValue() {\r\nreturn value;\r\n}\r<\/code><\/pre>\n\n\n\nQ34. What is the use of the volatile keyword in Java?<\/h3>\n\n\n\n
Sample Answer: <\/strong>The volatile keyword guarantees that a variable’s value will be read from and written in the main memory and not be cached in thread memory. It is used for variables that are accessed and changed by multiple threads, giving visibility to other threads and ensuring that a thread cannot interfere with the modification of the values.<\/p>\n\n\n\nQ35. Explain the Observer Design Pattern. How would you implement it in Java?<\/h3>\n\n\n\n
Sample Answer: <\/strong>Observer is a one-to-many dependency where the one that depends on more than one object is notified if any of the objects on which it depends change their state. <\/p>\n\n\n\nThe code for implementing this in Java is:<\/p>\n\n\n\n
interface Observer {\r\nvoid update(String message);\r\n}\r\nclass ConcreteObserver implements Observer {\r\npublic void update(String message) {\r\nSystem.out.println(\"Received message: \" + message);\r\n}\r\n}\r<\/code><\/pre>\n\n\n\nQ36. Write a function find_missing_number that takes a list of integers from 1 to n with exactly one number missing. The list contains n-1 numbers. Return the missing number?<\/h3>\n\n\n\n
Sample Answer: <\/strong>The find_missing_number function calculates the expected sum of integers from 1 to n, where n is the list length plus one. It then subtracts the sum of the given numbers from the expected sum. The difference between these sums is the missing number in the list.<\/p>\n\n\n\nHere\u2019s a code:<\/p>\n\n\n\n
def find_missing_number(nums):\r\n\tn = len(nums) + 1\r\n\texpected_sum = n * (n + 1) \/\/ 2 # Sum of first n natural numbers\r\n\tactual_sum = sum(nums) # Sum of numbers in the list\r\n\treturn expected_sum - actual_sum # The missing number is the difference\r<\/code><\/pre>\n\n\n\nQ37. What are the distinctions between a HashMap and a TreeMap in Java?<\/h3>\n\n\n\n
Sample Answer: <\/strong>HashMap does not keep any order of the keys, where O(1) is the time complexity for all basic operations. TreeMap, on the other hand, is sorted according to keys and uses a Red-Black Tree internally, giving it a time complexity of O(logn) for put and get operations.<\/p>\n\n\n\nQ38. What do ‘final’, ‘finally’, and ‘finalize’ mean in Java?<\/h3>\n\n\n\n
Sample Answer: <\/strong>The meaning of ‘final’, ‘finally’, and ‘finalize’ is:<\/p>\n\n\n\n\n- final <\/strong>is used to define the constant to avoid method overriding and inheritance.<\/li>\n\n\n\n
- finally <\/strong>is that block that gets executed even if there is no exception generated after the try block.<\/li>\n\n\n\n
- finalize <\/strong>is a method of the object class that is called before the object is garbage collected for cleanup.<\/li>\n<\/ul>\n\n\n\n
Q39. Write a function merge_sorted_arrays that takes two sorted arrays and merges them into a single sorted array.<\/h3>\n\n\n\n
Sample Answer:<\/strong> The function merges two sorted arrays by comparing their elements one by one and adding the smaller element to the result array. After one array is exhausted, the remaining elements of the other array are appended. This solution works in O(n + m) time complexity, where n and m are the lengths of the input arrays.<\/p>\n\n\n\nThe function for this used in Java is:<\/p>\n\n\n\n
def merge_sorted_arrays(arr1, arr2):\r\n merged_array = []\r\n i, j = 0, 0\r\n \r\n while i < len(arr1) and j < len(arr2):\r\n if arr1[i] < arr2[j]:\r\n merged_array.append(arr1[i])\r\n i += 1\r\n else:\r\n merged_array.append(arr2[j])\r\n j += 1\r\n \r\n # Append remaining elements\r\n merged_array.extend(arr1[i:])\r\n merged_array.extend(arr2[j:])\r\n return merged_array\r<\/code><\/pre>\n\n\n\nQ40. Explain the differences between Callable and Runnable in Java.<\/h3>\n\n\n\n
Sample Answer: <\/strong>Both Callable and Runnable are used for asynchronous task execution, but Callable can return a value or throw an exception, while Runnable cannot return values or throw exceptions. While callable works with an ExecutorService, runnable works under the Thread mechanism.<\/p>\n\n\n\nQ41. Write a function rotate_matrix that takes an n x n matrix and rotates it 90 degrees clockwise. The matrix is given as a list of lists.<\/h3>\n\n\n\n
Sample Answer: <\/strong>The rotate_matrix function rotates an n x n matrix 90 degrees clockwise by first transposing it (swapping rows and columns) and then reversing each row. This in-place solution has a time complexity of O(n^2) and efficiently modifies the matrix. <\/p>\n\n\n\nThe function for the same used in Java is:<\/p>\n\n\n\n
def rotate_matrix(matrix):\r\n n = len(matrix)\r\n # Transpose the matrix (swap rows and columns)\r\n for i in range(n):\r\n \tfor j in range(i, n):\r\n \tmatrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j]\r\n # Reverse each row\r\n for row in matrix:\r\n \trow.reverse()\r\n return matrix\r<\/code><\/pre>\n\n\n\nQ42. How would you implement a thread-safe LRU (Least Recently Used) cache in Java?<\/h3>\n\n\n\n
Sample Answer: <\/strong>In this implementation, the LinkedHashMap maintains the order of access. The removeEldestEntry() method is overridden to remove the oldest entry once the cache exceeds its capacity. This ensures the least recently used entry is evicted. The cache is thread-safe because LinkedHashMap is internally synchronized for single-threaded access. For full thread safety in a multi-threaded environment, additional synchronization mechanisms like ReentrantLock or synchronized blocks can be used.<\/p>\n\n\n\nHere’s an example:<\/p>\n\n\n\n
import java.util.LinkedHashMap;\r\nimport java.util.Map;\r\n \r\npublic class LRUCache<K, V> extends LinkedHashMap<K, V> {\r\n private final int capacity;\r\n \r\n public LRUCache(int capacity) {\r\n \tsuper(capacity, 0.75f, true); \/\/ True for access order\r\n \tthis.capacity = capacity;\r\n }\r\n \r\n @Override\r\n protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {\r\n \treturn size() > capacity;\r\n }\r\n \r\n public static void main(String[] args) {\r\n \tLRUCache<Integer, String> cache = new LRUCache<>(3);\r\n \tcache.put(1, \"One\");\r\n \tcache.put(2, \"Two\");\r\n \tcache.put(3, \"Three\");\r\n \tcache.get(1); \/\/ Access the key 1\r\n \tcache.put(4, \"Four\"); \/\/ This will evict key 2\r\n \tSystem.out.println(cache); \/\/ Output will be {1=One, 3=Three, 4=Four}\r\n }\r\n}\r<\/code><\/pre>\n\n\n\nQ43. How would you implement a distributed transaction management system using the Saga pattern in Java?<\/h3>\n\n\n\n
Sample Answer: <\/strong>The Saga pattern manages distributed transactions by coordinating a series of local transactions across services. Each service performs a local transaction and publishes events, with compensating actions triggered if a failure occurs, ensuring eventual consistency and reliability in microservices.<\/p>\n\n\n\nHere\u2019s a simplified implementation using the Saga pattern in Java:<\/p>\n\n\n\n
public class OrderService {\r\npublic void placeOrder(Order order) {\r\n \ttry {\r\n createOrder(order);\r\n InventoryService.updateInventory(order);\r\n \t} catch (Exception e) {\r\n compensateOrderCreation(order);\r\n \t}\r\n\t}\r\n \r\n\tprivate void createOrder(Order order) { \/* Order creation logic *\/ }\r\n\tprivate void compensateOrderCreation(Order order) { \/* Compensation logic *\/ }\r\n}\r\n \r\npublic class InventoryService {\r\n\tpublic static void updateInventory(Order order) {\r\n \ttry { \/* Update inventory logic *\/ }\r\n \tcatch (Exception e) { \/* Compensation logic *\/ }\r\n\t}\r\n}\r<\/code><\/pre>\n\n\n\nQ44. How would you implement a thread-safe Singleton pattern using the Bill Pugh Singleton design in Java?<\/h3>\n\n\n\n
Sample Answer: <\/strong>The Bill Pugh Singleton design uses a static inner class to implement the Singleton pattern efficiently. The instance is created only when needed, ensuring lazy initialization and thread safety. This method avoids synchronization overhead and leverages the Java ClassLoader mechanism. <\/p>\n\n\n\nHere’s an example:<\/p>\n\n\n\n
public class Singleton {\r\n \/\/ Private constructor to prevent instantiation\r\n private Singleton() {}\r\n \/\/ Static inner class responsible for holding the Singleton instance\r\n private static class SingletonHelper {\r\n \t\/\/ This line will only be executed when getInstance() is called\r\n \tprivate static final Singleton INSTANCE = new Singleton();\r\n }\r\n \/\/ Public method to provide access to the instance\r\n public static Singleton getInstance() {\r\n \treturn SingletonHelper.INSTANCE;\r\n }\r\n}\r<\/code><\/pre>\n\n\n\nQ45. How do you process the database transactions in Java?<\/h3>\n\n\n\n
Sample Answer: <\/strong>Transactions are handled in Java via JDBC or with a framework such as Hibernate. The Connection object contains the methods commit() and rollback() that manage transactions accordingly. A transaction is initiated with setAutoCommit(false) and performed by a commit or rollback transaction based on whether a transaction was committed or rollback. <\/p>\n\n\n\nHere\u2019s a code:<\/p>\n\n\n\n
connection.setAutoCommit(false);\r\ntry {\r\n\/\/ Execute queries\r\nconnection.commit();\r\n} catch (SQLException e) {\r\n}\r\nconnection.rollback();\r<\/code><\/pre>\n\n\n\nQ46. Write a program to implement a thread-safe Singleton pattern in Java.\u00a0<\/h3>\n\n\n\n
Sample Answer: <\/strong>The thread-safe Singleton pattern can be implemented using double-checked locking. By checking if the instance is null before and after synchronization, and using the volatile keyword, it ensures that only one instance is created in a multithreaded environment, improving performance. <\/p>\n\n\n\nHere\u2019s an implementation of a thread-safe Singleton pattern using the \u2018Double-Checked Locking\u2019 mechanism:<\/p>\n\n\n\n
public class Singleton {\r\n \t\/\/ Volatile keyword ensures that the instance is correctly handled in a multithreaded environment\r\n\tprivate static volatile Singleton instance;\r\n\t\/\/ Private constructor to prevent instantiation\r\n\tprivate Singleton() {}\r\n\tpublic static Singleton getInstance() {\r\n \tif (instance == null) {\r\n synchronized (Singleton.class) {\r\n \t\/\/ Double-checked locking to ensure only one instance is created\r\n \tif (instance == null) {\r\n instance = new Singleton();\r\n \t}\r\n \t}\r\n \t}\r\n \treturn instance;\r\n\t}\r\n}\r<\/code><\/pre>\n\n\n\nPro Tip:<\/strong> Experienced professionals can also consider applying for the IBM Associate System Engineer role. If you are looking to transition into this position, check out IBM associate system engineer interview questions<\/a> guide.<\/p>\n\n\n\n