3595、反转两次的数字

标签：assertTrue return 数字 3595 int 反转 Assert num test

反转一个整数意味着倒置它的所有位。

例如，反转 2021 得到 1202 。反转 12300 得到 321 ，不保留前导零。

给你一个整数 num ，反转 num 得到 reversed1 ，接着反转 reversed1 得到 reversed2 。如果 reversed2 等于 num ，返回 true ；否则，返回 false 。

示例 1：

输入：num = 526

输出：true

解释：反转 num 得到 625 ，接着反转 625 得到 526 ，等于 num 。

示例 2：

输入：num = 1800

输出：false

解释：反转 num 得到 81 ，接着反转 81 得到 18 ，不等于 num 。

示例 3：

输入：num = 0

输出：true

解释：反转 num 得到 0 ，接着反转 0 得到 0 ，等于 num 。

提示：

0 <= num <= 106

来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/a-number-after-a-double-reversal

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

package cn.fansunion.leecode.isNumber;

import java.util.List;

import cn.fansunion.leecode.kit.Kit;

/**

 * 2119. 反转两次的数字 <br/>

 * 反转 一个整数意味着倒置它的所有位。

 *

 * 例如，反转 2021 得到 1202 。反转 12300 得到 321 ，不保留前导零 。 <br/>

 * 给你一个整数 num ，反转 num 得到 reversed1 ，接着反转 reversed1 得到 reversed2 。 <br/>

 * 如果 reversed2 等于 num ，返回 true ；否则，返回 false 。

 *

 * 来源：力扣（LeetCode） 链接：力扣

 * 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

 *

 * @author [email protected]

 *

 *         2022-3-9

 */

public class ANumberAfterADoubleReversal {

    /*示例 1：

     

    输入：num = 526

    输出：true

    解释：反转 num 得到 625 ，接着反转 625 得到 526 ，等于 num 。

    示例 2：

     

    输入：num = 1800

    输出：false

    解释：反转 num 得到 81 ，接着反转 81 得到 18 ，不等于 num 。

    示例 3：

     

    输入：num = 0

    输出：true

    解释：反转 num 得到 0 ，接着反转 0 得到 0 ，等于 num 。

      

     

    提示：

     

    0 <= num <= 106*/

    /**

     * 正常情况：1个数字，反转2次=没有反转，肯定和自己相等。<br/>

     * 题目的特点是：“不保留前导零”，正常来说，输入的数字肯定没有“前导零”，那么只用判断末尾是否有0就可以了。0特殊判断。

     *

     *

     * @param num

     * @return

     */

    public boolean isSameAfterReversals(int num) {

        if (num == 0) {

            return true;

        }

        return num % 10 != 0;

    }

    public boolean isSameAfterReversals2(int num) {

        if (num >= 0 && num <= 9) {

            return true;

        }

        List<Integer> numList = Kit.intToDigitList(num);

        List<Integer> reverseList = Kit.reverseListThenRemoveStartZero(numList);

        List<Integer> reverseList2 = Kit.reverseListThenRemoveStartZero(reverseList);

        int num2 = Kit.digitListToInt(reverseList2);

        return num == num2;

    }

}

package cn.fansunion.leecode.kit;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import java.util.Set;

/**

 * 一些常见的工具类

 *

 * @author [email protected]

 *

 *         2022-1-9

 */

public class Kit {

    /**

     * 打印数组

     *

     * @param array

     */

    public static void print(int[] array) {

        if (array == null) {

            System.out.println("The array is null");

            return;

        }

        if (array.length == 0) {

            System.out.println("The array length is 0");

            return;

        }

        for (int index = 0; index < array.length; index++) {

            System.out.print(array[index]);

            if (index != array.length - 1) {

                System.out.print(",");

            } else {

                System.out.println();

            }

        }

    }

    public static int[] setToArray(Set<Integer> set) {

        int[] nums = new int[set.size()];

        int index = 0;

        for (Integer num : set) {

            nums[index] = num;

            index++;

        }

        return nums;

    }

    /**

     * 把1个十进制的整数，转换成十进制数字组成的数组，1234->[1, 2, 3, 4]

     *

     * @param n

     * @return

     */

    public static List<Integer> intToDigitList(int n) {

        List<Integer> numList = new ArrayList<>();

        while (n >= 10) {

            numList.add(0, n % 10);

            n = n / 10;

        }

        numList.add(0, n);

        return numList;

    }

    /**

     * 把1个十进制的整数，转换成十进制数字组成的数组，1234->[4, 3, 2, 1]

     *

     * @param totalSum

     * @return

     */

    public static List<Integer> intToDigitListDesc(int n) {

        // 取模取余

        List<Integer> list = new ArrayList<>();

        // >=10

        while (n >= 10) {

            list.add(n % 10);

            n = n / 10;

        }

        list.add(n);

        return list;

    }

    public static void main(String[] args) {

        System.out.println(Kit.intToDigitList(1234));

        System.out.println(Kit.intToDigitListDesc(1234));

    }

    /**

     * 把一个十进制的整数数组，转换成int格式的数字

     *

     * @param numArray

     * @return

     */

    public static int digitListToInt(List<Integer> numList) {

        int num = 0;

        for (int index = numList.size() - 1; index >= 0; index--) {

            final int curDigit = numList.get(index);

            final int time = numList.size() - 1 - index;

            num += curDigit * Math.pow(10, time);

        }

        return num;

    }

