Merge branch 'main' of https://github.com/Blooverh/Java-DataStructs-Algorithms-LeetCode

Author: Blooverh

DataAndAlgoL/Chpt7BinaryHeapsPriorityQs/Problem7.java

@@ -0,0 +1,31 @@
+package DataAndAlgoL.Chpt7BinaryHeapsPriorityQs;
+
+
+/*
+ * Given a min heap, what is an algorithm to find the maximum element
+ * In a min heap, the max element is always at the leaf only 
+ */
+public class Problem7 {
+    public static void main(String[] args) {
+        Heap h= new Heap(5, 0);
+
+        h.Insert(5);
+        h.Insert(14);
+        h.Insert(2);
+        h.Insert(10);
+        h.Insert(21);
+
+        System.out.println(FindMaxElementMinHeap(h));
+    }
+
+    public static int FindMaxElementMinHeap(Heap h){
+        int max= -1;
+        for( int i= (h.count+1)/2; i < h.count; i++){
+            if(h.array[i] >max){
+                max=h.array[i];
+            }
+        }
+
+        return max;
+    }
+}

LeetCode/Array Exercises/ArrayFromPermutation.java

@@ -0,0 +1,31 @@
+package Grind169.Arrays;
+
+import java.util.Arrays;
+import java.util.HashMap;
+
+public class TwoSum_1 {
+    public static void main(String[] args) {
+        int nums[]={2,7,11,15};
+        int target=9;
+        System.out.println(Arrays.toString(twoSum(nums, target)));
+
+    }
+
+    public static int[] twoSum(int[] nums, int target){
+        int res[]= new int[2]; //stores both indices of num array that have values that add up to target
+        HashMap<Integer, Integer> map= new HashMap<>();  //stores numbers of num array as key and its indices as values in map
+
+        //iterated through the array
+        for(int i=0; i< nums.length; i++){
+            if(map.containsKey(target- nums[i])){ //checks if a key with value target- nums[i] exists in hashmap
+                //if it does
+                res[1]=i; //store the current i at position 1 of array result 
+                res[0]=map.get(target - nums[i]); //store at position 0 the value of the number in the hashmap that is equal to target-nums[i]
+            }
+            //if the if statement is not satisfied, put in map current i and its value from nums array 
+            map.put(nums[i], i);
+        }
+
+        return res; //return result array
+    }
+}

LeetCode/Grind169/Arrays/TwoSum_1.java

@@ -0,0 +1,37 @@
+package Grind169.Heaps;
+
+import java.util.Comparator;
+import java.util.PriorityQueue;
+
+public class KclosestPointsToOrigin_973 {
+    public static void main(String[] args) {
+        
+    }
+
+    public static int[][] kClosest(int[][] points, int k) {
+        // If the k points close to origin are all the points in the array, return the array
+        if (k == points.length){
+            return points;
+        }
+
+        // priority queue holds each point as max heap, thus sorted by the distance from origin in descending order
+        PriorityQueue<int[]> pq= new PriorityQueue<>(k, new Comparator<int[]>() {
+            // Comparator is used to compare two points and return the one that is closer to the origin
+            // compares which points ? -> compares the distance from origin of each point
+            @Override
+            public int compare(int[] a, int[] b){
+                return (b[0] *b[0] +b[1]*b[1]) - (a[0] *a[0] + a[1]* a[1]); // b-a because we want max heap
+            }
+        });
+
+        for(int[] point: points){
+            pq.add(point);
+            if(pq.size() > k){ // When size of PQ is > than k we poll remove first element (root) as it is the furthest from the origin
+                pq.poll();
+            }
+
+        }
+
+        return pq.toArray(new int[0][0]);                  
+    }
+}

LeetCode/Grind169/Heaps/KclosestPointsToOrigin_973.java

