Monday, 24 May 2021

Heap Sort(max heap)

 public class HeapSortNew {

    public static void main(String[] args) {

        int[] arr = {4,1,7,2,3,8,10};

        int n= arr.length;


        for(int i=n/2-1;i>=0;i--){

            heapify(arr,n,i);

        }


        System.out.println(Arrays.toString(arr));



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

            swap(arr,i,0);

            heapify(arr,i,0);

        }

        System.out.println(Arrays.toString(arr));




    }


    static void heapify(int[] arr, int n, int i){

        int l = 2*i+1;

        int r = 2*i+2;


        int largest = i;



        if(l<n){

            if(arr[l]>arr[largest]){

                largest = l;

            }

        }


        if(r<n){

            if(arr[r]>arr[largest]){

                largest = r;

            }

        }


        //if value get updated

        if(largest!=i){

            swap(arr,i,largest);

            heapify(arr,n,largest);

        }


    }


    static void swap(int[] arr, int i, int j){

        int temp = arr[i];

        arr[i]  =arr[j];

        arr[j]=temp;

    }


}


output:
[10, 3, 8, 2, 1, 4, 7]
[1, 2, 3, 4, 7, 8, 10]he

Find kth largest element in array in java using MaxHeap

 public class FIndKthLargestEmement {

    public static void main(String[] args) {

        int[] arr = {4,1,7,2,3,8,10};

        int n= arr.length;


        for(int i=n/2-1;i>=0;i--){

            heapify(arr,n,i);

        }


        System.out.println(Arrays.toString(arr));


        int k = 2;

//run the loop k times from last index , move root element to ith and heapify the array to maintain maxheap 

        for(int i=n-1;i>=n-k;i--){

            swap(arr,i,0);

            heapify(arr,i,0); //i due to don't like to incluede already sorted element

        }

        System.out.println(Arrays.toString(arr));

        System.out.println(arr[n-k]);



    }


    static void heapify(int[] arr, int n, int i){

        int l = 2*i+1;

        int r = 2*i+2;


        int largest = i;



        if(l<n){

            if(arr[l]>arr[largest]){

                largest = l;

            }

        }


        if(r<n){

            if(arr[r]>arr[largest]){

                largest = r;

            }

        }


        //if value get updated

        if(largest!=i){

            swap(arr,i,largest);

            heapify(arr,n,largest);

        }


    }


    static void swap(int[] arr, int i, int j){

        int temp = arr[i];

        arr[i]  =arr[j];

        arr[j]=temp;

    }


}


output:
[10, 3, 8, 2, 1, 4, 7]
[7, 3, 4, 2, 1, 8, 10]
8

Sunday, 16 May 2021

Minimum Subarray Of Sumk

Given an array of positive integers nums and a positive integer target, return the minimal length of a contiguous subarray [numsl, numsl+1, ..., numsr-1, numsr] of which the sum is greater than or equal to target. If there is no such subarray, return 0 instead.


Input: target = 7, nums = [2,3,1,2,4,3]
Output:

Explanation: The subarray [4,3] has the minimal length under the problem constraint. 


public class MinimumSubarrayOfSumk {

    public static void main(String[] args) {

        int[] arr = {

                10,5,13,4,8,4,5,11,14,9,16,10,20,8};

        int target  =80;


        int i =-1;

        int j=-1;

        int sum = 0;

        int length = Integer.MAX_VALUE;

        while (true){

        boolean f1 = false,f2 = false;

            while (i<arr.length-1 && sum<target){

                f1 = true;

                i++;

                sum+=arr[i];

                if(sum>=target){

                    length = Math.min(length,i-j);

                    break;

                }

               // f1 = true;

            }


            while (j<i && sum>=target){

                f2 = true;

                j++;

                sum-=arr[j];

                if(sum>=target){

                    length = Math.min(length,i-j);

                }else{

                    break;

                }

               // f2 = true;


            }


            if(!f1 && !f2){

                break;

            }


        }


        System.out.println(length);



    }

}


