CodeWithYash

 class Solution {     public int missingNumber(int[] nums) {         int n=nums.length;         int max=0;         int sum=0;                  for(int i=0;i<n;i++){             sum=sum+nums[i];             if(nums[i]>max){                 max=nums[i];             }         }         int m=max;         int min=0;         boolean flag=false;                  for(int i=0;i<n;i++){              if(nums[i]<min){                 min=nums[i];             }                                              }                  for(int i=0;i<n;i++){              if(nums[i]==0){                 flag=true;                  break;             }             else{                 flag=false;             }         }                  /*System.out.println(" max digit is: "+max);         System.out.println("Tentaive max sum should be: "+(m*(m+1))/2);         System.out.println("Sum of series is: "+sum);         System.out.println("Missing number is : "+((m

 class Solution {     public int firstUniqChar(String s) {   LinkedHashMap<Character,Integer> map=new LinkedHashMap<Character,Integer>();         for(int i=0;i<s.length();i++){             if(map.containsKey(s.charAt(i))){                 map.put(s.charAt(i),map.get(s.charAt(i))+1);             }             else{                 map.put(s.charAt(i),1);             }         }         char a='\0';         //map.forEach((k,v)->System.out.println(k+"->"+v));                  for (Map.Entry<Character, Integer> entry : map.entrySet()) {             char key = entry.getKey();             int tab = entry.getValue();             if(tab==1){                 a=key;                 break;             }                    }         return s.indexOf(a);                               } } Approach: Here first we will store all the characters and their frequency in LinkedHashMap. [Reason for using linked hashmap is that insertion order will be preserved. T

  class  StoreStack{      int  data;      int  val; } public   class  Solution {      public   int  largestRectangleArea( int [] arr) {          int  n=arr.length;         Stack<StoreStack> stack1= new  Stack<StoreStack>();          Stack<StoreStack> stack2= new  Stack<StoreStack>();                   ArrayList<Integer>aa= new  ArrayList<Integer>();         ArrayList<Integer>ab= new  ArrayList<Integer>();         ArrayList<Integer>ac= new  ArrayList<Integer>();                  StoreStack obj[]= new  StoreStack[n];                   for ( int  i= 0 ;i<n;i++){             obj[i]= new  StoreStack();             obj[i].data=arr[i];             obj[i].val=i;                      }                   for ( int  i= 0 ;i<n;i++){              if (stack1.isEmpty()){                 aa.add(- 1 );             }              else {                  if (stack1.peek().data<arr[i]){                     aa.add(stack1.peek().val);     

 class Compute {          public long countOfElements(long arr[], long n, long x)     {         long count=0l;         for(int i=0;i<n;i++){             if(arr[i]<=x){                 count++;             }         }         return count;     } } TIME:O(N)[GFG Time: 0.7/3.5] SPACE:O(1)

 class StoreStack{ int val; int data; } class Solution {     //Function to calculate the span of stock’s price for all n days.          public static int[] calculateSpan(int arr[], int n)     {         ArrayList<Integer> aa=new ArrayList<Integer>();         StoreStack obj[]=new StoreStack[n];         Stack<StoreStack> stack=new Stack<StoreStack>();         for(int i=0;i<n;i++){ obj[i]=new StoreStack(); obj[i].val=arr[i]; obj[i].data=i; } /*for(int i=0;i<n;i++){ System.out.println(obj[i].val+" "+obj[i].data); }*/ for(int i=0;i<n;i++){ if(stack.isEmpty()){ aa.add(-1); } else{ if(stack.peek().val>arr[i]){ aa.add(stack.peek().data); } else{ while(!stack.isEmpty() && stack.peek().val<=arr[i]){ stack.pop(); } if(stack.isEmpty()){ aa.add(-1); } else{ aa.add(stack.peek().data); } } } sta

 class Solution {     public int[] nextLargerNodes(ListNode head) {         ArrayList<Integer> aa=new ArrayList<Integer>();         Stack<Integer> stack=new Stack<Integer>();                           ListNode temp=head;                 while(temp!=null){             aa.add(temp.val);             temp=temp.next;         }         Collections.reverse(aa);                  System.out.println(aa);                  int ab[]=new int[aa.size()];                  for(int i=0;i<aa.size();i++){             if(stack.isEmpty()){                 ab[i]=(0);                              }             else{                 while(!stack.isEmpty() && stack.peek()<=aa.get(i)){                     stack.pop();                 }                 if(stack.isEmpty()){                     ab[i]=(0);                 }                 else{                     ab[i]=(stack.peek());                 }                              }             stack.push(aa.get(i));         }

 Approach 1: Using ArrayList                  ArrayList<Long> aa=new ArrayList<Long>();         Stack<Long>stack=new Stack<Long>();         for(int i=n-1;i>-1;i--){             if(stack.isEmpty()==true){                 aa.add(Long.valueOf(-1));             }             else{                 if(stack.peek()>arr[i]){                     aa.add(stack.peek());                 }                 else{                     while(!stack.isEmpty() && stack.peek()<=arr[i]){                         stack.pop();                     }                     if(stack.isEmpty()==true){                         aa.add(Long.valueOf(-1));                     }                     else{                         aa.add(stack.peek());                     }                 }                              }             stack.push(arr[i]);         }         Collections.reverse(aa);         long arr1[]=new long[aa.size()];         for(int i=0;i<aa.size();i++){            

 For Both Questions Code Is Same: MINIMUM DELETIONS: class Solution{     static int minimumNumberOfDeletions(String s1) {         StringBuilder sb=new StringBuilder();         sb.append(s1);         String s2=sb.reverse().toString();         int n=s2.length();                  int t[][]=new int[n+1][n+1];                  for(int i=0;i<n+1;i++){             for(int j=0;j<n+1;j++){                 if(i==0 || j==0){                     t[i][j]=0;                 }             }         }                  for(int i=1;i<n+1;i++){             for(int j=1;j<n+1;j++){                 if(s1.charAt(i-1)==s2.charAt(j-1)){                     t[i][j]=1+t[i-1][j-1];                 }                 else{                     t[i][j]=Integer.max(t[i-1][j],t[i][j-1]);                 }             }         }                  return n-t[n][n];     } } *********************************************************************************** FORM PALINDROME: class Solution{     static int countM

 class Solution {     public int longestPalinSubseq(String s1)     {         StringBuilder sb=new StringBuilder();         sb.append(s1);         String s2=sb.reverse().toString();         int n=s1.length();         return cal(s1,s2,n);     }          public int cal(String a, String b, int n){         int t[][]=new int[n+1][n+1];          for(int i=0;i<n+1;i++){ for(int j=0;j<n+1;j++){ if(i==0 || j==0){ t[i][j]=0; } } } for(int i=01;i<n+1;i++){ for(int j=01;j<n+1;j++){ if(a.charAt(i-1)==b.charAt(j-1)){ t[i][j]=1+t[i-1][j-1]; } else{ t[i][j]=Integer.max(t[i-1][j],t[i][j-1]); } } } return t[n][n];     }                          } TIME:O(N*N)[Geeks For Geeks Time: 0.2/1.3] SPACE:O(N*N) *********************************************************************************** LEETCODE: class Solution {     public int longestPalindromeSubseq(String s) {                  int n=s.length();         int t[

 import java.util.Scanner; class Solve{ public int cal(String a, String b, int n){ int t[][]=new int[n+1][n+1]; for(int i=0;i<n+1;i++){ for(int j=0;j<n+1;j++){ if(i==0 || j==0){ t[i][j]=0; } } } for(int i=01;i<n+1;i++){ for(int j=01;j<n+1;j++){ if(a.charAt(i-1)==b.charAt(j-1)){ t[i][j]=1+t[i-1][j-1]; } else{ t[i][j]=Integer.max(t[i-1][j],t[i][j-1]); } } } return t[n][n]; } } class LongestPaindromicSubsequence{ public static void main(String arg[]){ Scanner sc=new Scanner(System.in); String s=sc.next(); StringBuilder sb=new StringBuilder(); sb.append(s); String b=(sb.reverse().toString()); int n=s.length(); Solve obj=new Solve(); int c=obj.cal(s,b,n); System.out.println(c); } }

 class Solution { public int minOperations(String s1, String s2)  {      int n=s1.length();     int m=s2.length();     int p=cal(s1,s2,n,m);     //System.out.println(p);     return p; }  public int cal(String x, String y, int n, int m){     int t[][]=new int[n+1][m+1];     for(int i=0;i<n+1;i++){         for(int j=0;j<m+1;j++){             if(i==0 ||j==0){                 t[i][j]=0;             }         }     }          for(int i=1;i<n+1;i++){         for(int j=1;j<m+1;j++){             if(x.charAt(i-1)==y.charAt(j-1)){                 t[i][j]=t[i-1][j-1]+1;             }             else{                 t[i][j]=Integer.max(t[i-1][j],t[i][j-1]);             }         }     }          int c=t[n][m];          int del=n-c;     int ins=m-c;          return del+ins;      } } APPROACH: Here we have to convert String a to String b. The insertion and deletion from the string will be made of those ch

 class Solution {     //Function to find the length of the shortest common supersequence of two strings.     public static int shortestCommonSupersequence(String x,String y,int n,int m)     {          int t[][]=new int[n+1][m+1];                  for(int i=0;i<n+1;i++){             for(int j=0;j<m+1;j++){                 if(i==0 || j==0){                     t[i][j]=0;                 }             }         }                  for(int i=1;i<n+1;i++){             for(int j=1;j<m+1;j++){                 if(x.charAt(i-1)==y.charAt(j-1)){                     t[i][j]=t[i-1][j-1]+1;                 }                 else{                     t[i][j]=Integer.max(t[i][j-1],t[i-1][j]);                 }             }         }                  int c=t[n][m];                  return n+m-c;              } } TIME:O(N*M) [Nested Arrays] [Geeks For Geeks Time:0.3/1.5] SPACE:O(N*M)[2D array is used] Thanks for Reading.😇 "Share further to increase knowledge treasure.😊"

 import java.util.Scanner; class LongestCommonSequencePrint{ public static String cal(String x, String y, int n ,int m){ int t[][]=new int[n+1][m+1]; for(int i=0;i<n+1;i++){ for(int j=0;j<m+1;j++){ if(n==0 || m==0){ t[i][j]=0; } } } for(int i=01;i<n+1;i++){ for(int j=01;j<m+1;j++){ if(x.charAt(i-1)==y.charAt(j-1)){ //t[n][m]=1+cal(x,y,i-1,j-1); //t[i][j]=1+cal(x,y,i-1,j-1); t[i][j]=t[i-1][j-1]+1; } else{ //t[n][m]=Integer.max((cal(x,y,i-1,j)),cal(x,y,i,j-1)); //t[i][j]=Integer.max((cal(x,y,i-1,j)),cal(x,y,i,j-1)); t[i][j]=Integer.max(t[i][j-1],t[i-1][j]); } } } String s=print(x,y,n,m,t); return s; } public static String print(String x, String y, int n, int m, int[][]t){ StringBuilder sb=new StringBuilder(); int i=n; int j=m; while(i>0 && j>0){ if(x.charAt(i-1)==y.charAt(j-1)){ sb.append(x.char

 LeetCode: class Solution {     public int longestCommonSubsequence(String a, String b) {       int n=a.length();         int m=b.length();         int t[][]=new int[n+1][m+1];         for(int i=0;i<n+1;i++){             for(int j=0;j<m+1;j++){                 if(i==0 || j==0){                     t[i][j]=0;                 }             }         }         for(int i=1;i<n+1;i++){             for(int j=1;j<m+1;j++){                 if(a.charAt(i-1)==b.charAt(j-1)){                     t[i][j]=t[i-1][j-1]+1;                 }                 else{                     t[i][j]=Integer.max(t[i-1][j],t[i][j-1]);                 }             }         }         return t[n][m];                             } } TIME:O(N*M)[2 loops ie. nested][LeetCode Time: 18ms faster than 44.87% ] SPACE:O(N*M)[Due to usage of 2d matrix][LeetCode Memory: 43.1 MB less than 36.27%] For printing LCS refer to:  https://yashboss116.blogspot.com/2021/10/printing-longest-common-subsequence.html And inste

 import java.util.Scanner; class KnapsackSolve{ public int knapsack(int[] arr, int n, int sum){ int t[][]=new int[n+1][sum+1]; for(int i=0;i<n+1;i++){ for(int j=0;j<sum+1;j++){ t[i][j]=-1; } } if(n==0 && sum==0){ return 1; } if(n==0 && sum!=0){ return 0; } if(sum==0){ return 1; } if(t[n][sum]!=-1){ return t[n][sum];  } else{ if(arr[n-1]>sum){ t[n][sum]=knapsack(arr,n-1,sum); } else{ t[n][sum]=Integer.max(knapsack(arr,n-1,sum),knapsack(arr,n-1,sum-arr[n-1])); } return t[n][sum]; } } } class EqualSumPartitionMemoize{ public static void main(String arg[]){ Scanner sc=new Scanner(System.in); int n=sc.nextInt(); int arr[]=new int[n]; for(int i=0;i<n;i++){ arr[i]=sc.nextInt(); } int sum=0; for(int i=0;i<n;i++){ sum=sum+arr[i]; } if(sum%2!=0){ System.out.println("false"); System.out.pr

 import java.util.Scanner; class KnapsackSolve{ public boolean knapsack(int[] arr, int n, int sum){ if(n==0 && sum==0){ return true; } if(n==0 && sum!=0){ return false; } if(sum==0){ return true; } else{ if(arr[n-1]>sum){ return knapsack(arr,n-1,sum); } else{ return (knapsack(arr,n-1,sum) || knapsack(arr,n-1,sum-arr[n-1])); } } } } class EqualSumPartitionRecursive{ public static void main(String arg[]){ Scanner sc=new Scanner(System.in); int n=sc.nextInt(); int arr[]=new int[n]; for(int i=0;i<n;i++){ arr[i]=sc.nextInt(); } int sum=0; for(int i=0;i<n;i++){ sum=sum+arr[i]; } if(sum%2!=0){ System.out.println("false"); System.out.println("Not possible"); } else{ KnapsackSolve obj1=new KnapsackSolve(); boolean c=obj1.knapsack(arr,n,sum/2); System.out.println(c); } } }

  public   class  Solution {      public   int  solve( int [] arr,  int  sum) {                   //Base Condition          int  n=arr.length;          boolean  t[][]= new   boolean [n+ 1 ][sum+ 1 ];              int  a= 0 ;              for ( int  i= 0 ;i<n+ 1 ;i++){                  for ( int  j= 0 ;j<sum+ 1 ;j++){                      if (i== 0 ){                         t[i][j]= false ;                                                                      }                      if (j== 0 ){                         t[i][j]= true ;                                                                       }                 }             }                                        for ( int  i= 1 ;i<n+ 1 ;i++){                  for ( int  j= 1 ;j<sum+ 1 ;j++){                      if (arr[i- 1 ]>j){                         t[i][j]=t[i- 1 ][j];                     }                      else {                         t[i][j]=(t[i- 1 ][j]) || (t[i- 1 ][j-arr[i- 1 ]]);             

 import java.util.Scanner; class KnapsackSolve{ public boolean knapsack(int[] arr, int n, int sum){ //Base Condition if(n==0){ return false; } else if(sum==0 && n!=0){ return true; } else if(sum==0 && n==0){ return true; } boolean t[][]=new boolean[n+1][sum+1]; for(int i=1;i<n+1;i++){ for(int j=1;j<sum+1;j++){ t[i][j]=false; } } if(t[n][sum]!=false){ return t[n][sum]; } else{ if(arr[n-1]>sum){ t[n][sum]=knapsack(arr,n-1,sum); } else{ t[n][sum]=knapsack(arr,n-1,sum) || knapsack(arr,n-1,sum-arr[n-1]); } return t[n][sum]; } } } class SubsetSumMemoize{ public static void main(String arg[]){ Scanner sc=new Scanner(System.in); int n=sc.nextInt(); int arr[]=new int[n]; for(int i=0;i<n;i++){ arr[i]=sc.nextInt(); } int sum=sc.nextInt(); KnapsackSolve obj1=new KnapsackSolve(); boole