Cacher is the code snippet organizer for pro developers

package platform.leetcode.problem0007;

import base.ISolution;
import common.Entry;
import common.io.input.InputReader;
import common.io.utils.Utility;

import java.io.InputStream;
import java.util.Arrays;

/**
 * @author Saurabh Dutta
 * @see <a href="https://leetcode.com/problems/search-in-rotated-sorted-array/">https://leetcode.com/problems/search-in-rotated-sorted-array/</a>
 **/
public class SearchInRotatedSortedArray implements ISolution {

    @Override
    public void solve(InputStream in) throws Exception {
        InputReader reader = new InputReader(in);
        String line = reader.readLine();
        int[] input = Utility.getIntArray(line);
        int target = Integer.parseInt(reader.readLine());
        System.out.println(search(input, target));
    }


    @Entry
    public int search(int[] nums, int target) {
        if (nums.length > 0) {
            // find pivot
            Integer[] arr = Arrays.stream( nums ).boxed().toArray( Integer[]::new );
            int pivot = findPivot(nums, 0, nums.length - 1);
            int first  = nums[0];
            int last = nums[nums.length -1];
            int max = nums[pivot];
            // normal sorted array
            if (last == max) {
                return Math.max(-1, Arrays.binarySearch(arr, target));
            }
            // sorted array with first element out of place
            else if (first == max) {
                if (target == max) {
                    return 0;
                }
                return Math.max(-1,Arrays.binarySearch(arr, 1, nums.length, target));
            }
            // target in first half
            else if (target >= first && target <= max) {
                return Math.max(-1,Arrays.binarySearch(arr,0 , pivot + 1, target));
            }
            // target in last half
            else {
                return Math.max(-1,Arrays.binarySearch(arr,pivot+1 , nums.length, target));
            }
        } else {
            return -1;
        }
    }


    private int findPivot(int[] nums, int start, int end) {
        int mid = (start + end) / 2;
        // sorted, take last value
        if (nums[mid] >= nums[end] && nums[mid] <= nums[start]) {
            return start;
        }
        // sorted reverse, take first value
        if (nums[mid] <= nums[end] && nums[mid] >= nums[start]) {
            return end;
        }
        //left half is sorted, go to right
        if (nums[mid] >= nums[end] && nums[mid] >= nums[start]) {
            if(nums[mid] >= nums[mid+1]) {
                return mid;
            }
            return findPivot(nums, mid +1, end);
        }
        //right half is sorted, go to left
        if (nums[mid] <= nums[start] && nums[mid] <= nums[end]) {
            return findPivot(nums, start, mid -1 );
        }
        return -1; // pivot not found
    }
}

package platform.leetcode.problem0008;
import base.ISolution;
import common.Entry;
import common.io.input.InputReader;
import common.io.utils.Utility;

import java.io.InputStream;

/**
*
* @author Saurabh Dutta
* @see <a href="https://leetcode.com/problems/merge-sorted-array/">https://leetcode.com/problems/merge-sorted-array/</a> 
*
**/
public class MergeSortedArray implements ISolution {

    @Override
    public void solve(InputStream in) throws Exception{
        InputReader reader = new InputReader(in);
        int[] nums1 = Utility.getIntArray(reader.readLine());
        int m = Integer.parseInt(reader.readLine());
        int[] nums2 = Utility.getIntArray(reader.readLine());
        int n = Integer.parseInt(reader.readLine());
        merge(nums1,m,nums2,n);
        for(int num: nums1) {
            System.out.print(num + " ");
        }
    }

    @Entry
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        int pointer1 = m-1;
        int pointer2 = n-1;

        for(int i = nums1.length-1; i>=0; i--) {
            if (pointer1>=0 && pointer2>=0) {
                if (nums1[pointer1] >= nums2[pointer2]) {
                    nums1[i] = nums1[pointer1];
                    pointer1--;
                } else {
                    nums1[i] = nums2[pointer2];
                    pointer2--;
                }
            } else {
                if (pointer1 >=0) {
                    nums1[i] = nums1[pointer1];
                    pointer1--;
                }
                else {
                    nums1[i] = nums2[pointer2];
                    pointer2--;
                }
            }
        }
    }
}