Result: 6

Permutation in String

 Given two strings s1 and s2, write a function to return true if s2 contains the permutation of s1. In other words,

one of the first string’s permutations is the substring of the second string.

For example:

Input: s1 = "ab" s2 = "eidbaooo"

Output: True

Explanation: s2 contains one permutation of s1 ("ba").


public class PermutationInString {

    public static void main(String[] args) {

        boolean bool = checkInclusion();

        System.out.println(bool);

    }


    private static boolean checkInclusion(){

        String str1 = "eidbaooo";

        String str2 = "ab";


        Map<Character, Integer> map2 = new HashMap<>();

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

            char ch = str2.charAt(i);

            map2.put(ch,map2.getOrDefault(ch,0)+1);

        }


        Map<Character, Integer> map1 = new HashMap<>();

        int i = -1;

        int j=-1;

        int desireCount = str2.length();

        int mCount = 0;

        boolean resultFlag= false;

        while (true){

            boolean f1 = false,f2 = false;


            while (i<str1.length()-1 && mCount<desireCount){

                f1= true;

                i++;

                char ch = str1.charAt(i);


                map1.put(ch,map1.getOrDefault(ch,0)+1);


                if(map1.getOrDefault(ch,0)<=map2.getOrDefault(ch,0)){

                    mCount++;

                }


                if(mCount==desireCount){

                    break;

                }


            }


            while (j<i && mCount==desireCount){

                f2 = true;

                j++;

                if(i+1-j==desireCount){ //check if size of string is same as desired count

                    //System.out.println("result");

                    resultFlag = true;

                    break;

                }

                char ch = str1.charAt(j);

                Integer val =map1.get(ch);

                if(val>1){

                    map1.put(ch,map1.get(ch)-1);

                }else{

                    map1.remove(ch);

                }


                if(map1.getOrDefault(ch,0)<map2.getOrDefault(ch,0)){

                    mCount--;

                }


                if(mCount<desireCount){

                    break;

                }


            }


            if(resultFlag){

                System.out.println("result found");

                break;

            }

            if(!f1 && !f2){

                System.out.println("result not found");


                break;

            }



        }


        if(resultFlag){

            //System.out.println("result found");

            return true;

        }else{

            //System.out.println("not found");

            return false;

        }


     //   return true;


    }

}


Result:true

Minimum Window Substring

Given a string S and a string T, find the minimum window in S which will contain all the characters in T in

complexity O(n).

For example, S = "ADOBECODEBANC", T = "ABC", Minimum window is "BANC". 

//we need to find smallest substring from str1 if all character of str2 available in substring

public class MinimumWindowSubstring {

    public static void main(String[] args) {

        String str1 = "dbaecbbabdcaafbddcabgba";

        String str2 = "abbcdc";


       // String str1 = "a";

        //String str2 = "aa";

        int i = -1;

        int j = -1;


        //preparing a frequncy map of string 2

        Map<Character,Integer> map2 = new HashMap<>();

        for(int k = 0;k<str2.length();k++){

            char ch = str2.charAt(k);

            map2.put(ch, map2.getOrDefault(ch,0)+1);

        }


        Map<Character,Integer> map1 = new HashMap<>();

        int mCount = 0;

        int desireCount = str2.length();

        String result = "";


        while (true){

            boolean f1 = false,f2 = false;


            //we need to run till my current count  less then desired count(str2 count)

            while (i<str1.length()-1 && mCount<desireCount ){


                i++;

                char ch = str1.charAt(i);

                map1.put(ch,map1.getOrDefault(ch,0)+1);


                if(map1.getOrDefault(ch,0)<=map2.getOrDefault(ch,0)){

                    mCount++;

                }


                 f1 = true;


            }



            //we need to run this till we are getting my current count equal to desired count

            while (j<i && mCount==desireCount) {

                f2 = true;

                j++;

                String potentialAns = str1.substring(j,i+1);

                if(result.length()==0 || potentialAns.length()<result.length()){

                    result = potentialAns;

                }

                char ch = str1.charAt(j);

                Integer val = map1.get(ch);

                if(val>1){

                    map1.put(ch,map1.get(ch)-1);

                }else{

                    map1.remove(ch);

                }


                if(map1.getOrDefault(ch,0)<map2.getOrDefault(ch,0)){

                    mCount--;


                }

                 f2 = true;


            }


            if(!f1 && !f2){

                break;

            }

        }

        System.out.println(result);



    }

}


