Chúng ta có một số dấu phẩy động rtừ 0 đến 1 và một số nguyên p.

Tìm phân số nguyên có mẫu số nhỏ nhất, gần đúng rvới ít nhất là pđộ chính xác kỹ thuật số.

• Đầu vào: r(một số dấu phẩy động) và p(số nguyên).
• Đầu ra: avà bsố nguyên, trong đó
  • a/b(như float) xấp xỉ rcho đến khi pchữ số.
  • b là số nguyên dương nhỏ nhất có thể có.

Ví dụ:

• nếu r=0.14159265358979và p=9,
• sau đó kết quả là a=4687và b=33102,
• vì 4687/33102=0.1415926530119026.

Bất kỳ giải pháp nào cũng phải hoạt động trên lý thuyết với các loại độ chính xác tùy ý, nhưng các hạn chế gây ra bởi các loại độ chính xác cố định của việc triển khai không thành vấn đề.

Độ chính xác có nghĩa là số chữ số sau " 0." in r. Vì vậy, nếu r=0.0123và p=3, sau đó a/bnên bắt đầu với 0.012. Nếu các pchữ số đầu tiên của phần phân số rlà 0, hành vi không xác định được chấp nhận.

Đạt tiêu chí:

• Thuật toán nhanh nhất chiến thắng. Tốc độ được đo bằng O (p).
• Nếu có nhiều thuật toán nhanh nhất, thì chiến thắng ngắn nhất.
• Câu trả lời của riêng tôi được loại trừ khỏi tập hợp những người chiến thắng có thể.

Phần toán học thực sự dễ dàng hơn nhiều vì có vẻ như, tôi đề nghị đọc bài này .

JavaScript, O (10 ^p ) & 72 byte

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]}

Thật là tầm thường khi chứng minh rằng vòng lặp sẽ được thực hiện sau tối đa các lần lặp O (10 ^p ).

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>

Rất cám ơn ý tưởng của Neil, tiết kiệm 50 byte.

Haskell , O (10 ^p ) trong trường hợp xấu nhất 121 119 byte

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

Hãy thử trực tuyến!

Đã lưu 2 byte nhờ Laikoni

Tôi đã sử dụng thuật toán từ /math/2432123/how-to-find-the-fraction-of-integers-with-the-smallest-denominator-matching-an-i .

Ở mỗi bước, khoảng mới là một nửa của khoảng trước đó. Vì vậy, kích thước khoảng là 2**-n, nơi nlà bước hiện tại. Khi nào 2**-n < 10**-p, chúng tôi chắc chắn có xấp xỉ đúng. Tuy nhiên, nếu n > 4*psau đó 2**-n < 2**-(4*p) == 16**-p < 10**-p. Kết luận là thuật toán này O(p).

EDIT Như được chỉ ra bởi orlp trong một bình luận, yêu cầu trên là sai. Trong trường hợp xấu nhất, r = 1/10**p( r= 1-1/10**ptương tự), sẽ có 10**pcác bước : 1/2, 1/3, 1/4, .... Có một giải pháp tốt hơn, nhưng tôi không có thời gian để khắc phục điều này.

C, 473 byte (không có ngữ cảnh), O (p), không cạnh tranh

Giải pháp này sử dụng phần toán chi tiết trong bài tuyệt vời này . Tôi chỉ tính calc()vào kích thước câu trả lời.

#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;
}