Update 1095-find-in-mountain-array.cpp

Algorithm description removed

Author: Vicen-te

Diff for: cpp/1095-find-in-mountain-array.cpp

@@ -1,44 +1,15 @@
 /**
- *  Description:
- *      (This problem is an interactive problem.)
- *  
- *      You may recall that an array arr is a mountain array if and only if:
- *          arr.length >= 3
- *          There exists some i with 0 < i < arr.length - 1 such that:
- *              arr[0] < arr[1] < ... < arr[i - 1] < arr[i]
- *              arr[i] > arr[i + 1] > ... > arr[arr.length - 1]
- *  
- *      Given a mountain array mountainArr, return the minimum index such that 
- *      mountainArr.get(index) == target. If such an index does not exist, return -1.
- *  
- *      You cannot access the mountain array directly. You may only access the array using 
- *      a MountainArray interface:
- *          MountainArray.get(k) returns the element of the array at index k (0-indexed).
- *          MountainArray.length() returns the length of the array.
- *  
- *      Submissions making more than 100 calls to MountainArray.get will be judged Wrong Answer. 
- *      Also, any solutions that attempt to circumvent the judge will result in disqualification.
- *  
- *      Ex1.
- *          Input: array = [1,2,3,4,5,3,1], target = 3
- *          Output: 2
- *          Explanation: 3 exists in the array, at index=2 and index=5. Return the minimum index, 
- *          which is 2.
- *  
- *      Ex2.
- *          Input: array = [0,1,2,4,2,1], target = 3
- *          Output: -1
- *          Explanation: 3 does not exist in the array, so we return -1.
  * 
  *  Algorithm:
- *      1. The algorithm's goal is to find the minimum index at which the value "target",
+ *      -  The algorithm's goal is to find the minimum index at which the value "target",
  *         exist within a "MountainArray".
- *      2. It employs a binary search approach, dividing the array into ascending and 
- *         descending halves.Additionally, it identifies the peak index to determine the
+ *      -  It employs a binary search approach, dividing the array into ascending and 
+ *         descending halves. Additionally, it identifies the peak index to determine the
  *         transition from ascending to descending.
  * 
- *  Time Complexity: O(log n) 
+ *  Time  Complexity: O(log n) 
  *  Space Complexity: O(1)
+ * 
  */
 
 /**