Result: cbbabdc


Longest Substring with K Distinct Characters

 Given "abcadcacacaca" and 3, it returns "cadcacacaca".


public class LongestSubstringExactKDistinctElement {

    public static void main(String[] args) {

        String str = "aabcbcdbca";

        int i =-1;

        int j =-1;


        int length = 0;

        int k =2;

        Map<Character,Integer> map = new HashMap<>();

        while (true){



            boolean f1 = false,f2 = false;

            //acquire


            while (i<str.length()-1){

                f1 = true;

                i++;

                char ch = str.charAt(i);

                if(map.containsKey(ch)) {

                    map.put(ch, map.get(ch)+1);

                }else{

                    map.put(ch,1);

                }


                if(map.size()==k){

                    length = Math.max(length,i-j);

                }else if(map.size()>k){

                    break;

                }

            }




            //release


            while (j<i){

                f2 = true;

                j++;

                char ch = str.charAt(j);

                Integer val = map.get(ch);

                if(val==1){

                    map.remove(ch);

                }else{

                    map.put(ch,map.get(ch)-1);

                }


                if(map.size()==k){

                    Math.max(length,i-j);

                    break;

                }else if(map.size()>k){

                    continue;

                }

            }

            if(!f1 && !f2){

                break;

            }

        }

        System.out.println(length);

    }

}

Result: 4



Longest Substring with At Most K Distinct Characters

Given a string, find the longest substring that contains only two unique characters. For example, given "abcbbb-

bcccbdddadacb", the longest substring that contains 2 unique character is "bcbbbbcccb".


//maximum k distict allowed

public class LongestSubstringMostKDisinctChar {

    public static void main(String[] args) {

        String str = "ddacbbaccdedacebb";

        int i = -1;

        int j =-1;

        Map<Character, Integer> map = new HashMap<>();

        int length = 0;

        int k  = 3;


        while (true){

            boolean f1= false, f2 = false;

            //acquire

            while (i<str.length()-1){

                f1 = true;

                i++;

                char ch = str.charAt(i);

                if(map.containsKey(ch)){

                    map.put(ch,map.get(ch)+1);

                }else{

                    map.put(ch,1);

                }


                if(map.size()<=k){

                    length = Math.max(length,i-j);

                }else {

                    break;

                }


            }


            while (j<i){

                f2 = true;

                j++;


                char ch = str.charAt(j);

                Integer val = map.get(ch);

                if(val>1){

                    map.put(ch,map.get(ch)-1);

                }else{

                    map.remove(ch);

                }


                if(map.size()==k){

                    length = Math.max(length,i-j);

                    break;

                }


            }


            if(!f1 && !f2){

                break;

            }

            //release

        }

        System.out.println(length);



    }

}


Result: 7

Longest Substring Without Repeating Characters

 Given a string, find the length of the longest substring without repeating characters. For example, the longest

substring without repeating letters for "abcabcbb" is "abc", which the length is 3. For "bbbbb" the longest substring

is "b", with the length of 1.


public class LongestSubstringWithoutRepeatingchar2 {