    public static int digitArrayToInt(int[] numArray) {

        List<Integer> numList = new ArrayList<>();

        for (int num : numArray) {

            numList.add(num);

        }

        return digitListToInt(numList);

    }

    /**

     * 反转list，[1,2,3,4] -> [4,3,2,1]

     *

     * @param numList

     * @return

     */

    public static List<Integer> reverseList(List<Integer> numList) {

        if (numList == null || numList.size() == 1) {

            return numList;

        }

        List<Integer> reverseList = new ArrayList<>();

        for (int index = numList.size() - 1; index >= 0; index--) {

            reverseList.add(numList.get(index));

        }

        return reverseList;

    }

    /**

     * 反转list，且删除开头的0；[1,2,3,4] -> [4,3,2,1],<br/>

     * [1,2,3,0] -> [0,3,2,1] -> [3,2,1],[1,2,3,0,0] -> [0,0,3,2,1] -> [3,2,1]<br/>

     * [0]->[0]

     *

     * @param numList

     * @return

     */

    public static List<Integer> reverseListThenRemoveStartZero(List<Integer> numList) {

        List<Integer> reverseList = reverseList(numList);

        List<Integer> list = removeStartZero(reverseList);

        return list;

    }

    /**

     * 删除一个list中的0开头的数字。如果只有1个0，保留 <br/>

     * [0,0,3,2,1] -> [3,2,1], [3,2,1] -> [3,2,1],[0]->[0]

     *

     * @param reverseList

     * @return

     */

    private static List<Integer> removeStartZero(List<Integer> reverseList) {

        // 找到第1个非0的index

        int firstNotZeroIndex = -1;

        for (int index = 0; index < reverseList.size(); index++) {

            int num = reverseList.get(index);

            // 非前导0，才保留

            if (num != 0) {

                firstNotZeroIndex = index;

                break;

            }

        }

        if (firstNotZeroIndex == -1) {

            return Arrays.asList(0);

        }

        List<Integer> list = reverseList.subList(firstNotZeroIndex, reverseList.size());

        return list;

    }

}

package test.leecode.isNumber;

import org.junit.Assert;

import org.junit.Test;

import cn.fansunion.leecode.isNumber.ANumberAfterADoubleReversal;

/**

 * @author [email protected]

 *

 *         2022-3-12

 */

public class ANumberAfterADoubleReversalTest {

    @Test

    public void test() {

        ANumberAfterADoubleReversal test = new ANumberAfterADoubleReversal();

        //one

        Assert.assertTrue(test.isSameAfterReversals(1));

        Assert.assertTrue(test.isSameAfterReversals(2));

        Assert.assertTrue(test.isSameAfterReversals(9));

        Assert.assertTrue(test.isSameAfterReversals(0));

        //two

        Assert.assertTrue(test.isSameAfterReversals(11));

        Assert.assertTrue(test.isSameAfterReversals(12));

        Assert.assertTrue(test.isSameAfterReversals(78));

        Assert.assertFalse(test.isSameAfterReversals(10));

        Assert.assertFalse(test.isSameAfterReversals(30));

        //three

        Assert.assertFalse(test.isSameAfterReversals(180));

        Assert.assertTrue(test.isSameAfterReversals(181));

        Assert.assertTrue(test.isSameAfterReversals(526));

        Assert.assertTrue(test.isSameAfterReversals(123));

        //four

        Assert.assertFalse(test.isSameAfterReversals(1800));

        Assert.assertTrue(test.isSameAfterReversals(1801));

        //

        Assert.assertTrue(test.isSameAfterReversals(180258941));

        Assert.assertFalse(test.isSameAfterReversals(180258940));

    }

     

    @Test

    public void test2() {

        ANumberAfterADoubleReversal test = new ANumberAfterADoubleReversal();

        //one

        Assert.assertTrue(test.isSameAfterReversals2(1801));

        Assert.assertTrue(test.isSameAfterReversals2(1));

        Assert.assertTrue(test.isSameAfterReversals2(2));

        Assert.assertTrue(test.isSameAfterReversals2(9));

        Assert.assertTrue(test.isSameAfterReversals2(0));

        //two

        Assert.assertTrue(test.isSameAfterReversals2(11));

        Assert.assertTrue(test.isSameAfterReversals2(12));

        Assert.assertTrue(test.isSameAfterReversals2(78));

        Assert.assertFalse(test.isSameAfterReversals2(10));

        Assert.assertFalse(test.isSameAfterReversals2(30));

        //three

        Assert.assertFalse(test.isSameAfterReversals2(180));

        Assert.assertTrue(test.isSameAfterReversals2(181));

        Assert.assertTrue(test.isSameAfterReversals2(526));

        Assert.assertTrue(test.isSameAfterReversals2(123));

        //four

        Assert.assertFalse(test.isSameAfterReversals2(1800));

       

        //

        Assert.assertTrue(test.isSameAfterReversals2(180258941));

        Assert.assertFalse(test.isSameAfterReversals2(180258940));

    }

}

标签：assertTrue,return,数字,3595,int,反转,Assert,num,test
From： https://blog.51cto.com/fansunion/6056741

相关文章

赞助商

阅读排行