Lo que debe hacer es crear una función / programa que tome un decimal como entrada y genere el resultado de tomar repetidamente el recíproco de la parte fraccionaria del número, hasta que el número se convierta en un entero.

Más específicamente, el proceso es el siguiente:

1. Deje x ser la entrada

2. Si x es un entero, envíelo.

3. De lo contrario: . Regrese a 2.$x \leftarrow \frac{1}{\mathrm{frac}(x)}$

$\mathrm{frac}(x)$x x - ⌊ x ⌋ ⌊ x ⌋ x es el componente fraccionario de , y es igual a . es el piso de x, que es el mayor entero menor que .$x$$x - \left\lfloor x \right\rfloor$$\left\lfloor x \right\rfloor$$x$

Casos de prueba:

0 = 0
0.1 = 1/10 -> 10
0.2 = 1/5 -> 5
0.3 = 3/10 -> 10/3 -> 1/3 -> 3
0.4 = 2/5 -> 5/2 -> 1/2 -> 2
0.5 = 1/2 -> 2
0.6 = 3/5 -> 5/3 -> 2/3 -> 3/2 -> 1/2 -> 2
0.7 = 7/10 -> 10/7 -> 3/7 -> 7/3 -> 1/3 -> 3
0.8 = 4/5 -> 5/4 -> 1/4 -> 4
0.9 = 9/10 -> 10/9 -> 1/9 -> 9
1 = 1
3.14 = 157/50 -> 7/50 -> 50/7 -> 1/7 -> 7
6.28 = 157/25 -> 7/25 -> 25/7 -> 4/7 -> 7/4 -> 3/4 -> 4/3 -> 1/3 -> 3

Resumen de 0 a 1 en incrementos de 0.1: 0, 10, 5, 3, 2, 2, 2, 3, 4, 9, 1

Este es el código de golf , por lo que gana menos bytes.

Aclaraciones:

• "Puntos de bonificación" sin error de redondeo
• Debería funcionar para cualquier número racional no negativo (ignorando el error de redondeo)
• Puede, pero no tiene que dar salida a los pasos dados
• Puede tomar la entrada como un decimal, fracción o par de números, que pueden estar en una cadena.

Perdón por todos los problemas, esta es mi primera pregunta en este sitio web.

J, 18 bytes

%@(-<.)^:(~:<.)^:_

En J, el idioma u ^: v ^:_significa "Sigue aplicando el verbo umientras la condición vdevuelve verdadero.

En nuestro caso, la condición final está definida por el gancho ~:<., lo que significa "el piso del número <.no es igual ~:al número mismo", por lo que nos detendremos cuando el verbo principal udevuelva un int.

uen este caso hay otro gancho -<., el número menos su piso, cuyo valor de retorno se alimenta al @verbo recíproco %.

Pruébalo en línea!

Python 3 , 101 bytes

