Cuente números en un rango dado que son simétricos cuando se giran 180 grados en el sentido de las agujas del reloj

Dado un rango [L, R), la tarea es contar los números que permanecen sin cambios cuando se giran 180 grados en el sentido de las agujas del reloj.

Ejemplos:

Entrada: L = 0, R =10 
Salida: 3
Explicación: Aquí entre 0 y 10 (10 exclusivo) los números deseados son: 0, 1 y 8. 
Observe que 6 y 9 no están incluidos porque, cuando 6 se gira 180 grados su valor cambia a 9.
Lo mismo sucede con 9, su valor cambia a 6. Entonces la respuesta es 3.

Entrada: L = 0, R =100 
Salida: 7
Explicación: Los números son 0, 1, 8, 11, 69, 88, 96. 
Estos números cuando se giran 180 grados, sus valores permanecen sin cambios.

Enfoque: Este enfoque se basa en la implementación. Use una función para verificar si un número es un número al revés o no e itere sobre el rango y calcule los números totales que satisfacen la condición dada.

• Inicialice la variable «resultado» con 0 .
• Primero iterar sobre el rango [L, R) .
• Mantenga un diccionario que tenga todos los números de un solo dígito que forman un número válido cuando se giran 180 grados (como 6 se convierte en 9)
• En cada iteración, compruebe si el número satisface la condición dada del problema:
  • Comprueba si los dígitos de un número están en el diccionario o no.
  • Si no , devuelve False .
  • Si es parte del diccionario , verifique que su elemento indexado opuesto sea el mismo o no.
    • Si no , devuelve False .
  • Si todo coincide, devuelve verdadero.
• Si es así, entonces incremente la variable «resultado» en 1 .

A continuación se muestra la implementación del enfoque anterior.

// C++ program to implement the approach
#include<bits/stdc++.h>
using namespace std;
 
// Function to check if a number is same
// when rotated 180 degrees
bool Check_Upside_Down(string n){
  unordered_map<char,char> 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

// Java program to implement the approach
import java.util.*;
 
class GFG{
 
// Function to check if a number is same
// when rotated 180 degrees
static boolean Check_Upside_Down(String n){
   
  HashMap<Character,Character> Dict = new HashMap<Character,Character>();
  Dict.put('0', '0');
  Dict.put('1', '1');
  Dict.put('6', '9');
  Dict.put('8', '8');
  Dict.put('9', '6');
 
  for(int x = 0; x < n.length(); x++) {
 
    if (!Dict.containsKey(n.charAt(x)))
      return false;
    if (Dict.get(n.charAt(x))!= n.charAt(n.length() - x - 1))
      return false;
  }
  return true;
}
 
// Function to find total count of numbers
// having same value when rotated 180 degrees
static int Total_Upside_Number(int L,int R){
  int res = 0;
  for (int i = L; i < R; ++i){
    if (Check_Upside_Down(String.valueOf(i)))
      res += 1;
  }
  return res;
}
 
// Driver code
public static void main(String[] args){
 
  int L = 0;
  int R = 10;
  int ans = Total_Upside_Number(L, R);
  System.out.print(ans +"\n");
 
}
 
}
// This code contributed by shikhasingrajput

# 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)

// C# program to implement the approach
using System;
using System.Collections.Generic;
 
public class GFG{
 
// Function to check if a number is same
// when rotated 180 degrees
static bool Check_Upside_Down(String n){
   
  Dictionary<char,char> Dict = new Dictionary<char,char>();
  Dict.Add('0', '0');
  Dict.Add('1', '1');
  Dict.Add('6', '9');
  Dict.Add('8', '8');
  Dict.Add('9', '6');
 
  for(int x = 0; x < n.Length; x++) {
 
    if (!Dict.ContainsKey(n[x]))
      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
static int Total_Upside_Number(int L,int R){
  int res = 0;
  for (int i = L; i < R; ++i){
    if (Check_Upside_Down(String.Join("",i)))
      res += 1;
  }
  return res;
}
 
// Driver code
public static void Main(String[] args){
 
  int L = 0;
  int R = 10;
  int ans = Total_Upside_Number(L, R);
  Console.Write(ans +"\n");
 
}
}
 
// This code is contributed by shikhasingrajput

<script>
    // 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
 
</script>

3

Complejidad de tiempo: O((R – L)*d) donde d es el número máximo de dígitos en un número en el rango [L, R)
Espacio auxiliar: O(1)

Usando maketras() y translate(): La sobrecarga con el método anterior es que tenemos que escribir el método que itera sobre el número y verificar uno por uno que es el mismo cuando se gira 180 grados. En Python, algunos métodos facilitan la codificación de esta transición. En este enfoque, use la función maketras() y translate( ) de string que facilita el trabajo. 

1. Ha establecido s1 de todos los números de un solo dígito que dan otro número válido cuando se giran 180 grados.
2. Tenga una tabla de transición preparada con el número adecuado para su reemplazo.
3. Iterar sobre el rango [L, R) .
4. En cada iteración, convierta el número en un conjunto de caracteres.
5. Compruebe si el conjunto es un subconjunto de s1 o no.
6. Si no es así, continúe con la iteración.
7. Si es un subconjunto de s1 entonces:
   1. Traduce todos los números con la ayuda de la tabla de transición .
   2. Luego emparéjalo con el número anterior .
   3. Si no coincide, continúe con la iteración .
   4. si coincide, aumente la cuenta en 1 .

A continuación se muestra la implementación del enfoque anterior:

# 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

Complejidad de tiempo: O((R – L)*d) donde d es el número máximo de dígitos en un número en el rango [L, R)
Espacio auxiliar: O(1)