Quello che devi fare è creare una funzione / programma che accetta un decimale come input e produce il risultato di prendere ripetutamente il reciproco della parte frazionaria del numero, fino a quando il numero diventa un numero intero.

Più specificamente, il processo è il seguente:

1. Lascia che x sia l'input

2. Se x è un numero intero, emettilo.

3. Altrimenti: . Torna a 2.$x \leftarrow \frac{1}{\mathrm{frac}(x)}$

$\mathrm{frac}(x)$ è il componente frazionario di , ed è uguale a . è il piano di x, che è il numero intero maggiore inferiore a .$x$$x - \left\lfloor x \right\rfloor$$\left\lfloor x \right\rfloor$$x$

Casi test:

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

Riepilogo da 0 a 1 con incrementi di 0,1: 0, 10, 5, 3, 2, 2, 2, 3, 4, 9, 1

Questo è code-golf , quindi vince meno byte.

chiarimenti:

• "Punti bonus" per nessun errore di arrotondamento
• Dovrebbe funzionare per qualsiasi numero razionale non negativo (ignorando l'errore di arrotondamento)
• È possibile, ma non è necessario emettere i passaggi effettuati
• Puoi prendere l'input come decimale, frazione o coppia di numeri, che possono essere in una stringa.

Ci scusiamo per tutti i problemi, questa è la mia prima domanda su questo sito web.

J, 18 byte

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

In J, il linguaggio u ^: v ^:_significa "Continua ad applicare il verbo umentre la condizione vritorna vera.

Nel nostro caso, la condizione finale è definita dal gancio ~:<., che significa "il piano del numero <.non è uguale ~:al numero stesso" - quindi ci fermeremo quando il verbo principale urestituisce un int.

uin questo caso c'è un altro hook -<.- il numero meno il suo floor - il cui valore di ritorno viene inserito @nel verbo reciproco %.

Provalo online!

Python 3 , 101 byte

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)

Provalo online!

Formato: la stringa deve contenere un punto decimale.

Mathematica, 36 byte

Last@*ContinuedFraction@*Rationalize

dimostrazione

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 byte

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

Provalo online!

Il nudemetodo restituisce il nu merator e il de nominator di un numero razionale come un elenco di due elementi. È più breve ottenere il denominatore in questo modo che chiamare denominatordirettamente il metodo.

Haskell , 47 byte

Questo batte la risposta di Wheat Wizard perché GHC.Realci consente di modellare la corrispondenza sui razionali usando :%, oltre ad avere un nome più breve

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

Provalo online!

faccetta un Rationalnumero come input, sebbene ghc consenta loro di essere scritti in un formato decimale, con una certa precisione.

Haskell , 40 34 byte

Modificare:

• -6 byte: @WheatWizard ha sottolineato che la frazione può probabilmente essere data come due argomenti separati.

(Non ho potuto resistere alla pubblicazione di questo dopo aver visto le risposte di Haskell con importazioni dettagliate - ora vedo che alcune risposte in altre lingue usano essenzialmente questo metodo.)

!accetta due argomenti interi (numeratore e denominatore della frazione; non devono essere in termini più piccoli ma il denominatore deve essere positivo) e restituisce un numero intero. Chiama come 314!100.

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

Provalo online!

• Ignorando la mancata corrispondenza del tipo, la parte frazionaria di n/d(presupponendo dpositivo) è mod n d/d, quindi mod n d==0, a meno che , non venga !ripetuta con una rappresentazione di d/mod n d.

Python 3 + sympy , 67 byte

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

Provalo online!

Sympy è un pacchetto matematico simbolico per Python. Poiché è simbolico e non binario, non ci sono imprecisioni in virgola mobile.

PHP , 69 byte

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

Provalo online!

PHP , 146 byte

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

Provalo online!

Gelatina , 8 byte

®İ$%1$©¿

Provalo online!

Inesattezze in virgola mobile.

JavaScript ES6, 25 byte

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

Chiama f(a,b)pera/b

Haskell , 62 61 byte

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

Provalo online!

Utilizza la Data.Ratiolibreria di Haskell per razionali arbitrari di precisione. Se solo i nomi predefiniti non fossero così lunghi.

APL (Dyalog Classic) , 18 byte

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

Provalo online!

APL NARS, 18 caratteri

-1 byte grazie al test 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 byte

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

Stax , 8 byte

ç▄é⌠á◙àù

Esegui ed esegui il debug

"Punti bonus" per nessun errore di precisione. Nessun aritmetica in virgola mobile utilizzata. Questo (finalmente) fa uso del tipo razionale incorporato di Stax.

JavaScript, 70 byte

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

Se possiamo modificare il tipo di input in una stringa, è possibile che vengano salvati 5 byte.