Merge branch 'main' of https://github.com/Yashi11/data-structures-and-algorithms

Author: Yashi11

Arrays/Good_pairs.cpp

@@ -0,0 +1,71 @@
+/* Name : Abhinav kumar
+Github username : Abhinavcode13
+Repository name : data-structures-and-algorithms
+Problem :  Find Number of Good Pairs in Go
+Issue Number : #529
+Problem statement : Given an array of integers nums, return the number of good pairs.
+
+A pair (i, j) is called good if nums[i] == nums[j] and i < j.
+
+Example 1:
+
+Input: nums = [1,2,3,1,1,3]
+Output: 4
+Explanation: There are 4 good pairs (0,3), (0,4), (3,4), (2,5) 0-indexed.
+Example 2:
+
+Input: nums = [1,1,1,1]
+Output: 6
+Explanation: Each pair in the array are good.
+Example 3:
+
+Input: nums = [1,2,3]
+Output: 0
+
+Constraints:
+
+1 <= nums.length <= 100
+1 <= nums[i] <= 100
+
+Explanation of the below cpp code:
+
+This C++ program takes an integer n as input and then reads n integers from the standard input.
+It then creates a vector v to store the input integers and a map m to count the frequency of each input integer.
+Finally, the program computes the number of pairs of input integers that are equal and outputs this count to the standard output.
+
+The algorithm used to compute the count of pairs is based on the following observation:
+for each integer x that appears k times in the input vector, there are k*(k-1)/2 pairs of integers that are equal to x.
+This can be seen by choosing any two of the k occurrences of x, which can be done in k*(k-1)/2 ways.
+
+The program uses the map data structure to count the frequency of each integer in the input vector.
+It then iterates over the pairs (x,k) in the map and adds k*(k-1)/2 to a variable count. Finally, it outputs the value of count.
+
+Overall, this program has a time complexity of O(n log n) due to the use of the map data structure, which has a logarithmic time complexity for insertion and lookup operations.
+However, since the input size is limited to 10^5 integers, the program should run efficiently for typical input sizes.
+*/
+-------------------------------------------------------------------------//C++ code begins here---------------------------------------------------------------------------------
+//Array: Find Number of Good Pairs in Go
+
+#include <bits/stdc++.h>
+using namespace std;
+
+int main() {
+    int n;
+    cin>>n;
+    vector<int> v;
+    map<int,int> m;
+    for(int i=0;i<n;i++)
+    {
+        int x;
+        cin>>x;
+        v.push_back(x);
+        m[x]++;
+    }
+    int count = 0;
+    for(auto it:m)
+    {
+        count = count + (it.second-1)*(it.second)/2;
+    }
+    cout<<count<<endl;
+    return 0;
+}

Arrays/longest_peak.py

@@ -0,0 +1,47 @@
+"""
+Write a function that takes in an array of integers and returns the length of the longest peak
+in the array.A peak is defined as adjacent integers in the array that are strictly increasing
+until they reach a tip (the highest value in the peak), at which point they become strictly 
+decreasing. At least three integers are required to form a peak.
+"""
+
+
+
+#approach
+"""
+1. iterate through the array from index 1 to len(arr) - 1
+2. check if the current element is a peak
+3. if it is a peak, then find the length of the peak
+4. go to the uphill start
+5. go to the downhill end
+6. update the ans
+"""
+# Time Complexity: O(n)
+# Space Complexity: O(1)
+
+
+
+arr=[1, 2, 3, 3, 4, 0, 10, 6, 5, -1, -3, 2, 3]
+
+
+def longestPeak(arr: list) -> int:
+        ans = 0
+        # iterate through the array from index 1 to len(arr) - 1
+        for indx in range(1, len(arr) - 1):
+            # check if the current element is a peak
+            if arr[indx - 1] < arr[indx] > arr[indx + 1]:
+                # if it is a peak, then find the length of the peak
+                uphill_start = downhill_ends = indx
+                # go to the uphill start
+                while uphill_start > 0 and arr[uphill_start] > arr[uphill_start - 1]:
+                    uphill_start -= 1
+                    # go to the downhill end
+                while downhill_ends + 1 < len(arr) and arr[downhill_ends] > arr[downhill_ends + 1]:
+                    downhill_ends += 1
+                    # update the ans 
+                ans = max(ans, (downhill_ends - uphill_start + 1))
+        return ans
+
+
+print(longestPeak(arr))
+# output: 6

Arrays/squares_of_a_sorted_array.java