@@ -0,0 +1,81 @@
+package Grind169.Heaps;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.PriorityQueue;
+
+/*
+Given a characters array tasks, representing the tasks a CPU needs to do, where each letter represents a different task.
+Tasks could be done in any order. Each task is done in one unit of time. 
+For each unit of time, the CPU could complete either one task or just be idle.
+However, there is a non-negative integer n that represents the cooldown period between two same tasks (the same letter in the array), 
+    that is that there must be at least n units of time between any two same tasks.
+Return the least number of units of times that the CPU will take to finish all the given tasks.
+
+Example 1:
+
+Input: tasks = ["A","A","A","B","B","B"], n = 2
+Output: 8
+Explanation: 
+A -> B -> idle -> A -> B -> idle -> A -> B
+There is at least 2 units of time between any two same tasks.
+ */
+
+public class TaskScheduler_621 {
+    public static void main(String[] args) {
+        char[] tasks= {'A','A','A','B','B','B'};
+        int n=2;
+
+        System.out.println(leastInterval(tasks, n));
+    }
+
+    public static int leastInterval(char[] tasks, int n) {
+        //if there is no cooldown time between same tasks, units of time are the amount of tasks
+        if( n==0){
+            return tasks.length;
+        }
+
+        //To store the occurrences of each task 
+        HashMap<Character, Integer> map= new HashMap<>();
+
+        for(int i=0; i< tasks.length; i++){
+            map.put(tasks[i], map.getOrDefault(tasks[i], 0)+1); // if tasks are equal increase value, default value for each task that has no occurrence
+        }
+
+        //by default pq is a Min heap; hence the reverse order 
+        PriorityQueue<Integer> pq= new PriorityQueue<>(Collections.reverseOrder());
+
+        //add all the frequency values into pq 
+        pq.addAll(map.values());
+
+        //find the max frequency
+        int maxFreq= pq.poll(); // polls highest frequency by priority 
+
+        //total idle time is the maxFrequency of a task * time units n of cooldown 
+        int totalIdleTime=(maxFreq-1) * n;
+
+        //Looping through all the frequencies 
+        while(!pq.isEmpty()){
+            //find current frequency
+            int currentFreq= pq.poll();
+
+            //if it is equal to max frequency then we need to add 1 since we to consider last task
+            //Example A -> B -> Idle -> A -> B -> Idle -> A -> B (this B has to be considered)
+            if(maxFreq == currentFreq){
+                totalIdleTime-=currentFreq;
+                totalIdleTime+=1;
+            }else{
+                //else we just keep subtracting idle time
+                totalIdleTime-=currentFreq;
+            }
+        }
+
+        //if its greater than 0 then add it to tasks.length 
+        if(totalIdleTime >0){
+            return totalIdleTime + tasks.length;
+        }else{
+            return tasks.length;
+        }
+
+    }
+}

LeetCode/Grind169/Heaps/TaskScheduler_621.java

@@ -0,0 +1,9 @@
+package Grind169.Heaps;
+
+public class TopKFrequentWords_692 {
+    public static void main(String[] args) {
+        
+    }
+
+    
+}

LeetCode/Grind169/Heaps/TopKFrequentWords_692.java

@@ -1,3 +1,4 @@
+package LeetcodeV1;
 
 
 //Definition for singly-linked list.

LeetCode/Add2Nums.java renamed to LeetCode/LeetcodeV1/Add2Nums.java

