计算给定范围内顺时针旋转 180 度时对称的数字

给定一个范围 [L, R)，任务是计算顺时针旋转 180 度时保持不变的数字。

例子：

Input: L = 0, R =10 
Output: 3
Explanation: Here between 0 and 10 ( 10 exclusive) the desired numbers are: 0, 1, and 8. 
Notice 6 and 9 are not included because, when 6 is rotated 180 degree it’s value changes to 9.
Same happens for 9, its value changes to 6. So the answer is 3.

Input: L = 0, R =100 
Output: 7
Explanation: The numbers are 0, 1, 8, 11, 69, 88, 96. 
These numbers when rotated 180 degrees, their values remain unchanged.

方法：这种方法是基于实现的。使用函数来检查一个数字是否是上行数字，并在范围内迭代并计算满足给定条件的总数。

• 用0初始化“结果”变量。
• 首先迭代范围[L, R) 。
• 保留一个字典，其中包含所有个位数的数字，这些数字在旋转180 度时形成有效数字。（如 6 变为 9）
• 在每次迭代中检查数字是否满足问题的给定条件：
  • 检查数字的数字是否在字典中。
  • 如果不是，则返回False 。
  • 如果它是字典的一部分，则检查其相反的索引元素是否相同。
    • 如果不是，则返回False 。
  • 如果一切都匹配，则返回 true。
• 如果是，则将“结果”变量增加1 。

下面是上述方法的实现。

C++

// C++ program to implement the approach
#include
using namespace std;
 
// Function to check if a number is same
// when rotated 180 degrees
bool Check_Upside_Down(string n){
  unordered_map Dict;
  Dict['0'] = '0';
  Dict['1'] = '1';
  Dict['6'] = '9';
  Dict['8'] = '8';
  Dict['9'] = '6';
 
  for(int x = 0; x < n.length(); x++) {
 
    if (Dict.find(n[x]) == Dict.end())
      return false;
    if (Dict[n[x]] != n[n.length() - x - 1])
      return false;
  }
  return true;
}
 
// Function to find total count of numbers
// having same value when rotated 180 degrees
int Total_Upside_Number(int L,int R){
  int res = 0;
  for (int i = L; i < R; ++i){
    if (Check_Upside_Down(to_string(i)))
      res += 1;
  }
  return res;
}
 
// Driver code
int main(){
 
  int L = 0;
  int R = 10;
  int ans = Total_Upside_Number(L, R);
  cout << ans << endl;
 
}
 
// This code is contributed by shinjanpatra

Python

# Python program to implement the approach
 
# Function to check if a number is same
# when rotated 180 degrees
def Check_Upside_Down(n):
    Dict = {"0": "0", "1": "1", "6": "9", \
            "8": "8", "9": "6"}
    for x, y in enumerate(n):
        if y not in Dict:
            return False
        if Dict[y] != n[-x-1]:
            return False
    return True
 
# Function to find total count of numbers
# having same value when rotated 180 degrees
def Total_Upside_Number(L, R):
    res = 0
    for i in range(L, R):
        if Check_Upside_Down(str(i)):
            res += 1
    return res
 
# Driver code
if __name__ == "__main__":
    L = 0
    R = 10
    ans = Total_Upside_Number(L, R)
    print(ans)

Javascript

    // JavaScript program to implement the approach
 
    // Function to check if a number is same
    // when rotated 180 degrees
    const Check_Upside_Down = (n) => {
        let Dict = { "0": "0", "1": "1", "6": "9", "8": "8", "9": "6" }
        for (let x = 0; x < n.length; ++x) {
            if (!(n[x] in Dict))
                return false;
            if (Dict[n[x]] != n[n.length - x - 1])
                return false;
        }
        return true;
    }
 
    // Function to find total count of numbers
    // having same value when rotated 180 degrees
    const Total_Upside_Number = (L, R) => {
        let res = 0
        for (let i = L; i < R; ++i)
            if (Check_Upside_Down(i.toString()))
                res += 1
        return res
    }
 
    // Driver code
    let L = 0;
    let R = 10;
    let ans = Total_Upside_Number(L, R);
    document.write(ans);
 
// This code is contributed by rakeshsahni
 

输出

3

时间复杂度： O((R – L)*d) 其中 d 是 [L, R) 范围内数字的最大位数
辅助空间： O(1)

使用 maketras() 和 translate()：上述方法的开销是我们必须编写迭代数字的方法，并一一检查旋转 180 度时是否相同。在Python中，一些方法使这种转换易于编码。在这种方法中，使用字符串的 maketras() 和 translate()函数可以简化工作。

1. 已设置所有个位数字的s1 ，这些数字在旋转 180 度时会给出另一个有效数字。
2. 备有适当编号的转换表，以便更换。
3. 迭代范围[L, R) 。
4. 在每次迭代中将数字转换为字符集。
5. 检查该集合是否是s1的子集。
6. 如果不是，则继续迭代。
7. 如果它是s1的子集，则：
   1. 在转换表的帮助下翻译所有数字。
   2. 然后将其与先前的数字匹配。
   3. 如果不匹配，继续迭代。
   4. 如果匹配，则将count 增加 1 。

下面是上述方法的实现：

Python3

# Python program to implement the approach
 
# Function to calculate the total count
# of required numbers using
# maketrans() and translate()
def Total_Upside_number(L, R):
    s1 = {"0", "1", "6", "8", "9"}
    transition = str.maketrans("69", "96")
    result = 0
    for i in range(L, R):
        num = str(i)
        if set(num).issubset(s1):
            temp = num[::-1].translate(transition)
            if num == temp:
                result += 1
    return result
 
# Driver code
if __name__ == "__main__":
    L = 0
    R = 10
    ans = Total_Upside_number(L, R)
    print(ans)

输出

3

时间复杂度： O((R – L)*d) 其中 d 是 [L, R) 范围内数字的最大位数
辅助空间： O(1)