เรามีจำนวนจุดลอยrระหว่าง 0 และ 1, pและจำนวนเต็ม

ค้นหาเศษส่วนของจำนวนเต็มด้วยตัวหารที่เล็กที่สุดซึ่งใกล้เคียงrกับpความแม่นยำอย่างน้อย-digit

• อินพุต: r(หมายเลขจุดลอยตัว) และp(จำนวนเต็ม)
• ผลลัพธ์: aและbจำนวนเต็มโดยที่
  • a/b(ลอย) ประมาณrจนกระทั่งpตัวเลข
  • b เป็นไปได้ที่น้อยที่สุดเช่นจำนวนเต็มบวก

ตัวอย่างเช่น:

• ถ้าr=0.14159265358979และp=9,
• แล้วผลที่ได้คือa=4687และb=33102,
• 4687/33102=0.1415926530119026เพราะ

การแก้ปัญหาใด ๆ จะต้องทำงานในทางทฤษฎีด้วยความแม่นยำโดยพลการ

แม่นยำหมายถึงจำนวนของตัวเลขหลังจากที่ " 0." rใน ดังนั้นหากr=0.0123และp=3แล้วควรเริ่มต้นด้วยa/b 0.012หากpตัวเลขแรกของส่วนที่เป็นเศษส่วนของr0 เป็นพฤติกรรมที่ไม่ได้กำหนดเป็นที่ยอมรับ

เกณฑ์การชนะ:

• อัลกอริทึมเร็วที่สุดชนะ ความเร็วถูกวัดใน O (p)
• หากมีอัลกอริธึมที่เร็วที่สุดหลายตัว
• คำตอบของฉันถูกแยกออกจากกลุ่มผู้ชนะที่เป็นไปได้

ps คณิตศาสตร์ส่วนที่เป็นจริงได้ง่ายขึ้นมากเป็นดูเหมือนว่าฉันขอแนะนำให้อ่านนี้โพสต์

JavaScript, O (10 ^p ) & 72 ไบต์

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

มันเป็นเรื่องเล็กน้อยที่จะพิสูจน์ว่าวนซ้ำจะทำหลังจากมากที่สุด (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>

ขอบคุณมากสำหรับแนวคิดของ Neil บันทึก 50 ไบต์

Haskell , O (10 ^p ) ในกรณีที่เลวร้ายที่สุด121 119 ไบต์

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

ลองออนไลน์!

บันทึก 2 ไบต์ขอบคุณ Laikoni

ผมใช้อัลกอริทึมจาก/math/2432123/how-to-find-the-fraction-of-integers-with-the-smallest-denominator-matching-an-i

ในแต่ละขั้นตอนช่วงเวลาใหม่คือครึ่งหนึ่งของช่วงเวลาก่อนหน้า ดังนั้นขนาดช่วงเวลาคือ2**-nที่ซึ่งnเป็นขั้นตอนปัจจุบัน เมื่อ2**-n < 10**-pใดเราแน่ใจว่ามีการประมาณที่ถูกต้อง แต่ถ้าแล้วn > 4*p สรุปก็คือว่าอัลกอริทึม2**-n < 2**-(4*p) == 16**-p < 10**-pO(p)

แก้ไขตามที่ระบุโดย orlp ในความคิดเห็นการอ้างสิทธิ์ข้างต้นเป็นเท็จ ในกรณีที่เลวร้ายที่สุดr = 1/10**p( r= 1-1/10**pเป็นที่คล้ายกัน) จะมีขั้นตอน10**p 1/2, 1/3, 1/4, ...มีวิธีแก้ปัญหาที่ดีกว่า แต่ฉันไม่มีเวลาที่จะแก้ไข

C, 473 ไบต์ (ไม่มีบริบท), O (p), ไม่มีการแข่งขัน

วิธีการแก้ปัญหานี้ใช้ส่วนคณิตศาสตร์ที่มีรายละเอียดในการโพสต์ที่ยอดเยี่ยมนี้ ฉันคำนวณcalc()เป็นขนาดคำตอบเท่านั้น

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