Made changes according to PA

Author: thevijayshankersharma

dsa-solutions/lc-solutions/0000-0099/0033-search-in-rotated-sorted-array.md

@@ -3,10 +3,6 @@ id: search-in-rotated-sorted-array
 title: Search in Rotated Sorted Array (LeetCode)
 difficulty: Medium
 sidebar_label: 0033-SearchInRotatedSortedArray
-topics:
-  - Array
-  - Binary Search
-companies: []
 description: Search for a target element in a rotated sorted array with distinct values using an algorithm with O(log n) runtime complexity.
 ---
 
@@ -19,45 +15,45 @@ description: Search for a target element in a rotated sorted array with distinct
 
 ## Problem Description
 
-There is an integer array `nums` sorted in ascending order (with distinct values).
+There is an integer array $nums$ sorted in ascending order (with distinct values).
 
-Prior to being passed to your function, `nums` is possibly rotated at an unknown pivot index `k` (0 <= k < nums.length) such that the resulting array is `[nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]` (0-indexed).
+Prior to being passed to your function, $nums$ is possibly rotated at an unknown pivot index $k$ (0 <= k < nums.length) such that the resulting array is $[nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]$ (0-indexed).
 
-Given the array `nums` after the possible rotation and an integer `target`, return the index of `target` if it is in `nums`, or -1 if it is not in `nums`.
+Given the array $nums$ after the possible rotation and an integer $target$, return the index of $target$ if it is in $nums, or -1 if it is not in $nums$.
 
-You must write an algorithm with O(log n) runtime complexity.
+You must write an algorithm with $O(log n)$ runtime complexity.
 
 ### Examples
 
 #### Example 1
 
-- **Input:** `nums = [4,5,6,7,0,1,2]`, `target = 0`
-- **Output:** `4`
-- **Explanation:** 0 is located at index 4 in the rotated sorted array `[4,5,6,7,0,1,2]`.
+- **Input:** $nums = [4,5,6,7,0,1,2]$, $target = 0$
+- **Output:** $4$
+- **Explanation:** 0 is located at index 4 in the rotated sorted array $[4,5,6,7,0,1,2]$.
 
 #### Example 2
 
-- **Input:** `nums = [4,5,6,7,0,1,2]`, `target = 3`
-- **Output:** `-1`
-- **Explanation:** 3 is not in `nums`, so return -1.
+- **Input:** $nums = [4,5,6,7,0,1,2]$, $target = 3$
+- **Output:** $-1$
+- **Explanation:** 3 is not in $nums$, so return -1.
 
 #### Example 3
 
-- **Input:** `nums = [1]`, `target = 0`
-- **Output:** `-1`
-- **Explanation:** 0 is not in `nums`, so return -1.
+- **Input:** $nums = [1]$, $target = 0$
+- **Output:** $-1$
+- **Explanation:** 0 is not in $nums$, so return -1.
 
 ### Constraints
 
-- `1 <= nums.length <= 5000`
-- `-10^4 <= nums[i] <= 10^4`
-- All values of `nums` are unique.
-- `nums` is an ascending array that is possibly rotated.
-- `-10^4 <= target <= 10^4`
+- $v1 <= nums.length <= 5000$
+- $-10^4 <= nums[i] <= 10^4$
+- All values of $nums$ are unique.
+- $nums$ is an ascending array that is possibly rotated.
+- $-10^4 <= target <= 10^4$
 
 ### Approach
 
-To search for a target element in a rotated sorted array with distinct values with O(log n) runtime complexity, we can use the binary search algorithm.
+To search for a target element in a rotated sorted array with distinct values with $O(log n)$ runtime complexity, we can use the binary search algorithm.
 
 1. **Find the Pivot Point:**
    - Perform binary search to find the pivot element, which is the smallest element in the array. This element divides the array into two sorted subarrays.
@@ -70,7 +66,7 @@ To search for a target element in a rotated sorted array with distinct values wi
 
 #### Python
 
-```
+```py
 class Solution:
     def search(self, nums: List[int], target: int) -> int:
         left, right = 0, len(nums) - 1
@@ -93,7 +89,7 @@ class Solution:
 
 #### Java
 
-```
+```java
 class Solution {
     public int search(int[] nums, int target) {
         int left = 0, right = nums.length - 1;
@@ -120,7 +116,7 @@ class Solution {
 
 #### C++
 
-```
+```cpp
 class Solution {
 public:
     int search(vector<int>& nums, int target) {
@@ -148,4 +144,4 @@ public:
 
 ### Conclusion
 
-The above solution effectively searches for a target element in a rotated sorted array with distinct values using the binary search algorithm with O(log n) runtime complexity. It handles all edge cases and constraints specified in the problem statement.
+The above solution effectively searches for a target element in a rotated sorted array with distinct values using the binary search algorithm with $O(log n)$ runtime complexity. It handles all edge cases and constraints specified in the problem statement.