6 - integer inversion LeetCode.7

1. Title

  • Give a 32-bit signed integer
  • Invert this integer, the number on each
  • Assume that the environment does not allow the storage of 64 bit integers (signed or unsigned).
    [external chain picture transfer failed. The source station may have anti-theft chain mechanism. It is recommended to save the picture and upload it directly (img)-

2. Array

Pre knowledge, understanding is enough

  • It is a collection of data of the same type. Once the array is initialized, its length cannot be changed. Therefore, it is necessary to specify the initial capacity
  • Is a physically continuous storage structure, that is, the array name represents the first address of the continuous space
  • Through the first address, all elements of the array can be accessed in turn, and the subscript reads the data under the time complexity of O(1)

3. Problem solving ideas

  • Reverse order

  • Head and tail exchange

  • Mathematical thinking solution

1. Violent solution (reverse order)

  • step

    1. int to String, String to char []
      • The bottom layer of the array is actually a char [], and from JDK1.9, it is: byte []
    2. Traverses the character array in reverse and stores the elements in the new array
    3. Convert the new array into a string and then into an integer for output
  • Boundaries and details:

    1. Boundary:

      • Array Index Overflow

      • Value overflow boundary: [− 2 ^ 31, 2 ^ (31 − 1)], overflow returns 0

        • It can be seen that the absolute value of the minimum value is 1 greater than the maximum value. MIN and MAX cannot be reversed
    2. Details:

      • 32 bits, i.e. int type
      • The first is not 0
  • code:

    public static int reverse(int x) {
        // Note: after the absolute value is taken as the minimum value of Integer, it must be 1 greater than the maximum value, so it cannot be reversed
        if (x == Integer.MIN_VALUE || x == Integer.MAX_VALUE) {
            return 0;
        }
        // Processing positive and negative numbers
        int sign = x > 0 ? 1 : -1;  // Get symbol
        // Take absolute value
        x = x < 0 ? -x : x;
    
        String str = String.valueOf(x); // int to String
        char[] charArray = str.toCharArray(); // String to char []
    
        // Traverse the array in reverse, and then store the elements in the new array
        // 1. New array initialization
        int num = charArray.length;
        char[] newChar = new char[num];
        // 2. Reverse traversal
        for (int i = 0; i < num; i++) {
            newChar[i] = charArray[(num - 1) - i];
        }
    
        // The new array is converted to String and then int
        String newStr = String.valueOf(newChar); // To String
        // Not all strings can be converted to integers. Therefore, convert them to long before judging
        long value = Long.parseLong(newStr);
        // Judge that the overflow is 0
        boolean b = value > Integer.MAX_VALUE || value < Integer.MIN_VALUE;
        int result = b ? 0 : (int) value;
        return result * sign; // Do symbol processing
    }
    

2. End to end exchange

  • Steps:

    • int to String, String to char []

    • Loop traversal: perform head and tail exchange (until there are 1 or 0 operations left in the array)

      • Start > = end, the cycle ends and the inversion is completed

    • Finally, convert char [] to string and string to int

  • code:

    public static int reverse(int x) {
        // Boundary judgment
        if (x == Integer.MAX_VALUE || x == Integer.MIN_VALUE) return 0;
        // Positive and negative number processing
        int sign = x < 0 ? -1 : 1; // Extract negative sign
        x = x < 0 ? -x : x; // Get absolute value
    
        String str = String.valueOf(x);// To String
        char[] charArray = str.toCharArray();// To char []
        // Swap the first (start) and last (end) digits
        int start = 0, end = charArray.length - 1;
        while (start < end) {
            // Swap equidistant elements at both ends
            char temp = charArray[start];
            charArray[start] = charArray[end];
            charArray[end] = temp;
            start++;
            end--;
        }
    
        String newStr = String.valueOf(charArray); // Reverse result to String
        long value = Long.parseLong(newStr); // String to long (some numbers will overflow the int range after being reversed)
        // Determine the number greater than 32 (0 if overflow)
        int result = value > Integer.MAX_VALUE || value < Integer.MIN_VALUE ? 0 : (int) value;
        return result * sign; // Do symbol processing
    }
    

3. Mathematical thinking solution( ⭐)

It is also the optimization solution among the three solutions

  • Steps:

    1. Take the mold and get the lowest position
    2. Take the quotient again and remove the lowest order
    3. Loop traversal, the lowest bit obtained is accumulated and spliced
  • Details:

    1. At the highest position:
      • x%10 = x
      • x/10 = 0
      • (both conditions can be adjusted as the end of the cycle, just choose one)
    2. The spliced integer may overflow the range of int. use long to store it. Finally, judge that the overflow int returns 0
    3. The first is not 0
    4. Symbol processing. (extract the minus sign to get the result, and then restore)
  • code:

    public static int reverse3(int x) {
        // The boundary value of int cannot be reversed (the absolute value difference is 1)
        if (x == Integer.MAX_VALUE || x == Integer.MIN_VALUE) return 0;
        // Symbol processing
        int sign = x < 0 ? -1 : 1; // Get symbol
        x = x < 0 ? -x : x; // Gets the absolute value (both positive and negative are treated as positive numbers)
        long sum = 0; // result
        int last;  // Get the lowest order
    
        while ((last = x % 10) != x) { // The lowest bit = = itself, indicating that it is the last bit
            sum = sum * 10 + last;
            x /= 10; // Remove lowest bit
        }
        // At the end of the cycle, last is the highest bit (spliced into the result)
        if (last != 0) {
            sum = sum * 10 + last;
            // Overflow processing
            sum = sum > Integer.MAX_VALUE ? 0 : sum;
        }
        return (int) sum * sign; // Positive and negative processing
    }
    
    • The mathematical thinking solution discards the data structure, saves memory and improves efficiency

Tags: Java Algorithm data structure leetcode array

Posted on Mon, 29 Nov 2021 09:13:16 -0500 by BrandonKahre