Conteo de pares en un rango dado que tienen su razón igual a la razón del producto de sus dígitos

Dados dos números enteros L y R , la tarea es encontrar el número de pares desordenados de números enteros (A, B) en el rango [L, R] tal que la razón de A y B sea la misma que la razón del producto de dígitos de A y el producto de dígitos de B.

Ejemplos:

Entrada: L = 10, R = 50
Salida: 2
Explicación: Los pares en el rango [10, 50] que siguen la condición dada son (15, 24) como 15 : 24 = 5 : 8 ≡ (1*5) : (2*4) = 5 : 8 y (18, 45) como 18 : 45 = 2 : 5 ≡ (1*8) : (4*5) = 8 : 20 = 2 : 5.

Entrada: L = 1, R = 100
Salida: 43

Enfoque: El problema dado se puede resolver siguiendo los pasos que se describen a continuación:

Crear una función para calcular el producto de los dígitos de un número .
Iterar sobre todos los pares desordenados de enteros en el rango [L, R] usando a y b para cada par (a, b), a : b es equivalente al producto de dígitos de a : producto de dígitos de b si y solo si a * producto de dígitos de b = b * producto de dígitos de a .
Utilizando la observación anterior, mantenga el recuento de los pares válidos de (a, b) en una variable cntPair tal que a * producto de dígitos de b = b * producto de dígitos de a .
Después de completar los pasos anteriores, imprima el valor de cntPair como resultado.

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

C++

// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the product of
// digits of the given number
int getProduct(int n)
{
    int product = 1;
    while (n != 0) {
        product = product * (n % 10);
        n = n / 10;
    }
    return product;
}
 
// Function to find the count of pairs
// (a, b) such that a:b = (product of
// digits of a):(product of digits of b)
int countPairs(int L, int R)
{
    // Stores the count of the valid pairs
    int cntPair = 0;
 
    // Loop to iterate over all unordered
    // pairs (a, b)
    for (int a = L; a <= R; a++) {
        for (int b = a + 1; b <= R; b++) {
 
            // Stores the product of
            // digits of a
            int x = getProduct(a);
 
            // Stores the product of
            // digits of b
            int y = getProduct(b);
 
            // If x!=0 and y!=0 and a:b
            // is equivalent to x:y
            if (x && y && (a * y) == (b * x)) {
 
                // Increment valid pair count
                cntPair++;
            }
        }
    }
 
    // Return Answer
    return cntPair;
}
 
// Driver code
int main()
{
    int L = 1;
    int R = 100;
 
    // Function Call
    cout << countPairs(1, 100);
    return 0;
}

Java

// Java program for the above approach
class GFG{
 
// Function to find the product of
// digits of the given number
public static int getProduct(int n)
{
    int product = 1;
    while (n != 0) {
        product = product * (n % 10);
        n = n / 10;
    }
    return product;
}
 
// Function to find the count of pairs
// (a, b) such that a:b = (product of
// digits of a):(product of digits of b)
public static int countPairs(int L, int R)
{
    // Stores the count of the valid pairs
    int cntPair = 0;
 
    // Loop to iterate over all unordered
    // pairs (a, b)
    for (int a = L; a <= R; a++) {
        for (int b = a + 1; b <= R; b++) {
 
            // Stores the product of
            // digits of a
            int x = getProduct(a);
 
            // Stores the product of
            // digits of b
            int y = getProduct(b);
 
            // If x!=0 and y!=0 and a:b
            // is equivalent to x:y
            if (x !=0  && y != 0 && (a * y) == (b * x)) {
 
                // Increment valid pair count
                cntPair++;
            }
        }
    }
 
    // Return Answer
    return cntPair;
}
 
// Driver code
public static void  main(String args[])
{
    int L = 1;
    int R = 100;
 
    // Function Call
    System.out.println(countPairs(L, R));
}
 
}
 
// This code is contributed by _saurabh_jaiswal.

Python3

# Python 3 program for the above approach
 
