力扣：最长公共前缀，罗马数转整数，回文数，两数之和

/**
 * 最长公共前缀
 */
class Longestcommonprefix {
    public static String longestCommonPrefix(String[] strs) {

        String efix = "";
        OK:
        if (strs != null && strs.length > 0) {
            for (int i = 0; i < strs[0].length(); i++) {
                String prefix = strs[0].substring(0, i + 1);
                for (String str : strs) {
                    if (str.startsWith(prefix)) {
                        continue;
                    }
                    break OK;
                }
                efix = prefix;
            }
        }
        return efix;
    }

    public static void main(String[] args) {
        String[] s = new String[]{"flower", "flow", "flight"};
        String s1 = Longestcommonprefix.longestCommonPrefix(s);
        System.out.println(s1);
    }
}


//编写一个函数来查找字符串数组中的最长公共前缀。
//
// 如果不存在公共前缀，返回空字符串 ""。
//
//
//
// 示例 1：
//
//
//输入：strs = ["flower","flow","flight"]
//输出："fl"
//
//
// 示例 2：
//
//
//输入：strs = ["dog","racecar","car"]
//输出：""
//解释：输入不存在公共前缀。
//
//
//
// 提示：
//
//
// 0 <= strs.length <= 200
// 0 <= strs[i].length <= 200
// strs[i] 仅由小写英文字母组成
//
// Related Topics 字符串

/**
 * 罗马数字转整数
 */
class RomanNumeralstoIntegers {
    public static int romanToInt(String s) {
        Integer a = 0;
        Map<String, Integer> map = new HashMap<>();
        map.put("I", 1);
        map.put("V", 5);
        map.put("X", 10);
        map.put("L", 50);
        map.put("C", 100);
        map.put("D", 500);
        map.put("M", 1000);
        String[] chars = s.split("");
        for (int i = chars.length - 1; i >= 0; i--) {
            if (i - 1 >= 0 && map.get(chars[i]) > map.get(chars[i - 1])) {
                a += map.get(chars[i]) - map.get(chars[i - 1]);
                i -= 1;
                continue;
            }
            a += map.get(chars[i]);
        }
        return a;
    }

    public static void main(String[] args) {
        int mmmcmxcix = RomanNumeralstoIntegers.romanToInt("MMMCMXCIX");
        System.out.println(mmmcmxcix);
    }
}

。

/**
 * 回文数
 */
class PalindromeNumber {
    public static boolean isPalindrome(int x) {

        if (x < 0) {
            return false;
        }
        String a = "";
        String s = String.valueOf(x);
        char[] chars = s.toCharArray();
        for (int i = chars.length - 1; i >= 0; i--) {
            a += String.valueOf(chars[i]);
        }
        return a.equals(s);
    }

    public static void main(String[] args) {
        boolean palindrome = PalindromeNumber.isPalindrome(10101);
        System.out.println(palindrome);
    }
}


//给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false 。
//
// 回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。例如，121 是回文，而 123 不是。
//
//
//
// 示例 1：
//
//
//输入：x = 121
//输出：true
//
//
// 示例 2：
//
//
//输入：x = -121
//输出：false
//解释：从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。
//
//
// 示例 3：
//
//
//输入：x = 10
//输出：false
//解释：从右向左读, 为 01 。因此它不是一个回文数。
//
//
// 示例 4：
//
//
//输入：x = -101
//输出：false
//
//
//
//
// 提示：
//
//
// -231 <= x <= 231 - 1
//
//
//
//
// 进阶：你能不将整数转为字符串来解决这个问题吗？

/**
 * 两数之和
 */
class Sumoftwonumbers {
    public static int[] twoSum(int[] nums, int target) {

        Map<Integer, Integer> map = new HashMap<>();
        int[] a = new int[2];
        for (int i = 0; i < nums.length; i++) {
            if (map.containsKey(nums[i])) {
            a = new int[]{map.get(nums[i]), i};
            return a;
            }
            map.put(target - nums[i], i);
        }
        return a;
    }

    public static void main(String[] args) {
        int[] a = new int[]{2,7,22,5};
        int[] ints = Sumoftwonumbers.twoSum(a, 12);
        for (int anInt : ints) {
            System.out.print("["+anInt+"]");
        }
    }
}


//给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 的那 两个 整数，并返回它们的数组下标。
//
// 你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
//
// 你可以按任意顺序返回答案。
//
//
//
// 示例 1：
//
//
//输入：nums = [2,7,11,15], target = 9
//输出：[0,1]
//解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
//
//
// 示例 2：
//
//
//输入：nums = [3,2,4], target = 6
//输出：[1,2]
//
//
// 示例 3：
//
//
//输入：nums = [3,3], target = 6
//输出：[0,1]
//
//
//
//
// 提示：
//
//
// 2 <= nums.length <= 103
// -109 <= nums[i] <= 109
// -109 <= target <= 109
// 只会存在一个有效答案