    public static void main(String[] args) {

        String str = "abcabcbd";

       // String str = "";

        int i = -1;

        int j = -1;

        Map<Character, Integer> map = new HashMap<>();

        int len = 0;


        while (true){

            boolean f1 = false, f2 = false;

            while (i<str.length()-1) {

                f1 = true;

                i++;

                char ch = str.charAt(i);

                if (map.containsKey(ch)) {

                    map.put(ch, map.get(ch) + 1);

                    break;

                } else {

                    map.put(ch, 1);

                    len = Math.max(len, i - j);

                }

            }


            while (j<i){

                f2 = true;

                j++;

                char ch = str.charAt(j);

                Integer val = map.get(ch);


                if(val>=2){

                    map.put(ch,map.get(ch)-1);

                    len = Math.max(len,i-j);

                    break;

                }else{

                    map.remove(ch);

                }

            }

            if(!f1 && !f2){

                break;

            }


        }


        System.out.println(len);




       // System.out.println(len);

    }

}


Result: 3

Maximum Product Subarray

 Find the contiguous subarray within an array (containing at least one number) which has the largest product.

For example, given the array [2,3,-2,4], the contiguous subarray [2,3] has the largest product = 6.


public class MaximumProductSubArray {

    public static void main(String[] args) {

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


        int result = arr[0];

        int max = arr[0];

        int min = arr[0];


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

          int  tempMax = Math.max(arr[i], Math.max(max*arr[i],min*arr[i]));

          min = Math.min(arr[i], Math.min(max*arr[i],min*arr[i]));

          max = tempMax;


          result = Math.max(result,max);


        }


        System.out.println(result);


    }

}


Result:8

Maximum Subarray

 Find the contiguous subarray within an array (containing at least one number) which has the largest sum.

For example, given the array [ − 2,1, − 3,4, − 1,2,1, − 5,4], the contiguous subarray [4, − 1,2,1] has the largest sum =

6.


public class MaximumSumSubarray {

    public static void main(String[] args) {

        int[] arr = {4,3,-2,6,-14,7,-1,4,5,7,-10,2,9,-10,-5,-9,6,1};


        int maxSum =Integer.MIN_VALUE;

        int tempSum = 0;

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

            tempSum+=arr[i];


            if(tempSum<arr[i]){

                tempSum = arr[i];

            }

            maxSum = Math.max(maxSum,tempSum);

        }

        System.out.println(maxSum);

    }

}


Result: 23

Subarray Sum Equals K

 Given an array of integers and an integer k, find the total number of continuous subarrays whose sum equals to

k.

Example 1:

Input:nums = [1,1,1], k = 2 Output: 2

Note that empty array is not considered as a subarray.


public class CountSubarraySumEqualsK {

    public static void main(String[] args) {


        int arr[] = {3,9,-2,4,1,-7,2,6,-5,8,-3,-7,6,2,1};

        //int arr[] = {1,1,2};

        Map<Integer,Integer> map= new HashMap<>();

        int sum = 0;

        int count = 0;

        int k = 5;

       // int k =2;

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

            sum+=arr[i];


            if(sum==k){

                count++;

            }


            int diff = sum-k;


            if(map.containsKey(diff)){

                count = count + map.get(diff);

            }


            if(map.containsKey(sum)){

                map.put(sum,map.get(sum)+1);

            }else{

                map.put(sum,1);

            }


        }


        System.out.println(count);

    }

}



Result: 7

Maximum Size Subarray Sum Equals k

 Given an array nums and a target value k, find the maximum length of a subarray that sums to k. If there isn’t

one, return 0 instead.

Note: The sum of the entire nums array is guaranteed to fit within the 32-bit signed integer range.

Example 1: Given nums = [1, -1, 5, -2, 3], k = 3, return 4. (because the subarray [1, -1, 5, -2] sums to 3 and is the

longest)


public class MaxSizeSubArraySumK {

