david-kariuki / ace-the-java-coding-interview Goto Github PK

View Code? Open in Web Editor NEW

45.0 45.0 9.0 441 KB

Java project to learn advanced Data Structures and Algorithms

License: MIT License

Java 100.00%

dsa dsa-learning-series dsa-practice dsa-project dsalgo-questions

ace-the-java-coding-interview's People

Contributors

Stargazers

Watchers

Forkers

hellojyoti03 lrrp premvarma karthik8611 aakash-chouksey hamza7523 ramkbala darkmayor coeffowl966

ace-the-java-coding-interview's Issues

Arrays - Challenge 2: Merge Two Sorted Arrays

Arrays - Squaring a Sorted Array (easy)

Arrays - Ceiling of a Number (medium)

Arrays - Find Maximum in Sliding Window

Arrays - Challenge 3: Find Two Numbers that Add up to "n"

Arrays - Implement Binary Search on a Sorted Array

Arrays - Find Low/High Index of an Element in a Sorted Array

Arrays - Move All Zeros to the Beginning of the Array

Arrays - Permutations (medium)

Arrays - Triplet Sum to Zero (medium)

Arrays - Smallest Sub-array With a Greater Sum (easy)

Arrays - Challenge 7: Find Second Maximum Value in an Array

Arrays - Next Letter (medium)

Arrays - Introduction to Arrays

Challenge 7: Nested Loop with Multiplication (Pro)

Compute the big O complexity of the code snippet given below.

public static void main(String[] args) {
    int n = 10;   
		int sum = 0;  
    int j = 1;   
		double pie = 3.14; 

		for (int var = 0; var < n; var++) {  
      
			System.out.println("Pie: " + pie); 
			while(j < var) { 
        sum += 1;  
        j *= 2;  
      }
    } 
    System.out.println("Sum: " + sum); 
  }

Complexity Interview Questions

Arrays - Challenge 8: Right Rotate the Array by One Index

Arrays - Challenge 11: Find the Sum of Maximum Sum Subarray

Problem Sets

Problem Set 1 - 6

Arrays - Sort an Array Using Quicksort Algorithm

Arrays - Triplets with Smaller Sum (medium)

Challenge 3: Big O of Nested Loop with Multiplication

Compute the Big O of an algorithm that involves nested loops, and increments the loop variables through multiplication.

public static void main(String[] args) {
		int n = 10; // O(time complexity of the called function)
		int sum = 0; //O(?)
		double pie = 3.14; //O(?)
		int var = 1; //O(?)

		while(var < n) {
			System.out.println("Pie: " + pie); //O(?)
			for (int j = 0; j < var; j++) {
				sum++; //O(?)
			}
			var *= 2;  //O(?)
		} //end of while loop
		System.out.println("Sum: " + sum); //O(?)
	}

Arrays - Bitonic Array Maximum (easy)

Arrays - Challenge 10: Rearrange Sorted Array in Max/Min Form

Challenge 4: Nested Loop with Multiplication (Basic)

A basic exercise based on the Big(O) of an algorithm that involves nested loops and the loop variables increment with multiplication.

public static void main(String[] args) {
		int n = 10; // O(time complexity of the called function)
		int sum = 0; //O(1)
		double pie = 3.14; //O(1)
		int var = 1; //O(?)
		while(var < n) { 
			System.out.println("Pie: " + pie); 
				//O(?)
			for (int j = 1; j < n; j = j + 2) {   
				sum++;  
			}
			var *= 3;  
		} //end of while loop
		System.out.println("Sum: " + sum); //O(1)
	}

Arrays - Challenge 5: Find Minimum Value in Array

Arrays - Search a Rotated Array

Arrays - Triplet Sum Close to Target (medium)

Challenge 6: Nested Loop with Multiplication (Advanced)

Compute the Big O complexity of the code snippet given below.

public static void main(String[] args) {
    int n = 10;   
		int sum = 0; 
		double pie = 3.14; 

		for (int var = 0; var < n; var++) {   
      int j = 1;  
			System.out.println("Pie: " + pie);
			while(j < var) { 
        sum += 1;  
        j *= 2;  
      }
    } //end of for loop
    System.out.println("Sum: " + sum); 
  }

Arrays - Subsets With Duplicates (easy)

Arrays - Challenge 1: Remove Even Integers from an Array

Big Oh Cheat Sheet

Arrays - Pair with Target Sum (easy)

Arrays - Challenge 6: First Non-Repeating Integer in an Array

Cyclic Sort (easy)

Arrays - Order-agnostic Binary Search (easy)

Arrays - Conflicting Appointments (medium)

Arrays - Number Range (medium)

Challenge 2: Big (O) of Nested Loop with Subtraction

Compute Big(O) of an algorithm that involves nested loops and the loop variables decrement.

public static void main(String[] args) {
    int n = 10; // O(time complexity of the called function)
    int sum = 0; //O(1)
    double pie = 3.14; //O(1)
    
    //O(?)
    for (int var = n; var >= 1; var = var - 3) {
      System.out.println("Pie: " + pie);
      //O(?)
      for (int j = n; j >= 0; j = j - 1) {
        sum++;
      }
    } //end of outer for loop
  System.out.println("Sum: " + sum);//O(1)
  }

Challenge 1: Big (O) of Nested Loop with Addition

Compute the Big O complexity of an algorithm that involves nested loops where the loop variables increase with addition.

public static void main(String[] args) {
    int n = 10;
    int sum = 0;
    double pie = 3.14;
    
    for (int var = 0; var < n; var = var + 3) {
      System.out.println("Pie: " + pie);
      for (int j = 0; j < n; j = j + 2) {
        sum++;
        System.out.println("Sum = " + sum);
      }
    }
  }

Arrays - Merge Intervals (medium)

Challenge 5: Nested Loop with Multiplication (Intermediate)

Compute the Big O complexity of the code snippet given below. It is better to solve it on a piece of paper, and then see if your answer matches the correct option!

public static void main(String[] args) {
    int n = 10;    //O(1) 
    int sum = 0;  //O(1)
    int j = 1;   //O(1)
    double pie = 3.14;  //O(1) 
  
    //O(?)
    for (int var = 1; var < n; var += 3) {
      System.out.println("Pie: " + pie);
      j = 1;
      while (j < n) { //O(?)
        sum += 1;     
        j *= 3;       
      }
    }
    System.out.println("Sum: " + sum); //O(1)
	}