For the first technical round of interviews at HashedIn, you can expect to face
questions that assess your problem-solving abilities, understanding of data
structures and algorithms, and your proficiency in Java. Here are some key areas
and sample questions to help you prepare:
### Key Areas to Focus On
1. **Data Structures**: Arrays, Linked Lists, Stacks, Queues, Trees, Graphs, Hash
Tables, and Heaps.
2. **Algorithms**: Sorting, Searching, Dynamic Programming, Greedy Algorithms,
Backtracking, and Graph Algorithms.
3. **Programming Concepts**: Object-Oriented Programming (OOP), Design Patterns,
Exception Handling, and Multithreading.
4. **Java-Specific Questions**: Understanding of core Java concepts such as
Collections Framework, Java Memory Model, Java Concurrency, and Java 8 features
(like Streams and Lambdas).
### Sample Questions and Solutions
#### Data Structures and Algorithms
1. **Find the Middle of a Linked List**:
```java
class ListNode {
int val;
ListNode next;
ListNode(int x) { val = x; }
}
public class LinkedListMiddle {
public ListNode findMiddle(ListNode head) {
if (head == null) return null;
ListNode slow = head;
ListNode fast = head;
while (fast != null && fast.next != null) {
slow = slow.next;
fast = fast.next.next;
}
return slow;
}
}
```
2. **Check for Balanced Parentheses using Stack**:
```java
import java.util.Stack;
public class BalancedParentheses {
public boolean isValid(String s) {
Stack<Character> stack = new Stack<>();
for (char c : s.toCharArray()) {
if (c == '(' || c == '{' || c == '[') {
stack.push(c);
} else {
if (stack.isEmpty()) return false;
char top = stack.pop();
if ((c == ')' && top != '(') || (c == '}' && top != '{') || (c
== ']' && top != '[')) {
return false;
}
}
}
return stack.isEmpty();
}
}
```
3. **Binary Search**:
```java
public class BinarySearch {
public int binarySearch(int[] nums, int target) {
int left = 0, right = nums.length - 1;
while (left <= right) {
int mid = left + (right - left) / 2;
if (nums[mid] == target) return mid;
if (nums[mid] < target) left = mid + 1;
else right = mid - 1;
}
return -1;
}
}
```
4. **Merge Two Sorted Arrays**:
```java
public class MergeSortedArrays {
public int[] merge(int[] nums1, int m, int[] nums2, int n) {
int i = m - 1, j = n - 1, k = m + n - 1;
while (i >= 0 && j >= 0) {
if (nums1[i] > nums2[j]) {
nums1[k--] = nums1[i--];
} else {
nums1[k--] = nums2[j--];
}
}
while (j >= 0) {
nums1[k--] = nums2[j--];
}
return nums1;
}
}
```
5. **Find the Longest Palindromic Substring**:
```java
public class LongestPalindromicSubstring {
public String longestPalindrome(String s) {
if (s == null || s.length() < 1) return "";
int start = 0, end = 0;
for (int i = 0; i < s.length(); i++) {
int len1 = expandAroundCenter(s, i, i);
int len2 = expandAroundCenter(s, i, i + 1);
int len = Math.max(len1, len2);
if (len > end - start) {
start = i - (len - 1) / 2;
end = i + len / 2;
}
}
return s.substring(start, end + 1);
}
private int expandAroundCenter(String s, int left, int right) {
while (left >= 0 && right < s.length() && s.charAt(left) ==
s.charAt(right)) {
left--;
right++;
}
return right - left - 1;
}
}
```
#### Object-Oriented Programming (OOP)
1. **Design a Simple Library Management System**:
```java
import java.util.*;
class Book {
private String title;
private String author;
private String ISBN;
private boolean isAvailable;
public Book(String title, String author, String ISBN) {
this.title = title;
this.author = author;
this.ISBN = ISBN;
this.isAvailable = true;
}
// Getters and Setters
public boolean isAvailable() {
return isAvailable;
}
public void setAvailable(boolean available) {
isAvailable = available;
}
// Other methods
}
class Library {
private Map<String, Book> books;
public Library() {
this.books = new HashMap<>();
}
public void addBook(Book book) {
books.put(book.getISBN(), book);
}
public void removeBook(String ISBN) {
books.remove(ISBN);
}
public Book findBookByISBN(String ISBN) {
return books.get(ISBN);
}
public void checkoutBook(String ISBN) {
Book book = books.get(ISBN);
if (book != null && book.isAvailable()) {
book.setAvailable(false);
System.out.println("Book checked out successfully.");
} else {
System.out.println("Book is not available.");
}
}
public void returnBook(String ISBN) {
Book book = books.get(ISBN);
if (book != null && !book.isAvailable()) {
book.setAvailable(true);
System.out.println("Book returned successfully.");
} else {
System.out.println("Book was not checked out.");
}
}
// Other methods
}
public class LibraryManagementSystem {
public static void main(String[] args) {
Library library = new Library();
Book book1 = new Book("The Great Gatsby", "F. Scott Fitzgerald",
"12345");
Book book2 = new Book("1984", "George Orwell", "67890");
library.addBook(book1);
library.addBook(book2);
library.checkoutBook("12345");
library.returnBook("12345");
library.checkoutBook("67890");
}
}
```
#### Java-Specific Questions
1. **Java Collections Framework**:
- **Example: Using HashMap**:
```java
import java.util.HashMap;
import java.util.Map;
public class HashMapExample {
public static void main(String[] args) {
Map<String, Integer> map = new HashMap<>();
map.put("Alice", 30);
map.put("Bob", 25);
map.put("Charlie", 35);
for (Map.Entry<String, Integer> entry : map.entrySet()) {
System.out.println(entry.getKey() + ": " + entry.getValue());
}
}
}
```
2. **Java 8 Features**:
- **Example: Using Streams and Lambdas**:
```java
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class StreamExample {
public static void main(String[] args) {
List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David",
"Edward");
// Filtering names that start with 'A'
List<String> filteredNames = names.stream()
.filter(name ->
name.startsWith("A"))
.collect(Collectors.toList());
// Printing filtered names
filteredNames.forEach(System.out::println);
// Using map to convert names to uppercase
List<String> upperCaseNames = names.stream()
.map(String::toUpperCase)
.collect(Collectors.toList());
// Printing uppercase names
upperCaseNames.forEach(System.out::println);
}
}
```
### Preparation Tips
- **Practice Coding**: Solve problems on platforms like LeetCode, HackerRank, and
CodeSignal focusing on Java.
- **Understand Core Concepts**: Make sure you understand the core concepts of data
structures, algorithms, and OOP principles.
- **Revise Java Basics**: Review Java basics, especially Collections Framework,
Exception Handling, and Multithreading.
- **Mock Interviews**: Practice mock interviews with a friend or use platforms like
Pramp or Interviewing.io to simulate the interview environment.
By focusing on these areas and practicing the sample questions, you'll be well-
prepared for the first technical round at HashedIn.