# Function to find the product of
# digits of the given number
def getProduct(n):
    product = 1
    while (n != 0):
        product = product * (n % 10)
        n = n // 10
    return product
 
# Function to find the count of pairs
# (a, b) such that a:b = (product of
# digits of a):(product of digits of b)
def countPairs(L, R):
    # Stores the count of the valid pairs
    cntPair = 0
 
    # Loop to iterate over all unordered
    # pairs (a, b)
    for a in range(L,R+1,1):
        for b in range(a + 1,R+1,1):
            # Stores the product of
            # digits of a
            x = getProduct(a)
 
            # Stores the product of
            # digits of b
            y = getProduct(b)
 
            # If x!=0 and y!=0 and a:b
            # is equivalent to x:y
            if (x and y and (a * y) == (b * x)):
                # Increment valid pair count
                cntPair += 1
 
    # Return Answer
    return cntPair
 
# Driver code
if __name__ == '__main__':
    L = 1
    R = 100
 
    # Function Call
    print(countPairs(1, 100))
     
    # This code is contributed by SURENDRA_GANGWAR.

C#

// C# program for the above approach
using System;
 
public class GFG{
 
    // Function to find the product of
    // digits of the given number
    public static int getProduct(int n)
    {
        int product = 1;
        while (n != 0) {
            product = product * (n % 10);
            n = n / 10;
        }
        return product;
    }
 
    // Function to find the count of pairs
    // (a, b) such that a:b = (product of
    // digits of a):(product of digits of b)
    public static int countPairs(int L, int R)
    {
        // Stores the count of the valid pairs
        int cntPair = 0;
     
        // Loop to iterate over all unordered
        // pairs (a, b)
        for (int a = L; a <= R; a++) {
            for (int b = a + 1; b <= R; b++) {
     
                // Stores the product of
                // digits of a
                int x = getProduct(a);
     
                // Stores the product of
                // digits of b
                int y = getProduct(b);
     
                // If x!=0 and y!=0 and a:b
                // is equivalent to x:y
                if (x !=0  && y != 0 && (a * y) == (b * x)) {
     
                    // Increment valid pair count
                    cntPair++;
                }
            }
        }
     
        // Return Answer
        return cntPair;
    }
 
    // Driver code
    public static void Main(string []args)
    {
        int L = 1;
        int R = 100;
     
        // Function Call
        Console.WriteLine(countPairs(L, R));
    }
 
}
 
// This code is contributed by AnkThon

Javascript

<script>
        // JavaScript Program to implement
        // the above approach
 
 
        // Function to find the product of
        // digits of the given number
        function getProduct(n) {
            let product = 1;
            while (n != 0) {
                product = product * (n % 10);
                n = Math.floor(n / 10);
            }
            return product;
        }
 
        // Function to find the count of pairs
        // (a, b) such that a:b = (product of
        // digits of a):(product of digits of b)
        function countPairs(L, R) {
            // Stores the count of the valid pairs
            let cntPair = 0;
 
            // Loop to iterate over all unordered
            // pairs (a, b)
            for (let a = L; a <= R; a++) {
                for (let b = a + 1; b <= R; b++) {
 
                    // Stores the product of
                    // digits of a
                    let x = getProduct(a);
 
                    // Stores the product of
                    // digits of b
                    let y = getProduct(b);
 
                    // If x!=0 and y!=0 and a:b
                    // is equivalent to x:y
                    if (x && y && (a * y) == (b * x)) {
 
                        // Increment valid pair count
                        cntPair++;
                    }
                }
            }
 
            // Return Answer
            return cntPair;
        }
 
        // Driver code
 
        let L = 1;
        let R = 100;
 
        // Function Call
        document.write(countPairs(1, 100));
 
// This code is contributed by Potta Lokesh
 
    </script>

Producción:

Complejidad de tiempo: O(N ² *log N) donde N representa el número de enteros en el rango dado, es decir, R – L.
Espacio auxiliar: O(1)

Publicación traducida automáticamente

Artículo escrito por rakeshsahni y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

C++

Java

Python3

C#

Javascript

Deja una respuesta Cancelar la respuesta