Nous avons un nombre à virgule flottante rentre 0 et 1 et un entier p.

Trouvez la fraction d'entiers avec le plus petit dénominateur, qui se rapproche ravec une pprécision d' au moins chiffres.

• Entrées: r(un nombre à virgule flottante) et p(entier).
• Sorties: aet bentiers, où
  • a/b(flottant) se rapproche rjusqu'aux pchiffres.
  • b est le plus petit entier positif possible.

Par exemple:

• si r=0.14159265358979et p=9,
• alors le résultat est a=4687et b=33102,
• parce que 4687/33102=0.1415926530119026.

Toute solution doit fonctionner en théorie avec des types à précision arbitraire, mais les limitations causées par les types à précision fixe des implémentations n'ont pas d'importance.

La précision signifie le nombre de chiffres après " 0." dans r. Ainsi, si r=0.0123et p=3, alors a/bdevrait commencer par 0.012. Si les premiers pchiffres de la partie fractionnaire de rsont 0, un comportement non défini est acceptable.

Critères de victoire:

• L'algorithme algorithmiquement le plus rapide gagne. La vitesse est mesurée en O (p).
• S'il existe plusieurs algorithmes les plus rapides, le plus court l'emporte.
• Ma propre réponse est exclue de l'ensemble des gagnants possibles.

Ps la partie mathématique est en fait beaucoup plus facile qu'il n'y paraît, je vous suggère de lire ce post.

JavaScript, O (10 ^p ) et 72 octets

r=>p=>{for(a=0,b=1,t=10**p;(a/b*t|0)-(r*t|0);a/b<r?a++:b++);return[a,b]}

Il est trivial de prouver que la boucle se fera après au plus O (10 ^p ) itérations.

f=
r=>p=>{for(a=0,b=1,t=10**p;(a/b*t|0)-(r*t|0);a/b<r?a++:b++);return[a,b]}

<math xmlns="http://www.w3.org/1998/Math/MathML">
  <mrow>
    <mn>0.<input type="text" id="n" value="" oninput="[p,q]=f(+('0.'+n.value))(n.value.length);v1.value=p;v2.value=q;d.value=p/q" /></mn>
    <mo>=</mo>
    <mfrac>
      <mrow><mn><output id="v1">0</output></mn></mrow>
      <mrow><mn><output id="v2">1</output></mn></mrow>
    </mfrac>
    <mo>=</mo>
    <mn><output id="d">0</output></mn>
  </mrow>
</math>

Un grand merci à l'idée de Neil, économisez 50 octets.

Haskell , O (10 ^p ) dans le pire des cas 121 119 octets

g(0,1,1,1)
g(a,b,c,d)r p|z<-floor.(*10^p),u<-a+c,v<-b+d=last$g(last$(u,v,c,d):[(a,b,u,v)|r<u/v])r p:[(u,v)|z r==z(u/v)]

Essayez-le en ligne!

Enregistré 2 octets grâce à Laikoni

J'ai utilisé l'algorithme de /math/2432123/how-to-find-the-fraction-of-integers-with-the-smallest-denominator-matching-an-i .

À chaque étape, le nouvel intervalle représente la moitié de l'intervalle précédent. Ainsi, la taille de l'intervalle est 2**-n, où nest l'étape actuelle. Quand 2**-n < 10**-p, nous sommes sûrs d'avoir la bonne approximation. Pourtant si n > 4*palors 2**-n < 2**-(4*p) == 16**-p < 10**-p. La conclusion est que l'algorithme l'est O(p).

EDIT Comme l'a souligné orlp dans un commentaire, l'affirmation ci-dessus est fausse. Dans le pire des cas, r = 1/10**p( r= 1-1/10**pest similaire), il y aura des 10**pétapes: 1/2, 1/3, 1/4, .... Il y a une meilleure solution, mais je n'ai pas le temps pour l'instant de résoudre ce problème.

C, 473 octets (sans contexte), O (p), non concurrent

Cette solution utilise la partie mathématique détaillée dans cet excellent article. J'ai calculé uniquement calc()la taille de la réponse.

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

void calc(float r, int p, int *A, int *B) {
  int a=0, b=1, c=1, d=1, e, f;
  int tmp = r*pow(10, p);
  float ivl = (float)(tmp) / pow(10, p);
  float ivh = (float)(tmp + 1) / pow(10, p);

  for (;;) {
    e = a + c;
    f = b + d;

    if ((ivl <= (float)e/f) && ((float)e/f <= ivh)) {
      *A = e;
      *B = f;
      return;
    }

    if ((float)e/f < ivl) {
      a = e;
      b = f;
      continue;
    } else {
      c = e;
      d = f;
      continue;
    }
  }
}

int main(int argc, char **argv) {
  float r = atof(argv[1]);
  int p = atoi(argv[2]), a, b;
  calc(r, p, &a, &b);
  printf ("a=%i b=%i\n", a, b);
  return 0;
}