2022-01-15：中心对称数 III。 中心对称数是指一个数字在旋转了 180 度之后看起来依旧相同的数字（或者上下颠倒地看）。 写一个函数来计算范围在 [low, high] 之间中心对称数的个

Posted 2022-02-06 福大大架构师每日一题

2022-01-15：中心对称数 III。
中心对称数是指一个数字在旋转了 180 度之后看起来依旧相同的数字（或者上下颠倒地看）。
写一个函数来计算范围在 [low, high] 之间中心对称数的个数。
示例：
输入：low = “50”,high = “100”，
输出:3。
解释：69,88和96是三个在该范围内的中心对称数。
注意：
由于范围可能很大，所以low和high都用字符串表示。
来自力扣248。

答案2022-01-15：

假设low=264，high=3422。
264到999的个数x，
1000到9999的个数y,3422到9999的个数z。
sum=x+y-z。如果high本身是有效数，sum=x+y-z+1。

代码用golang编写。代码如下：

package main

import "fmt"

func main() 
    ret := strobogrammaticInRange("50", "100")
    fmt.Println(ret)


func strobogrammaticInRange(l, h string) int 
    low := []byte(l)
    high := []byte(h)
    if !equalMore(low, high) 
        return 0
    
    lowLen := len(low)
    highLen := len(high)
    if lowLen == highLen 
        up1 := up(low, 0, false, 1)
        up2 := up(high, 0, false, 1)
        return up1 - up2 + twoSelectOne(valid(high), 1, 0)
    
    ans := 0
    // lowLen = 3 hightLen = 7
    // 4 5 6
    for i := lowLen + 1; i < highLen; i++ 
        ans += all1(i)
    
    ans += up(low, 0, false, 1)
    ans += down(high, 0, false, 1)
    return ans


func equalMore(low, cur []byte) bool 
    if len(low) != len(cur) 
        return len(low) < len(cur)
    
    for i := 0; i < len(low); i++ 
        if low[i] != cur[i] 
            return low[i] < cur[i]
        
    
    return true


func valid(str []byte) bool 
    L := 0
    R := len(str) - 1
    for L <= R 
        t := L != R
        if convert2(str[L], t) != int(str[R]) 
            return false
        
        L++
        R--
    
    return true


// left想得到cha字符，right配合应该做什么决定，
// 如果left怎么也得不到cha字符，返回-1；如果能得到，返回right配合应做什么决定
// 比如，left!=right，即不是同一个位置
// left想得到0，那么就right就需要是0
// left想得到1，那么就right就需要是1
// left想得到6，那么就right就需要是9
// left想得到8，那么就right就需要是8
// left想得到9，那么就right就需要是6
// 除此了这些之外，left不能得到别的了。
// 比如，left==right，即是同一个位置
// left想得到0，那么就right就需要是0
// left想得到1，那么就right就需要是1
// left想得到8，那么就right就需要是8
// 除此了这些之外，left不能得到别的了，比如：
// left想得到6，那么就right就需要是9，而left和right是一个位置啊，怎么可能即6又9，返回-1
// left想得到9，那么就right就需要是6，而left和right是一个位置啊，怎么可能即9又6，返回-1
func convert2(cha byte, diff bool) int 
    switch cha 
    case '0':
        return '0'
    case '1':
        return '1'
    case '6':
        return twoSelectOne(diff, '9', -1)
    case '8':
        return '8'
    case '9':
        return twoSelectOne(diff, '6', -1)
    default:
        return -1
    


// low [左边已经做完决定了 left.....right 右边已经做完决定了]
// 左边已经做完决定的部分，如果大于low的原始，leftMore = true;
// 左边已经做完决定的部分，如果不大于low的原始，那一定是相等，不可能小于，leftMore = false;
// 右边已经做完决定的部分，如果小于low的原始，rightLessEqualMore = 0;
// 右边已经做完决定的部分，如果等于low的原始，rightLessEqualMore = 1;
// 右边已经做完决定的部分，如果大于low的原始，rightLessEqualMore = 2;
// rightLessEqualMore < = >
//                    0 1 2
// 返回 ：没做决定的部分，随意变，几个有效的情况？返回！
func up(low []byte, left int, leftMore bool, rightLessEqualMore int) int 
    N := len(low)
    right := N - 1 - left
    if left > right  // 都做完决定了！
        // 如果左边做完决定的部分大于原始 或者 如果左边做完决定的部分等于原始&左边做完决定的部分不小于原始
        // 有效！
        // 否则，无效！
        return twoSelectOne(leftMore || (!leftMore && rightLessEqualMore != 0), 1, 0)
    
    // 如果上面没有return，说明决定没做完，就继续做
    if leftMore  // 如果左边做完决定的部分大于原始
        return num(N - (left << 1))
     else  // 如果左边做完决定的部分等于原始
        ways := 0
        // 当前left做的决定，大于原始的left
        for cha := (low[left] + 1); cha <= '9'; cha++ 
            if convert2(cha, left != right) != -1 
                ways += up(low, left+1, true, rightLessEqualMore)
            
        
        // 当前left做的决定，等于原始的left
        convert := convert2(low[left], left != right)
        if convert != -1 
            if convert < int(low[right]) 
                ways += up(low, left+1, false, 0)
             else if convert == int(low[right]) 
                ways += up(low, left+1, false, rightLessEqualMore)
             else 
                ways += up(low, left+1, false, 2)
            
        
        return ways
    


// ll < =
// rs < = >
func down(high []byte, left int, ll bool, rs int) int 
    N := len(high)
    right := N - 1 - left
    if left > right 
        return twoSelectOne(ll || (!ll && rs != 2), 1, 0)
    
    if ll 
        return num(N - (left << 1))
     else 
        ways := 0
        for cha := byte(twoSelectOne((N != 1 && left == 0), '1', '0')); cha < high[left]; cha++ 
            if convert2(cha, left != right) != -1 
                ways += down(high, left+1, true, rs)
            
        
        convert := convert2(high[left], left != right)
        if convert != -1 
            if convert < int(high[right]) 
                ways += down(high, left+1, false, 0)
             else if convert == int(high[right]) 
                ways += down(high, left+1, false, rs)
             else 
                ways += down(high, left+1, false, 2)
            
        
        return ways
    


func num(bits int) int 
    if bits == 1 
        return 3
    
    if bits == 2 
        return 5
    
    p2 := 3
    p1 := 5
    ans := 0
    for i := 3; i <= bits; i++ 
        ans = 5 * p2
        p2 = p1
        p1 = ans
    
    return ans


// 如果是最开始 :
// Y X X X Y
// -> 1 X X X 1
// -> 8 X X X 8
// -> 9 X X X 6
// -> 6 X X X 9
// 如果不是最开始 :
// Y X X X Y
// -> 0 X X X 0
// -> 1 X X X 1
// -> 8 X X X 8
// -> 9 X X X 6
// -> 6 X X X 9
// 所有的len位数，有几个有效的？
func all1(len0 int) int 
    ans := twoSelectOne((len0&1) == 0, 1, 3)
    for i := twoSelectOne((len0&1) == 0, 2, 3); i < len0; i += 2 
        ans *= 5
    
    return ans << 2


// 我们课上讲的
func all2(len0 int, init0 bool) int 
    if len0 == 0  // init == true，不可能调用all(0)
        return 1
    
    if len0 == 1 
        return 3
    
    if init0 
        return all2(len0-2, false) << 2
     else 
        return all2(len0-2, false) * 5
    


func twoSelectOne(c bool, a, b int) int 
    if c 
        return a
     else 
        return b
    

执行结果如下：

---

左神java代码