Leetcode question brushing record

Catalog

1、 The following code results in ？22/7/27

2、 Judge whether the integer is palindrome   22/7/27

3、 Roman numeral to integer 22/7/28

---

1、 The following code results in ？22/7/27

2、 Judge whether the integer is palindrome   22/7/27

---

1、 The following code results in ？22/7/27

public class Test {
    public static void main(String args[]) {
        int x = -5;
        int y = -12;
        System.out.println(y % x);
    }
}

answer ：x And y Between operations , When x,y When the symbols are the same, the symbols of modulo and remainder are also the same

When x,y Different symbols , Take the remainder and take the head , Take mold and tail , The remainder result symbol and x identical , Take mold and y identical

Arrays.asList() The list returned by the method is Arrays.ArrayList Type of , Not at all java.util.ArrayList;

2、 Judge whether the integer is palindrome   22/7/27

My plan ：

 public static boolean isPalindrome(int x) {
        String s = String.valueOf(x);
        StringBuilder sb = new StringBuilder();
        char[] chars = s.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            sb.append(chars[i]);
        }

        if (sb.reverse().toString().equals(s)){
            return true;
        }
        return false;
    }

The problem is ： Memory consumption is too high , The code is too complicated , When the number is too large, it will cause overflow .

Solution ：

/**
     *  There is no need to reverse all integers before judging , You can take the general for comparison , Take the last few digits of the integer and compare with the first few digits 
     */
    public static boolean isPalindrome(int x) {

        // First, the result must not be the enumeration of palindromes 
        /**
         *  Less than 0 Signed is not palindrome 
         *  At the end is 0 Non - 0 Integers 
         */
        if (x < 0 || (x % 10 == 0 && x != 0)){
            return false;
        }
        // Trailing mantissa 
        int revertedNmuber = 0;
        // When x Less than or equal to revertedNmuber It indicates that the mantissa extracted is more than half , Only need to compare half 
        while ( x > revertedNmuber){
            //x%10 Is to take the last digit , The first cycle takes the last number , The second cycle is to multiply the previous mantissa by 10 Plus the current mantissa 
            revertedNmuber = revertedNmuber * 10 + x % 10;
            x /= 10;
        }
        // If x=revertedNmuber  It means that the same before and after is palindrome 
        // If x=revertedNmuber/10  It means that all the other digits are equal except the middle one 121 1=21/10  Is palindrome 
        return x == revertedNmuber || x == revertedNmuber/10;
    }

summary ： The general thinking of finding palindromes is to reverse all the numbers and then judge whether the number string after reverse order is compared with the original number string , Although it is easy to understand , But the method is more cumbersome , Wasting time and space is not worth it , And by improving the method , Only extract the value of half the string of integers for comparison ,12321, Take only 12  And mantissa 12 Compare , Save space , Improve system performance .

3、 Roman numeral to integer 22/7/28

The main idea ： Store symbols and corresponding values in Map Collection , Traverse the input string , If the characters on the left are smaller than those on the right, subtract them , If the left side is larger than the right side, add ,

for example XIV It can be regarded as X−I+V=10−1+5=14

    public static int romanToInt(String s) {
        //s = I 1, V 5 , X 10, L 50,C 100,D 500, M 1000.
        Map<Character,Integer> sLists = new HashMap<>();
        sLists.put('I',1);
        sLists.put('V',5);
        sLists.put('X',10);
        sLists.put('L',50);
        sLists.put('C',100);
        sLists.put('D',500);
        sLists.put('M',1000);

        int sum = 0;
        for (int i = 0; i < s.length(); i++) {
            // Get the value corresponding to the current string 
            int value = sLists.get(s.charAt(i));
            // The judgment of less than here is to prevent i+1 overflow , When i=s.length() - 1 Explain to the last element , Can no longer +1 operation 
            if (i < s.length() - 1 && value < sLists.get(s.charAt(i + 1)))
                sum -= value;
            else {
                sum += value;
            }
        }
        return sum;
    }
}

summary ： Preventing loop overflow can be judged with the last element , If it is less than the last element, continue to execute .