Dado un número decimal como N , la tarea es convertir N en una fracción irreducible equivalente.
Una fracción irreducible es una fracción en la que el numerador y el denominador son coprimos, es decir, no tienen otro divisor común que no sea 1.
Ejemplos:
Entrada: N = 4,50
Salida: 9/2
Explicación:
9/2 en decimal se escribe como 4,5Entrada: N = 0,75
Salida: 3/4
Explicación:
3/4 en decimal se escribe como 0,75
Enfoque: siga los pasos que se indican a continuación para resolver el problema.
- Obtenga el valor integral y la parte fraccionaria del número decimal ‘n’.
- Considere que el valor de precisión es 10 9 para convertir la parte fraccionaria del decimal en un equivalente integral.
- Calcule el GCD del equivalente integral de la parte fraccionaria y el valor de precisión.
- Calcula el numerador dividiendo el equivalente integral de la parte fraccionaria por el valor de GCD. Calcule el denominador dividiendo el valor de precisión por el valor GCD.
- De la fracción mixta obtenida, conviértala en una fracción impropia.
Por ejemplo, N = 4,50, valor integral = 4 y parte fraccionaria = 0,50
Considere que el valor de precisión es (10 9 ), es decir, valor de precisión = 1000000000
Calcule GCD (0,50 * 10 9 , 10 9 ) = 500000000
Calcule el numerador = (0,50 * 10 ^9) / 500000000 = 1 y denominador = 10^9/ 500000000 = 2
Convertir fracción mixta en fracción impropia que es fracción = ((4 * 2) + 1) / 2 = 9/2
A continuación se muestra la implementación del enfoque anterior:
C++
// C++ program for above approach
#include <bits/stdc++.h>
using namespace std;
// Recursive function to
// return GCD of a and b
long long gcd(long long a, long long b)
{
if (a == 0)
return b;
else if (b == 0)
return a;
if (a < b)
return gcd(a, b % a);
else
return gcd(b, a % b);
}
// Function to convert decimal to fraction
void decimalToFraction(double number)
{
// Fetch integral value of the decimal
double intVal = floor(number);
// Fetch fractional part of the decimal
double fVal = number - intVal;
// Consider precision value to
// convert fractional part to
// integral equivalent
const long pVal = 1000000000;
// Calculate GCD of integral
// equivalent of fractional
// part and precision value
long long gcdVal
= gcd(round(fVal * pVal), pVal);
// Calculate num and deno
long long num
= round(fVal * pVal) / gcdVal;
long long deno = pVal / gcdVal;
// Print the fraction
cout << (intVal * deno) + num
<< "/" << deno << endl;
}
// Driver Code
int main()
{
double N = 4.5;
decimalToFraction(N);
return 0;
}
C
// C implementation of the above approach
#include <math.h>
#include <stdio.h>
int gcfFinder(int a, int b)
{ // gcf finder
int gcf = 1;
for (int i = 1; i <= a && i <= b; i++)
{
if (a % i == 0 && b % i == 0)
{
gcf = i;
}
}
return gcf;
}
int shortform(int* a, int* b)
{
for (int i = 2; i <= *a && i <= *b; i++)
{
if (*a % i == 0 && *b % i == 0)
{
*a = *a / i;
*b = *b / i;
}
}
return 0;
}
// Driver Code
int main(void)
{
// converting decimal into fraction.
double a = 4.50;
int c = 10000;
double b = (a - floor(a)) * c;
int d = (int)floor(a) * c + (int)(b + .5f);
while (1)
{
if (d % 10 == 0)
{
d = d / 10;
c = c / 10;
}
else
break;
}
int* i = &d;
int* j = &c;
int t = 0;
while (t != 1)
{
int gcf = gcfFinder(d, c);
if (gcf == 1)
{
printf("%d/%d\n", d, c);
t = 1;
}
else
{
shortform(i, j);
}
}
return 0;
}
// this code is contributed by harsh sinha username-
// harshsinha03
Java
// Java program for the above approach
import java.util.*;
class GFG{
// Recursive function to
// return GCD of a and b
static long gcd(long a, long b)
{
if (a == 0)
return b;
else if (b == 0)
return a;
if (a < b)
return gcd(a, b % a);
else
return gcd(b, a % b);
}
// Function to convert decimal to fraction
static void decimalToFraction(double number)
{
// Fetch integral value of the decimal
double intVal = Math.floor(number);
// Fetch fractional part of the decimal
double fVal = number - intVal;
// Consider precision value to
// convert fractional part to
// integral equivalent
final long pVal = 1000000000;
// Calculate GCD of integral
// equivalent of fractional
// part and precision value
long gcdVal = gcd(Math.round(
fVal * pVal), pVal);
// Calculate num and deno
long num = Math.round(fVal * pVal) / gcdVal;
long deno = pVal / gcdVal;
// Print the fraction
System.out.println((long)(intVal * deno) +
num + "/" + deno);
}
// Driver Code
public static void main(String s[])
{
double N = 4.5;
decimalToFraction(N);
}
}
// This code is contributed by rutvik_56
Python3
# Python3 program for the above approach from math import floor # Recursive function to # return GCD of a and b def gcd(a, b): if (a == 0): return b elif (b == 0): return a if (a < b): return gcd(a, b % a) else: return gcd(b, a % b) # Function to convert decimal to fraction def decimalToFraction(number): # Fetch integral value of the decimal intVal = floor(number) # Fetch fractional part of the decimal fVal = number - intVal # Consider precision value to # convert fractional part to # integral equivalent pVal = 1000000000 # Calculate GCD of integral # equivalent of fractional # part and precision value gcdVal = gcd(round(fVal * pVal), pVal) # Calculate num and deno num= round(fVal * pVal) // gcdVal deno = pVal // gcdVal # Print the fraction print((intVal * deno) + num, "/", deno) # Driver Code if __name__ == '__main__': N = 4.5 decimalToFraction(N) # This code is contributed by mohit kumar 29
C#
// C# program for the above approach
using System;
class GFG{
// Recursive function to
// return GCD of a and b
static long gcd(long a, long b)
{
if (a == 0)
return b;
else if (b == 0)
return a;
if (a < b)
return gcd(a, b % a);
else
return gcd(b, a % b);
}
// Function to convert decimal to fraction
static void decimalToFraction(double number)
{
// Fetch integral value of the decimal
double intVal = Math.Floor(number);
// Fetch fractional part of the decimal
double fVal = number - intVal;
// Consider precision value to
// convert fractional part to
// integral equivalent
long pVal = 1000000000;
// Calculate GCD of integral
// equivalent of fractional
// part and precision value
long gcdVal = gcd((long)Math.Round(
fVal * pVal), pVal);
// Calculate num and deno
long num = (long)Math.Round(fVal * pVal) / gcdVal;
long deno = pVal / gcdVal;
// Print the fraction
Console.WriteLine((long)(intVal * deno) +
num + "/" + deno);
}
// Driver Code
public static void Main(String []s)
{
double N = 4.5;
decimalToFraction(N);
}
}
// This code is contributed by PrinciRaj1992
Javascript
<script>
// Javascript program to implement
// the above approach
// Recursive function to
// return GCD of a and b
function gcd(a, b)
{
if (a == 0)
return b;
else if (b == 0)
return a;
if (a < b)
return gcd(a, b % a);
else
return gcd(b, a % b);
}
// Function to convert decimal to fraction
function decimalToFraction(number)
{
// Fetch letegral value of the decimal
let letVal = Math.floor(number);
// Fetch fractional part of the decimal
let fVal = number - letVal;
// Consider precision value to
// convert fractional part to
// letegral equivalent
let pVal = 1000000000;
// Calculate GCD of letegral
// equivalent of fractional
// part and precision value
let gcdVal = gcd(Math.round(
fVal * pVal), pVal);
// Calculate num and deno
let num = Math.round(fVal * pVal) / gcdVal;
let deno = pVal / gcdVal;
// Print the fraction
document.write((letVal * deno) +
num + "/" + deno);
}
// Driver Code
let N = 4.5;
decimalToFraction(N);
</script>
Producción:
9/2
Complejidad temporal: O(log min(a, b))
Espacio auxiliar: O(1)
Publicación traducida automáticamente
Artículo escrito por anjalidivitha y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA