Merge pull request #203 from anishkumar127/v8

 code

Author: anishkumar127

Interview Ready Solution/Preparation 🔥/GFG/Tree/BST/BST - Recursion/Medium/Find a pair with given target in BST.md

@@ -0,0 +1,137 @@
+```java
+//{ Driver Code Starts
+//Initial Template for Java
+
+/*package whatever //do not write package name here */
+
+import java.io.*;
+import java.util.*;
+import java.math.*;
+
+class Node  
+{ 
+    int data; 
+    Node left, right; 
+   
+    public Node(int d)  
+    { 
+        data = d; 
+        left = right = null; 
+    } 
+}
+
+class GFG
+{
+    static Node buildTree(String str)
+    {
+        // Corner Case
+        if(str.length() == 0 || str.equals('N'))
+            return null;
+        String[] s = str.split(" ");
+        
+        Node root = new Node(Integer.parseInt(s[0]));
+        Queue <Node> q = new LinkedList<Node>();
+        q.add(root);
+        
+        // Starting from the second element
+        int i = 1;
+        while(!q.isEmpty() && i < s.length)
+        {
+              // Get and remove the front of the queue
+              Node currNode = q.remove();
+        
+              // Get the current node's value from the string
+              String currVal = s[i];
+        
+              // If the left child is not null
+              if(!currVal.equals("N")) 
+              {
+        
+                  // Create the left child for the current node
+                  currNode.left = new Node(Integer.parseInt(currVal));
+        
+                  // Push it to the queue
+                  q.add(currNode.left);
+              }
+        
+              // For the right child
+              i++;
+              if(i >= s.length)
+                  break;
+              currVal = s[i];
+        
+              // If the right child is not null
+              if(!currVal.equals("N")) 
+              {
+        
+                  // Create the right child for the current node
+                  currNode.right = new Node(Integer.parseInt(currVal));
+        
+                  // Push it to the queue
+                  q.add(currNode.right);
+              }
+              
+              i++;
+        }
+    
+        return root;
+    }
+    
+    public static void main(String args[]) throws IOException {
+    
+       BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        int t = Integer.parseInt(br.readLine().trim());
+        while(t>0)
+        {
+            String s = br.readLine();
+            Node root = buildTree(s);
+            
+            int target = Integer.parseInt(br.readLine().trim());
+            
+            Solution T = new Solution();
+            System.out.println(T.isPairPresent(root,target));
+            t--;
+        }
+    }
+}
+
+// } Driver Code Ends
+
+
+//User function Template for Java
+
+class Solution
+{
+    // root : the root Node of the given BST
+    // target : the target sum
+    private void inOrder(Node root, ArrayList<Integer>ans){
+        if(root==null) return;
+        
+        inOrder(root.left,ans);
+        ans.add(root.data);
+        inOrder(root.right,ans);
+    }
+    public int isPairPresent(Node root, int target)
+    {
+        
+        ArrayList<Integer> ans = new ArrayList<>();
+        
+        inOrder(root,ans);
+        // Write your code here
+        int s = 0;
+        int e = ans.size()-1;
+        while(s<=e){
+            int sum = ans.get(s) + ans.get(e);
+            if(sum==target) return 1;
+            else if(sum<target) s++;
+            else e--;
+        }
+        return 0;
+    }
+}
+
+
+```
+
+
+https://practice.geeksforgeeks.org/problems/find-a-pair-with-given-target-in-bst/1

Interview Ready Solution/Preparation 🔥/LeetCode/String/Medium/28. Find the Index of the First Occurrence in a String.md

@@ -0,0 +1,72 @@
+https://leetcode.com/problems/find-the-index-of-the-first-occurrence-in-a-string/
+
+
+# [28\. Find the Index of the First Occurrence in a String](https://leetcode.com/problems/find-the-index-of-the-first-occurrence-in-a-string/)
+
+## Description
+
+Difficulty: **Medium**  
+
+Related Topics: [Two Pointers](https://leetcode.com/tag/two-pointers/), [String](https://leetcode.com/tag/string/), [String Matching](https://leetcode.com/tag/string-matching/)
+
+
+Given two strings `needle` and `haystack`, return the index of the first occurrence of `needle` in `haystack`, or `-1` if `needle` is not part of `haystack`.
+
+**Example 1:**
+
+```
+Input: haystack = "sadbutsad", needle = "sad"
+Output: 0
+Explanation: "sad" occurs at index 0 and 6.
+The first occurrence is at index 0, so we return 0.
+```
+
+**Example 2:**
+
+```
+Input: haystack = "leetcode", needle = "leeto"
+Output: -1
+Explanation: "leeto" did not occur in "leetcode", so we return -1.
+```
+
+**Constraints:**
+
+*   1 <= haystack.length, needle.length <= 10<sup>4</sup>
+*   `haystack` and `needle` consist of only lowercase English characters.
+
+
+## Solution
+
+Language: **Java**
+
+```java
+class Solution {
+    public int strStr(String haystack, String needle) {
+        for(int i=0; i<haystack.length() - needle.length()+1; i++){  // 9-3+1 = 7; 
+            
+            if(haystack.charAt(i)==needle.charAt(0)){
+                if(haystack.substring(i,needle.length()+i).equals(needle)){
+                    return i;
+                }
+            }
+            
+        }
+        return -1;
+    }
+}
+​
+/*
+​
+haystack.length() - needle.length() + 1; // why ? because sad start from s. and if s in the end of the length of haystack. then how we can get the substring ? its give the error out of bound.
+​
+so we run till the haystack length and - needle length + 1.
+​
+​
+and now inside for loop we will check if haystack character match the first character of the needle.
+then we check the complete sentence of the needle using substring method. and we apply the substring method inside the haystack.
+and if it is equal then return the index.
+else not equal we check till the length. in the end we return the -1 as given the question requirements.
+​
+*/
+```
+

Interview Ready Solution/Preparation 🔥/LeetCode/Tree/Binary Search Tree/BST - Recursion/Medium/653. Two Sum IV - Input is a BST.md

@@ -0,0 +1,75 @@
+```java
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    private void inOrder(TreeNode root, ArrayList<Integer>ans){
+        if(root==null) return ;
+        
+        inOrder(root.left,ans);
+        ans.add(root.val);
+        inOrder(root.right,ans);
+    }
+    public boolean findTarget(TreeNode root, int k) {
+       ArrayList<Integer> ans = new ArrayList<>();
+        inOrder(root,ans);
+        
+        int s =0;
+        int e = ans.size()-1;
+        
+        while(s<e){
+            int sum = ans.get(s) + ans.get(e);
+            if(sum==k) return true;
+            else if(sum<k) s++;
+            else e--;
+        }
+        return false;
+    }
+
+}
+
+```
+
+```java
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+  HashSet<Integer> set = new HashSet<>();
+    public boolean findTarget(TreeNode root, int k) {
+      if(root==null) return false;
+        if(set.contains(k-root.val)){
+            return true;
+        }
+        else set.add(root.val);
+        
+        return findTarget(root.left,k) || findTarget(root.right,k);
+        
+    }
+
+}
+```