@@ -0,0 +1,91 @@
+/**
+
+ Time Complexity: O(n), Space Complexity O(n).
+
+ Given an integer array nums sorted in non-decreasing order, return an array of the squares of each number sorted in non-decreasing order.
+
+ Input: nums = [-4,-1,0,3,10]
+ Output: [0,1,9,16,100]
+
+ Input: nums = [-7,-3,2,3,11]
+ Output: [4,9,9,49,121]
+
+
+ Input: nums = [2,3,11]
+ Output: [4,9,121]
+
+**/
+
+class Solution {
+    public int[] sortedSquares(int[] nums) {
+
+        int hasNegative = -1; // -1  Indcating that are no negative values in the input array.
+        int len = nums.length;
+
+	  // Find the index of the last negative value.
+        for(int i = 0; i < len; ++i)
+        {
+            if(nums[i] < 0)
+            {
+                nums[i] = Math.abs(nums[i]); // If there is a negative value make it positive.
+                hasNegative = i;
+            }
+        }
+
+
+        int []ans = new int[nums.length];
+
+        if(hasNegative != -1) // check if the array have negative values
+        {
+
+	    /**
+		If there are negative values,
+                that's divide the input array into two halfs.
+                both halfs are sorted in increasing order if:
+
+	          -first half start from a and end at index 0, Where a is the index of the last negative value.
+        	    -second half start from (b) and end at (size of the array  - 1 (n - 1)) [b, n-1] iclusive, Where b is the index a + 1.
+
+                At every step we choose the minimun value between the vlaues at index a and b then,
+                square the value and store it in array []ans.
+	    **/
+            int a = hasNegative, b = hasNegative + 1;
+            int k = 0;
+
+            while(a >= 0 && b < len)
+            {
+                if(nums[a] <= nums[b]) // Value at index a is the minimum value so we choosed.
+                {
+                    ans[k] = nums[a] * nums[a];
+                    a--;
+                }
+                else
+                {
+                    ans[k] = nums[b] * nums[b];
+                    b++;
+                }
+                k++;
+            }
+
+            while(a >= 0)
+            {
+                 ans[k++] = nums[a] * nums[a];
+                 a--;
+            }
+
+            while(b < len)
+            {
+                 ans[k++] = nums[b] * nums[b];
+                 b++;
+            }
+        }
+        else  //If there are no negative values, the sloution is straight forward.
+        {
+
+            for(int i = 0; i < len; ++i)
+                ans[i] = nums[i] * nums[i];
+        }
+        return ans;
+    }
+
+}

Fast and Slow Pointers/linked_list_compute_midpoint.java

@@ -0,0 +1,113 @@
+/*
+ * LEETCODE 876
+Given the head of a singly linked list, return the middle node of the linked list.
+If there are two middle nodes, return the second middle node.
+*Example 1:
+Input: head = [1,2,3,4,5]
+Output: [3,4,5]
+Explanation: The middle node of the list is node 3.
+
+*Example 2:
+Input: head = [1,2,3,4,5,6]
+Output: [4,5,6]
+Explanation: Since the list has two middle nodes with values 3 and 4, we return the second one.
+
+*CODE EXPLAINATION WITH DRY RUN:
+This Java code finds the midpoint node of a singly-linked list. If the linked list has an even number 
+of nodes, it returns the second middle node.
+
+First, the Node class is defined with a constructor that takes in an integer value and initializes
+the next reference to null. The insertAtTail() method takes in a head node and an integer value,
+and inserts a new node with the given value at the end of the linked list. The printLinkedList() method 
+takes in a head node and prints out all the values in the linked list.
+
+The makeLinkedList() method prompts the user to enter integers until -1 is inputted. Each integer is 
+inserted into a new node at the tail of the linked list. The computeMidpoint() method takes in a head 
+node and returns the middle node(s) of the linked list. If the linked list has no nodes or only one node, 
+it just returns the head node. Otherwise, it initializes a slow pointer and a fast pointer to the head 
+node. The while loop advances the fast pointer by two nodes and the slow pointer by one node at each 
+iteration until the fast pointer reaches the end of the linked list. At that point, the slow pointer 
+will be pointing to the midpoint node(s) of the linked list.
+
+Finally, in the main() method, a new linked list is created by calling makeLinkedList(). The linked 
+list is printed using printLinkedList(). The midpoint of the linked list is computed using 
+computeMidpoint(), and its value is printed out.
+
+*Example Dry Run:
+Suppose we have the following input:
+1 2 3 4 5 -1
+This creates a linked list with the following structure:
+1 -> 2 -> 3 -> 4 -> 5 -> null
+Initially, the slow pointer and fast pointer both point to the head node, which is 1. In the first iteration of the while loop, the fast pointer moves two nodes ahead to node 3, while the slow pointer moves one node ahead to node 2. In the second iteration, the fast pointer moves another two nodes ahead to null, while the slow pointer moves one more node ahead to node 3. At this point, the slow pointer is pointing to the midpoint node(s) of the linked list.
+Therefore, computeMidpoint() returns node 3, which is printed out as output.
+
+*/
+import java.util.Scanner;
+
+public class linked_list_compute_midpoint {
+
+  static class Node {
+
+    int data;
+    Node next;
+
+    public Node(int data) {
+      this.data = data;
+      next = null;
+    }
+  }
+
+  static Node insertAtTail(Node head, int data) {
+    if (head == null) {
+      head = new Node(data);
+      return head;
+    }
+    Node n = new Node(data);
+    Node temp = head;
+    while (temp.next != null) {
+      temp = temp.next;
+    }
+    temp.next = n;
+    return head;
+  }
+
+  static void printLinkedList(Node head) {
+    while (head != null) {
+      System.out.print(head.data + "->");
+      head = head.next;
+    }
+  }
+
+  static Node makeLinkedList() {
+    Scanner scanner = new Scanner(System.in);
+    int data = scanner.nextInt();
+    Node head = null;
+    while (data != -1) {
+      head = insertAtTail(head, data);
+      data = scanner.nextInt();
+    }
+    scanner.close();
+    return head;
+  }
+
+  static Node computeMidpoint(Node head) {
+    if (head == null || head.next == null) {
+      return head;
+    }
+    Node slow = head;
+    Node fast = head.next;
+    while (fast != null && fast.next != null) {
+      fast = fast.next.next;
+      slow = slow.next;
+    }
+    return slow;
+  }
+
+  public static void main(String[] args) {
+    Node head = makeLinkedList();
+    printLinkedList(head);
+    System.out.println();
+    Node midpoint = computeMidpoint(head);
+    System.out.println(midpoint.data);
+  }
+}