Blogz

public String longestPalindrome(String s) {
    if (s.length() == 0 || s.length() == 1) return s;
    char[] chars = s.toCharArray();
    String maxString = String.valueOf(chars[0]);
    for (int i = 0; i < chars.length; i++) {
        int n = 0;
        int len = 1;
        while (i - n - 1 >= 0 && i + n + 1 < chars.length && chars[i - n - 1] == chars[i + n + 1]) {
            n++;
            len += 2;
        }
        if (len > maxString.length()) {
            maxString = s.substring(i - n, i + n + 1);
        }
        if (i + 1 < chars.length && chars[i] == chars[i + 1]) {
            n = 0;
            len = 2;
            while (i - n - 1 >= 0 && i + 1 + n + 1 < chars.length && chars[i - n - 1] == chars[i + 1 + n + 1]) {
                n++;
                len += 2;
            }
            if (len > maxString.length()) {
                maxString = s.substring(i - n, i + 1 + n + 1);
            }
        }
    }
    return maxString;
}

public String convert(String s, int numRows) {
    if (numRows <= 1) return s;
    char[] chars = s.toCharArray();
    StringBuilder result = new StringBuilder();
    int step = (numRows - 1) * 2;
    for (int r = 0; r < numRows; r++) {
        for (int i = 0; i < chars.length; i += step) {
            int colum = i + r;
            if (colum < chars.length) {
                result.append(chars[colum]);
            }
            int offset = step - r * 2;
            if (offset > 0 && offset < step && offset + colum < chars.length) {
                result.append(chars[offset + colum]);
            }
        }
    }
    return result.toString();
}

public double findMedianSortedArrays(int[] nums1, int[] nums2) {
    int len = nums1.length + nums2.length;
    int center = len / 2;
    boolean isOdd = (len % 2 == 1);
    int[] nums = new int[2];
    int cur = 0;
    int p1 = 0;
    int p2 = 0;
    int count = 0;
    while (true) {
        if (p1 < nums1.length && p2 < nums2.length) {
            if (nums1[p1] <= nums2[p2]) {
                nums[cur] = nums1[p1++];
            } else {
                nums[cur] = nums2[p2++];
            }
        } else if (p1 < nums1.length) {
            nums[cur] = nums1[p1++];
        } else {
            nums[cur] = nums2[p2++];
        }
        if (count++ == center) break;
        cur = cur == 1 ? 0 : 1;
    }
    if (isOdd) {
        return nums[cur];
    }
    return (nums[0] + nums[1]) / 2f;
}

public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
    ListNode p1 = new ListNode(0);
    p1.next = l1;
    ListNode p2 = new ListNode(0);
    p2.next = l2;
    int remain = 0;
    do {
        p1 = p1.next;
        int added = p1.val + remain;
        if (p2.next != null) {
            p2 = p2.next;
            added += p2.val;
        }
        remain = added / 10;
        p1.val = added % 10;

        if (p1.next == null && p2.next != null) {
            p1.next = p2.next;
            p2.next = null;
        } else if (p1.next == null) {
            if (remain > 0) p1.next = new ListNode(remain);
            break;
        }
    } while (true);
    return l1;
}

public int lengthOfLongestSubstring(String s) {
    if (s == null || s.length() == 0) return 0;
    if (s.length() == 1) return 1;
    char [] chars= s.toCharArray();
    int start = 0;
    int end = 1;
    int maxLength = 1;
    int curLength = 1;
    while(end<chars.length){
        for (int i = start; i < end; i++) {
            if (chars[end] == chars[i]) {
                maxLength = Math.max(curLength, maxLength);
                start = i + 1;
                curLength = end -start;
                if(chars.length - start < maxLength){
                    return maxLength;
                }
                break;
            }
        }
        curLength++;
        end++;
    }
    return Math.max(maxLength,curLength);
}

public void sort(int[] arr) {
    int len = arr.length;
    int step = len/2;
    while (step > 0) {
        for (int i = 0; i < step; i++) {
            for (int j = i + step; j < len; j += step) {
                int n = j;
                while (n - step >= 0) {
                    if (arr[n] >= arr[n - step]) break;
                    int temp = arr[n];
                    arr[n] = arr[n - step];
                    arr[n - step] = temp;
                    n -= step;
                }
            }
        }
        step /= 2;
    }
}

public int[] twoSum0(int[] nums, int target) {
    for (int i = 0; i < nums.length; i++) {
        for (int j = i + 1; j < nums.length; j++) {
            if (nums[i] + nums[j] == target) return new int[]{i, j};
        }
    }
    return new int[]{};
}

public int[] twoSum(int[] nums, int target) {
    Map<Integer, Integer> map = new HashMap<>();
    for (int i = 0; i < nums.length; i++) {
        int remain = target - nums[i];
        Integer num = map.get(remain);
        if (num != null) {
            return new int[]{i, num};
        }
        map.put(nums[i], i);
    }
    return null;
}

public void sort(int[] arr) {
    for (int i = arr.length - 1; i > 0; i--) {
        for (int j = 0; j < i; j++) {
            if (arr[j] > arr[j + 1]) {
                arr[j] = arr[j] ^ arr[j + 1];
                arr[j + 1] = arr[j] ^ arr[j + 1];
                arr[j] = arr[j] ^ arr[j + 1];
            }
        }
    }
}

public void sort(int[] arr) {
    for (int i = 1; i < arr.length; i++) {
        for (int j = i; j > 0; j--) {
            if (arr[j] < arr[j - 1]) {
                swap(arr, j, j - 1);
            } else {
                break;
            }
        }
    }
}

public void sort(int[] arr) {
    for (int i = 0; i < arr.length; i++) {
        int n = i;
        for (int j = i; j < arr.length; j++) {
            if (arr[j] < arr[n]) n = j;
        }
        swap(arr, i, n);
    }
}