反转 一个整数意味着倒置它的所有位。
例如，反转 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));
}
}