    public static void main(String[] args) {

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

        int k = 3;

        int max = 0;

        int sum = 0;

        Map<Integer, Integer> map = new HashMap<>();

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

            sum+=arr[i];


            if(sum==k){

                max = Math.max(max,i);

            }


            int diff = sum-k;


            if(map.containsKey(diff)){

                max= Math.max(max,i-map.get(diff));

            }

            if(!map.containsKey(sum)){

                map.put(sum,i);

            }


        }


        System.out.println(max);

    }


result: 8

Sunday, 2 May 2021

Group Shifted Strings

 


import java.util.*;


//https://www.youtube.com/watch?v=uEXJSRLqoKY&t=54s

public class GroupShiftedStrings {

    public static void main(String[] args) {

        String arr[] = {"abc","bcd","acef","xyz","az","ba","a","z","pqr","ace","jln"};

        List<List<String>> result = groupStrings(arr);

        System.out.println(result);

    }


    private static List<List<String>> groupStrings(String[] arr) {

        Map<String, List<String>> map = new HashMap<>();


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

            char[] charArr = arr[i].toCharArray();

            String key = "";

            if(charArr.length==1){

               key = "#";

            }else{

                for(int j=1; j<charArr.length;j++){

                    int diff  = (int)(charArr[j]-charArr[j-1]);

                    if(diff<0){

                        diff = diff+26;

                    }

                    key  = key + diff+"#";

                }

            }

            List<String> list = null;

            if(map.containsKey(key)){

               list = map.get(key);

            }else{

                list = new ArrayList<>();

            }

            list.add(arr[i]);

            map.put(key,list);


        }


        System.out.println(map);

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

        map.forEach((k,v)-> Collections.sort(v));


        result.addAll(map.values());


        return result;

    }

}



output:

{25#=[az, ba], 1#1#=[abc, bcd, xyz, pqr], 2#2#1#=[acef], #=[a, z], 2#2#=[ace, jln]}

[[az, ba], [abc, bcd, pqr, xyz], [acef], [a, z], [ace, jln]]

Saturday, 1 May 2021

HIndex || Sorted Array

 //sorted arr

public class HIndex2 {

    public static void main(String[] args) {

        int[] arr  = {0,1,3,5,6};

        int start = 0;

        int end = arr.length-1;

        int n = arr.length;


        if(n==0){

            System.out.println(0);

            return;

        }


        if(n==1){

            if(arr[0]==0){

                System.out.println(0);

            }else{

                System.out.println(1);

            }

            return;

        }


        while (start<=end){

            int mid = start+(end-start)/2;

            if(arr[mid]==n-mid){

                System.out.println(n-mid);

               return;

            }else if(arr[mid]>n-mid){

                end = mid-1;

            }else{

                start = mid+1;

            }

        }

        System.out.println(n-start);



    }

}


HIndex

 


//https://www.youtube.com/watch?v=fVAR6SiATgI

public class HIndex {

    public static void main(String[] args) {

        //int arr[] = {3,1,2,3,2};//out put 2

        int arr[] = {3,6,7,8,9}; //output 4 //bucket {0,0,0,1,0,4}

        int bucket[] = new int[arr.length+1];

        int n = arr.length;


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

            if(arr[i]>=n){

                bucket[n]++;

            }else{

                bucket[arr[i]]++;

            }

        }


        int count = 0;

        for(int i= bucket.length-1;i>=0;i--){

            count = count+bucket[i];

            if(count>=i){

                System.out.println(i);

                break;

            }

        }


    }

}


links for Data Structure

  1) 𝐁𝐞𝐜𝐨𝐦𝐞 𝐌𝐚𝐬𝐭𝐞𝐫 𝐢𝐧 𝐋𝐢𝐧𝐤𝐞𝐝 𝐋𝐢𝐬𝐭:  https://lnkd.in/gXQux4zj 2) 𝐀𝐥𝐥 𝐭𝐲𝐩𝐞𝐬 𝐨𝐟 𝐓𝐫𝐞𝐞 𝐓𝐫𝐚𝐯𝐞𝐫𝐬𝐚𝐥𝐬...