@@ -1,3 +1,4 @@
+package LeetcodeV1;
 
 
 /*

LeetCode/AddBinary.java renamed to LeetCode/LeetcodeV1/AddBinary.java

@@ -1,3 +1,4 @@
+package LeetcodeV1;
 public class ClimbingStairs {
 
     /*

LeetCode/Blind75HintsAndExplanations.txt renamed to LeetCode/LeetcodeV1/Blind75HintsAndExplanations.txt

@@ -1,3 +1,4 @@
+package LeetcodeV1;
 import java.util.Arrays;
 
 public class ConcatenationArr {

LeetCode/ClimbingStairs.java renamed to LeetCode/LeetcodeV1/ClimbingStairs.java

@@ -1,3 +1,4 @@
+package LeetcodeV1;
 public class FindPeakElementHigherThanElements {
     public static void main(String[] args) {
         int[] array= {5,10, 20,15};

LeetCode/ConcatenationArr.java renamed to LeetCode/LeetcodeV1/ConcatenationArr.java

@@ -1,3 +1,4 @@
+package LeetcodeV1;
 import java.util.LinkedList;
 /*
  * You are given an array of non-overlapping intervals intervals where intervals[i] = [starti, endi] represent the start and 

LeetCode/FindPeakElementHigherThanElements.java renamed to LeetCode/LeetcodeV1/FindPeakElementHigherThanElements.java

@@ -1,3 +1,4 @@
+package LeetcodeV1;
 import java.util.Comparator;
 import java.util.PriorityQueue;
 

LeetCode/InsertInterval.java renamed to LeetCode/LeetcodeV1/InsertInterval.java

@@ -1,3 +1,4 @@
+package LeetcodeV1;
 public class LengthOfLastWord {
     public static void main(String[] args) {
         System.out.println(lengthOfLastWord("Hello World"));

LeetCode/KclosestPointsToOrigin_Lt973.java renamed to LeetCode/LeetcodeV1/KclosestPointsToOrigin_Lt973.java

@@ -1,3 +1,4 @@
+package LeetcodeV1;
 import java.util.HashMap;
 
 public class LongestSubstringWithoutRepetitions {

LeetCode/LengthOfLastWord.java renamed to LeetCode/LeetcodeV1/LengthOfLastWord.java

@@ -1,3 +1,4 @@
+package LeetcodeV1;
 //Definition for a binary tree node.
 class TreeNode {
      int val;

LeetCode/LongestSubstringWithoutRepetitions.java renamed to LeetCode/LeetcodeV1/LongestSubstringWithoutRepetitions.java

@@ -1,3 +1,4 @@
+package LeetcodeV1;
 public class Lt142 {
     public static void main(String[] args) {
 

LeetCode/Lt100.java renamed to LeetCode/LeetcodeV1/Lt100.java

@@ -1,3 +1,4 @@
+package LeetcodeV1;
 import java.util.Arrays;
 
 public class Lt1470 {

LeetCode/Lt142.java renamed to LeetCode/LeetcodeV1/Lt142.java

@@ -1,3 +1,4 @@
+package LeetcodeV1;
 /*
  * Given the heads of two singly linked-lists headA and headB, 
  * return the node at which the two lists intersect. If the two linked lists have no intersection at all, return null.

LeetCode/Lt1470.java renamed to LeetCode/LeetcodeV1/Lt1470.java

@@ -1,3 +1,4 @@
+package LeetcodeV1;
 public class Lt2011 {
     public static void main(String[] args) {
         String[] operations={"X++","++X","--X","X--"};

LeetCode/Lt160.java renamed to LeetCode/LeetcodeV1/Lt160.java

@@ -1,3 +1,4 @@
+package LeetcodeV1;
 /*Remove linked list elements that have the same val and variable val */
 class ListNode {
     int val;

LeetCode/Lt2011.java renamed to LeetCode/LeetcodeV1/Lt2011.java

@@ -1,3 +1,4 @@
+package LeetcodeV1;
 import java.util.Arrays;
 import java.util.Scanner;
 

LeetCode/Lt203.java renamed to LeetCode/LeetcodeV1/Lt203.java

@@ -1,3 +1,4 @@
+package LeetcodeV1;
 import java.util.HashMap;
 
 public class Lt5 {

LeetCode/Lt2469.java renamed to LeetCode/LeetcodeV1/Lt2469.java

@@ -1,3 +1,4 @@
+package LeetcodeV1;
 import java.util.Arrays;
 
 public class MergeSortedArray {

LeetCode/Lt5.java renamed to LeetCode/LeetcodeV1/Lt5.java

@@ -1,3 +1,4 @@
+package LeetcodeV1;
 import java.util.Arrays;
 
 public class MoveZeroes_Lt283 {

LeetCode/MergeSortedArray.java renamed to LeetCode/LeetcodeV1/MergeSortedArray.java

@@ -1,3 +1,4 @@
+package LeetcodeV1;
 import java.util.Arrays;
 
 public class PlusOne {

LeetCode/MoveZeroes_Lt283.java renamed to LeetCode/LeetcodeV1/MoveZeroes_Lt283.java

@@ -1,3 +1,4 @@
+package LeetcodeV1;
 import java.util.Arrays;
 
 public class PlusOne2 {

LeetCode/PlusOne.java renamed to LeetCode/LeetcodeV1/PlusOne.java

@@ -1,3 +1,4 @@
+package LeetcodeV1;
 import java.util.ArrayList;
 import java.util.LinkedList;
 

LeetCode/PlusOne2.java renamed to LeetCode/LeetcodeV1/PlusOne2.java

@@ -1,3 +1,4 @@
+package LeetcodeV1;
 public class RichestCustomerWealth {
     public static void main(String[] args) {
         int[][] accounts= {{1,2,3},

LeetCode/ReverseLinkedList.java renamed to LeetCode/LeetcodeV1/ReverseLinkedList.java

@@ -1,3 +1,4 @@
+package LeetcodeV1;
 import java.util.Arrays;
 
 public class RunninSum {

LeetCode/RichestCustomerWealth.java renamed to LeetCode/LeetcodeV1/RichestCustomerWealth.java

@@ -1,3 +1,4 @@
+package LeetcodeV1;
 public class SearchInsertPosition {
     public static void main(String[] args) {
         int[] nums= {1,3,5,6};

LeetCode/RunninSum.java renamed to LeetCode/LeetcodeV1/RunninSum.java

@@ -1,3 +1,4 @@
+package LeetcodeV1;
 import java.util.Scanner;
 
 public class Sqrt {

LeetCode/SearchInsertPosition.java renamed to LeetCode/LeetcodeV1/SearchInsertPosition.java

@@ -1,3 +1,4 @@
+package LeetcodeV1;
 import java.util.Arrays;
 
 public class SquaresOfSortedArray_Lt977 {

LeetCode/Sqrt.java renamed to LeetCode/LeetcodeV1/Sqrt.java

@@ -1,3 +1,4 @@
+package LeetcodeV1;
 public class longestCommonPrefix {
     public static void main(String[] args) {
         String[] words= {"flower", "flight", "flow"};

LeetCode/SquaresOfSortedArray_Lt977.java renamed to LeetCode/LeetcodeV1/SquaresOfSortedArray_Lt977.java

@@ -1,3 +1,4 @@
+package LeetcodeV1;
 // You are given the heads of two sorted linked lists list1 and list2.
 // Merge the two lists in a one sorted list. The list should be made by splicing together the nodes of the first two lists.
 // Return the head of the merged linked list.

LeetCode/longestCommonPrefix.java renamed to LeetCode/LeetcodeV1/longestCommonPrefix.java

@@ -1,3 +1,4 @@
+package LeetcodeV1;
 public class palindromeNum{
     public static void main(String[] args){
         int num=121;

LeetCode/merge2sorterLists.java renamed to LeetCode/LeetcodeV1/merge2sorterLists.java

@@ -1,3 +1,4 @@
+package LeetcodeV1;
 import java.util.Arrays;
 
 public class removeDupsSorted2 {

LeetCode/palindromeNum.java renamed to LeetCode/LeetcodeV1/palindromeNum.java

@@ -1,3 +1,4 @@
+package LeetcodeV1;
 import java.util.Arrays;
 
 public class removeDupsSortedArray {