276反转两次的数字

Posted huoyingfans

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了276反转两次的数字相关的知识,希望对你有一定的参考价值。

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

例如,反转 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 wen.lei@brgroup.com

 *

 *         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 wen.lei@brgroup.com

 *

 *         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 wen.lei@brgroup.com

 *

 *         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));

    

以上是关于276反转两次的数字的主要内容,如果未能解决你的问题,请参考以下文章

3595反转两次的数字

3595反转两次的数字

LeetCode 2119. 反转两次的数字

剑指offer数组中仅仅出现一次的数字

剑指offer数组中仅仅出现一次的数字

剑指offer数组中仅仅出现一次的数字