lambda s:g(int(s.replace(".","")),10**s[::-1].index("."))
g=lambda a,b:a and(b%a and g(b%a,a)or b//a)

Pruébalo en línea!

Formato: la cadena debe contener un punto decimal.

Mathematica, 36 bytes

Last@*ContinuedFraction@*Rationalize

Manifestación

In[1]:= f = Last@*ContinuedFraction@*Rationalize

Out[1]= Last @* ContinuedFraction @* Rationalize

In[2]:= f[0]

Out[2]= 0

In[3]:= f[0.1]

Out[3]= 10

In[4]:= f[0.2]

Out[4]= 5

In[5]:= f[0.3]

Out[5]= 3

In[6]:= f[0.4]

Out[6]= 2

In[7]:= f[0.5]

Out[7]= 2

In[8]:= f[0.6]

Out[8]= 2

In[9]:= f[0.7]

Out[9]= 3

In[10]:= f[0.8]

Out[10]= 4

In[11]:= f[0.9]

Out[11]= 9

In[12]:= f[1]

Out[12]= 1

Perl 6 , 42 bytes

{($_,{1/($_-.floor)}...*.nude[1]==1)[*-1]}

Pruébalo en línea!

El nudemétodo devuelve el nu merator y de denominador de un número racional como una lista de dos elementos. Es más corto obtener el denominador de esta manera que llamar al denominatormétodo directamente.

Haskell , 47 bytes

Esto supera la respuesta de Wheat Wizard porque GHC.Realnos permite crear patrones de coincidencia en racionales usando :%, además de tener un nombre más corto

import GHC.Real
f(x:%1)=x
f x=f$1/(x-floor x%1)

Pruébalo en línea!

ftoma un Rationalnúmero como entrada, aunque ghc permite que se escriban en formato decimal, con cierta precisión.

Haskell , 40 34 bytes

Editar:

• -6 bytes: @WheatWizard señaló que la fracción probablemente se puede dar como dos argumentos separados.

(No pude resistir publicar esto después de ver las respuestas de Haskell con importaciones detalladas; ahora veo que algunas respuestas en otros idiomas también utilizan esencialmente este método).

!toma dos argumentos enteros (numerador y denominador de la fracción; no es necesario que estén en términos más pequeños, pero el denominador debe ser positivo) y devuelve un entero. Llamar como 314!100.

n!d|m<-mod n d,m>0=d!m|0<1=div n d

Pruébalo en línea!

• Ignorando el desajuste de tipo, la parte fraccional de n/d(suponiendo dpositiva) es mod n d/d, por lo tanto mod n d==0, a menos que !vuelva a aparecer con una representación de d/mod n d.

Python 3 + sympy , 67 bytes

from sympy import*
k=Rational(input())
while k%1:k=1/(k%1)
print(k)

Pruébalo en línea!

Sympy es un paquete matemático simbólico para Python. Debido a que es simbólico y no binario, no hay imprecisiones de coma flotante.

PHP , 69 bytes

for(;round(1e9*$a=&$argn)/1e9!=$o=round($a);)$a=1/($a-($a^0));echo$o;

Pruébalo en línea!

PHP , 146 bytes

for($f=.1;(0^$a=$argn*$f*=10)!=$a;);for(;1<$f;)($x=($m=max($a,$f))%$n=min($a,$f))?[$f=$n,$a=$x]:$f=!!$a=$m/$n;echo($o=max($a,$f))>1?$o:min($a,$f);

Pruébalo en línea!

Jalea , 8 bytes

®İ$%1$©¿

Pruébalo en línea!

Imprecisiones de punto flotante.

JavaScript ES6, 25 bytes

f=(a,b)=>a%b?f(b,a%b):a/b

Llame f(a,b)paraa/b

Haskell , 62 61 bytes

import Data.Ratio
f x|denominator x==1=x|u<-x-floor x%1=f$1/u

Pruébalo en línea!

Utiliza la Data.Ratiobiblioteca de Haskell para racionalidades arbitrarias de precisión. Si tan solo los nombres incorporados no fueran tan largos.

APL (Dyalog Classic) , 18 bytes

{1e¯9>t←1|⍵:⍵⋄∇÷t}

Pruébalo en línea!

NARS APL, 18 caracteres

-1 byte gracias a la prueba de Uriel

f←{1e¯9>t←1|⍵:⍵⋄∇÷t}
v←0 .1 .2 .3 .4 .5 .6 .7 .8 .9 1 3.14
⎕←v,¨f¨v
  0 0  0.1 10  0.2 5  0.3 3  0.4 2  0.5 2  0.6 2  0.7 3  0.8 4  0.9 9  1 1  3.14 7 

Smalltalk, 33 bytes

[(y:=x\\1)>0]whileTrue:[x:=1/y].x

Stax , 8 bytes

ç▄é⌠á◙àù

Ejecutar y depurarlo

"Puntos de bonificación" sin errores de precisión. No se utiliza aritmética de coma flotante. Esto (finalmente) hace uso del tipo racional incorporado de Stax.

JavaScript, 70 bytes

x=>(y=(x+'').slice(2),p=(a,b)=>b?a%b?p(b,a%b):a/b:0,p(10**y.length,y))

Si podemos cambiar el tipo de entrada a una cadena, entonces puede ahorrar 5 bytes.