Ce que vous devez faire est de créer une fonction / programme qui prend une décimale en entrée et génère le résultat de la prise répétée de l'inverse de la partie fractionnaire du nombre, jusqu'à ce que le nombre devienne un entier.

Plus précisément, le processus est le suivant:

1. Soit x l'entrée

2. Si x est un entier, affichez-le.

3. Sinon: $x \leftarrow \frac{1}{\mathrm{frac}(x)}$ . Revenez à 2.

$\mathrm{frac}(x)$ est la composante fractionnaire de$x$ , et est égale à$x - \left\lfloor x \right\rfloor$ . $\left\lfloor x \right\rfloor$ est le plancher de x, qui est le plus grand entier inférieur à$x$ .

Cas de 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

Résumé pour 0 à 1 par incréments de 0,1: 0, 10, 5, 3, 2, 2, 2, 3, 4, 9, 1

Il s'agit de code-golf , donc le moins d'octets gagne.

Clarifications:

• "Points bonus" pour aucune erreur d'arrondi
• Devrait fonctionner pour tout nombre rationnel non négatif (en ignorant l'erreur d'arrondi)
• Vous pouvez, mais ne devez pas afficher les étapes suivies
• Vous pouvez prendre l'entrée sous forme décimale, fraction ou paire de nombres, qui peut être dans une chaîne.

Désolé pour tous les problèmes, c'est ma première question sur ce site.

J, 18 octets

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

En J, l'idiome u ^: v ^:_signifie "Continuez à appliquer le verbe tant uque la condition vrenvoie vrai.

Dans notre cas, la condition de fin est définie par le crochet ~:<., ce qui signifie "le plancher du nombre <.n'est pas égal ~:au nombre lui-même" - nous nous arrêterons donc lorsque le verbe principal urenvoie un entier.

udans ce cas est un autre crochet -<.- le nombre moins son plancher - dont la valeur de retour est introduite dans @le verbe réciproque %.

Essayez-le en ligne!

Python 3 , 101 octets

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)

Essayez-le en ligne!

Format: la chaîne doit contenir un point décimal.

Mathematica, 36 octets

Last@*ContinuedFraction@*Rationalize

Démo

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 octets

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

Essayez-le en ligne!

La nudeméthode renvoie le nu merator et de proposeur d'un nombre rationnel comme une liste à deux éléments. Il est plus court d'obtenir le dénominateur de cette façon que d'appeler denominatordirectement la méthode.

Haskell , 47 octets

Cela bat la réponse de Wheat Wizard car GHC.Realnous permet de faire correspondre les motifs sur les rationnels en utilisant :%, ainsi que d'avoir un nom plus court

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

Essayez-le en ligne!

fprend un Rationalnombre en entrée, bien que ghc leur permette d'être écrit au format décimal, avec une certaine précision.

Haskell , 40 34 octets

Éditer:

• -6 octets: @WheatWizard a souligné que la fraction peut probablement être donnée en deux arguments distincts.

(Je n'ai pas pu résister à publier ceci après avoir vu les réponses Haskell avec des importations verbeuses - maintenant je vois que d'autres réponses linguistiques utilisent également essentiellement cette méthode.)

!prend deux arguments entiers (numérateur et dénominateur de la fraction; ils n'ont pas besoin d'être en termes plus petits mais le dénominateur doit être positif) et retourne un entier. Appelez le 314!100.

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

Essayez-le en ligne!

• En ignorant la non-concordance de type, la partie fractionnaire de n/d(en supposant dpositive) est mod n d/d, donc à moins que mod n d==0, ne se !reproduise avec une représentation de d/mod n d.

Python 3 + sympy , 67 octets

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

Essayez-le en ligne!

Sympy est un package mathématique symbolique pour Python. Parce qu'il est symbolique et non binaire, il n'y a pas d'inexactitudes en virgule flottante.

PHP , 69 octets

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

Essayez-le en ligne!

PHP , 146 octets

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

Essayez-le en ligne!

Gelée , 8 octets

®İ$%1$©¿

Essayez-le en ligne!

Imprécisions à virgule flottante.

JavaScript ES6, 25 octets

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

Appel f(a,b)àa/b

Haskell , 62 61 octets

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

Essayez-le en ligne!

Utilise la Data.Ratiobibliothèque de Haskell pour des justifications de précision arbitraires. Si seulement les noms intégrés n'étaient pas si longs.

APL (Dyalog Classic) , 18 octets

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

Essayez-le en ligne!

APL NARS, 18 caractères

-1 octet grâce au 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 octets

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

Stax , 8 octets

ç▄é⌠á◙àù

Exécuter et déboguer

"Points bonus" pour aucune erreur de précision. Aucune arithmétique à virgule flottante utilisée. Cela (enfin) utilise le type rationnel intégré de stax.

JavaScript, 70 octets

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

Si nous pouvons changer le type d'entrée en une chaîne, cela peut économiser 5 octets.