3的幂

给定一个整数，写一个函数来判断它是否是 3 的幂次方。

示例 1:

1
2
输入: 27
输出: true

示例 2:

1
2
输入: 0
输出: false

示例 3:

1
2
输入: 9
输出: true

示例 4:

1
2
输入: 45
输出: false

进阶：
你能不使用循环或者递归来完成本题吗？

代码

循环

1
2
3
4
5
6
7
8
9
10
public boolean isPowerOfThree(int n) {
    //如果n小于1直接返回false
    if(n<1)return false;
    //除尽之后肯定为1
    while(n>1){
        if(n%3!=0)return false;
        n/=3;
    }
    return true;
}

进阶

正则匹配

在2的幂中，我们使用了Integer的BitCount方法来得到位1的个数来判断，但是这里行不通了，需要考虑新方法，Integer中有个toString(int i,int radix)方法，该方法的作用是将int整数转成指定进制数的字符串，这也算是一个方法，但效率不理想

1
2
3
4
5
6
7
public boolean isPowerOfThree(int n) {
    if (n < 1) return false;
    //将n转化为3进制的字符串
    String num = Integer.toString(n, 3);
    //利用正则判断
    return num.matches("[1][0]*");
}

死方法

将int范围内的所有3的幂写出来，个数当然是有限的。记得之前看到过一句话，不要被算法的外表所迷惑，归根结底，我们要的是性能(就算这种方法很蠢)，而不是太多技巧，就算以后升级也是int之外的其他数据类型的重载。遗憾的是这个方法在性能上并没有优势，总之也算是一个没有使用循环和递归的方法吧。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
public boolean isPowerOfThree(int n) {
    switch (n){
        case 1:
            return true;
        case 3:
            return true;
        case 9:
            return true;
        case 27:
            return true;
        case 81:
            return true;
        case 243:
            return true;
        case 729:
            return true;
        case 2187:
            return true;
        case 6561:
            return true;
        case 19683:
            return true;
        case 59049:
            return true;
        case 177147:
            return true;
        case 531441:
            return true;
        case 1594323:
            return true;
        case 4782969:
            return true;
        case 14348907:
            return true;
        case 43046721:
            return true;
        case 129140163:
            return true;
        case 387420489:
            return true;
        case 1162261467:
            return true;
        default:
            return false;
    }
}