งาน:

งานของคุณคือเมื่อได้รับสามอินพุต:

• ตัวเศษ n
• ตัวส่วน d
• อีกจำนวนเต็ม x

สร้างโปรแกรม / ฟังก์ชั่นที่ค้นหาตัวเลขxth ของตัวเลขหลังจุดทศนิยม

รายละเอียด:

• ช่วงของnและdอยู่ระหว่าง1และ2^31 - 1รวม
• ช่วงของxอยู่ระหว่าง1และ10,000,000รวม
  • การจัดทำดัชนีคุณอาจเลือกที่จะใช้ 1 ตามการจัดทำดัชนีหรือ 0 xที่ใช้สำหรับ โปรดระบุคำตอบที่คุณใช้
• ndอาจจะมีขนาดใหญ่กว่า
• n, dและxได้รับการรับรองให้เป็นจำนวนเต็มบวก (ต่อ 1 ตามรุ่นของดัชนีxถ้าคุณเลือกที่จะใช้การจัดทำดัชนี 0 ที่ใช้สำหรับการxนั้นxสามารถ0)
• คุณอาจรับอินพุตในลักษณะที่สมเหตุสมผล (เช่นวิธีใด ๆ ที่ไม่ใช่ช่องโหว่มาตรฐาน)

กฎ:

• คุณจะต้องกลับที่แน่นอนxหลักที่ไม่ได้เมื่อกลม - ดังนั้น15หลัก TH ของ1/6ตัวอย่างเช่นไม่ได้แต่76
• โปรแกรมของคุณจะต้องใช้งานได้สำหรับทุกคน xต่ำกว่า 10 ล้านคนยกเว้นว่าภาษาของคุณจะไม่สนับสนุนทศนิยมถึง 10 ล้านแห่ง

ตัวอย่าง I / O:

การป้อนข้อมูลตัวอย่างเช่นใช้การจัดทำดัชนี 0-based ซึ่งหมายความว่าxจะไปจากการ0 9,999,999เช่นเดียวกับที่ "ป้อน" ถูกเขียนเป็นสตริงที่มีช่องว่างแยกตัวเลข

1 2 3: 0
5 6 0: 8
5 6 1: 3
1 6 15: 6 (not 7, as it's not rounded)
1 11 2: 0
1 10000 9999999: 0
11 7 1: 7

Python 2 , 25 ไบต์

พอร์ตของคำตอบ Haskell ของฉันเนื่องจาก Python ยังรองรับ bignums ตามค่าเริ่มต้น เนื่องจากมีxการจัดทำดัชนี 1

lambda n,d,x:n*10**x/d%10

ลองออนไลน์! (ยืมเสื้อคลุมของกีรณาประภาประภา)

Mathematica 33 Bytes

RealDigits[#/#2,10,1,-#3][[1,1]]&

การจัดทำดัชนีแบบ 1

เช่นตัวเลข 10 ล้านหลักของ Pi ทางขวาของจุดทศนิยม:

%[Pi,1,10^7]
7

ใช้เวลาประมาณ 2 วินาทีในเครื่องเก่าของฉัน

คุณสามารถลองออนไลน์ได้ที่WolframAlpha (คลิกที่เครื่องหมายเท่ากับ)

Haskell , 26 ไบต์

ใช้งานได้กับทุกกรณีทดสอบ ยาย bignums!

(n#d)xใช้เวลาและส่งกลับInteger ถูกจัดทำดัชนี 1 รายการIntegerx

(n#d)x=n*10^x`div`d`mod`10

ลองออนไลน์!

PHP> = 7.1, 40 ไบต์

<?=bcdiv(($a=$argv)[1],$a[2],$a[3])[-1];

bcdiv

เวอร์ชั่นออนไลน์

เยลลี่ขนาด 7 ไบต์

⁵*×:ƓDṪ

ลองออนไลน์!

การส่งฟังก์ชั่น (แต่ยังทำงานเป็นโปรแกรมเต็มรูปแบบ) ฟังก์ชัน Jelly สามารถรับอาร์กิวเมนต์ได้สองข้อเท่านั้น ดังนั้นฉันใช้ตัวเลขเพื่อกลับเป็นอาร์กิวเมนต์ซ้ายตัวเศษเป็นอาร์กิวเมนต์ที่ถูกต้องและตัวส่วนจากอินพุตมาตรฐาน (แทนการใช้อาร์กิวเมนต์ที่สาม)

คนที่เคยใช้งานเยลลี่อาจทราบว่าโปรแกรมเต็มรูปแบบอาจใช้เวลามากกว่าสองข้อโต้แย้ง แต่การทำเช่นนั้นทำให้คุณสูญเสียการเข้าถึงวิธีที่ยากที่สุดในการเขียนจำนวนเต็มคงที่ 10 ซึ่งมีความเกี่ยวข้องอย่างเป็นธรรมที่นี่ ดังนั้นข้อมูลอินพุตแบบผสมนี้จึงให้ความรู้สึกว่าเป็นประโยชน์มากกว่าการเล่นกอล์ฟที่มีประโยชน์จริง ฉันเองไม่เห็นด้วยกับมัน แต่กฎเกี่ยวกับการอนุญาตให้ทำอยู่ที่ +40 / -12 ดังนั้นตราบใดที่มันอยู่ในกฎฉันก็อาจเอาเปรียบมันได้ (และต้องมีการแข่งขัน)

อาร์กิวเมนต์ซ้ายของ 1 หมายถึงตัวเลขทันทีหลังจุดทศนิยม (".1s หลัก"), อาร์กิวเมนต์ 2 ถึงหลัก 0.01 และอื่น ๆ

คำอธิบาย

⁵*×:ƓDṪ
⁵*        10 to the power of {the left argument}
  ×       multiplied by {the right argument}
   :      divided by
    Ɠ                standard input
      Ṫ   take the last
     D                  decimal digit

เจลลี่มีเลขคณิตความแม่นยำตามอำเภอใจเป็นจำนวนเต็มดังนั้นโดยการคูณด้วยกำลัง 10 เราจะย้ายตัวเลขที่มีประสิทธิภาพที่เราต้องการไปยังตำแหน่งของหน่วยซึ่งมันง่ายกว่ามากในการแยก

sed -r , 93 131 136ไบต์

s/$/,/
:d
s/,.+/,/
:
s/(1+)(1*;\1;1*,)1{10}?/\21/
t
s/1*/&&&&&&&&&&/
ta
:a
s/1,/,/
td
s/.+,//

ลองออนไลน์!

( ดูผลลัพธ์เป็นทศนิยม )

รับอินพุตเป็น unary และเอาต์พุตเป็น unary และโปรแกรมถูกทำดัชนี 1 รายการ โชคดีที่ความท้าทายนี้ได้เตรียมฉันไว้สำหรับสิ่งนี้แล้ว

แนวคิดคล้ายกันทั้งสองดำเนินการส่วนยาว ที่นี่ฉันทำเวลาหารยาวxที่ไหนxเป็นหลักหลังจุดทศนิยมที่ฉันต้องค้นหา หลังจากการวนซ้ำแต่ละครั้งฉันจะละทิ้งทศนิยมก่อนหน้านี้เนื่องจากไม่จำเป็นอีกต่อไป

dividend;divisor;x,resultในขณะที่ทำส่วนโปรแกรมที่เป็นในรูปแบบ

s/$/,/ เพิ่มเครื่องหมายจุลภาคนี้จำเป็นต้องใช้เครื่องหมายจุลภาคเพื่อแยกผลลัพธ์จากสิ่งอื่น

จากนั้นติดตามลูปโปรแกรมหลัก

:d ฉลาก d

• s/,.+/,/ ลบทุกอย่างหลังจากเครื่องหมายจุลภาค

• : ป้ายกำกับที่ว่างเปล่า

• • s/(1+)(1*;\1;1*,)1{10}?/\21/ ดำเนินการหารโดยเพิ่ม 1 ให้กับผลลัพธ์แต่ละการวนซ้ำในขณะเดียวกันก็ลบบล็อกของ 10 อย่างต่อเนื่อง 1 วินาทีในผลลัพธ์

• t สาขาไปยังป้ายว่างเปล่าในคำอื่น ๆ วนจนกว่าการจ่ายเงินปันผลจะหมด

• s/1*/&&&&&&&&&&/ คูณเงินปันผลด้วย 10 เพื่อเตรียมพร้อมสำหรับการวนซ้ำครั้งถัดไป

• ta สาขาที่จะติดฉลาก

• :aเลเบล a, บรรทัดนี้และบรรทัดด้านบนจำเป็นต้องtdทำงาน

• s/1,/,/ ลบ 1 จาก x

tdสาขาที่มีเงื่อนไขถึง d นี่จะถูกเรียกใช้หากมีการทดแทนที่ประสบความสำเร็จตั้งแต่สาขาที่มีเงื่อนไขล่าสุดเนื่องจากs/1*/&&&&&&&&&&/ประสบความสำเร็จtdเสมอจะได้รับการทริกเกอร์เสมอ แต่โดยการแนะนำสาขา a เราแก้ไขได้เพื่อให้มันขึ้นอยู่กับการทดแทนก่อนหน้านี้เท่านั้น

s/.+,// ในที่สุดลบทุกอย่างยกเว้นผลลัพธ์

Ruby , 34 33 ไบต์

->n,d,x{(0..x).map{n=n%d*10};n/d}

ลองออนไลน์!

REXX, 76 ไบต์

(ไม่สั้นมาก แต่คิดว่ามันจะทำให้การเปลี่ยนแปลงเป็นสิ่งที่ทำได้ใน REXX) ​​Rexx เป็นแบบ 1 โดยการกำหนด

arg n d x
numeric digits x+10
y=n/d
parse var y "." +(x) z
say left(z,1,"0")

คำอธิบาย:

1. อ่านอินพุตไปยังตัวเลข
2. รับประกันตัวเลขที่สำคัญเพียงพอ (ค่าเริ่มต้นคือ 9)
3. คำนวณ
4. แยก ค้นหาจุดทศนิยมนับไปข้างหน้าตัวอักษร "x" ใช้ตัวอักษรต่อไปนี้และใส่ลงใน "z"
5. พิมพ์เลขตัวแรก แผ่นที่มี 0 เพื่อให้แน่ใจว่า

การรวม 3 และ 4 เข้าด้วยกันจริงทำให้มันนานขึ้นเนื่องจากการเปลี่ยนแปลงของไวยากรณ์:

parse value n/d with "." +x z +1

สำหรับผู้ที่ไม่ใช่ REXXers: สตริงและตัวเลขสามารถใช้แทนกันได้ทั้งหมดใน REXX พวกเขาจะถูกกำหนดโดยวิธีที่คุณดำเนินการกับพวกเขา ดังนั้นคุณสามารถแยกตัวเลขโดยใช้ฟังก์ชั่นต่อยโดยไม่มีการแปลง ตัวอย่างเช่น

"27" + "28"

ส่งคืน 55 และไม่ใช่ 2728!

รุ่นที่ 70 ไบต์

@set n=%1
@for /l %%x in (0,1,%3)do @set/an=n%%%2*10
@cmd/cset/an/%2

การประกอบภาษา Intel x86 cpu ขนาด 50 ไบต์

00000940  53                push ebx
00000941  8B5C240C          mov ebx,[esp+0xc]
00000945  8B4C2410          mov ecx,[esp+0x10]
00000949  31C0              xor eax,eax
0000094B  48                dec eax
0000094C  81C102000000      add ecx,0x2
00000952  721A              jc 0x96e
00000954  81FB00000000      cmp ebx,0x0
0000095A  7412              jz 0x96e
0000095C  8B442408          mov eax,[esp+0x8]
00000960  31D2              xor edx,edx
00000962  F7F3              div ebx
00000964  49                dec ecx
00000965  7407              jz 0x96e
00000967  8D0492            lea eax,[edx+edx*4]
0000096A  01C0              add eax,eax
0000096C  EBF2              jmp short 0x960
0000096E  5B                pop ebx
0000096F  C20C00            ret 0xc

traslation ใน nasm

; u32 __stdcall rdiv(u32 a, u32  b, u32 c)
; 8a, 12b, 16c
      align   4
rdiv:                   ; c<0xFFFFFFFE and b!=0
      push    ebx       ; something as for(;a=10*(a%b),c--;);return a/b
      mov     ebx,  dword[esp+  12]
      mov     ecx,  dword[esp+  16]
      xor     eax,  eax
      dec     eax
      add     ecx,  2
      jc      .z
      cmp     ebx,  0
      je      .z            
      mov     eax,  dword[esp+  8]
.1:   xor     edx,  edx
      div     ebx
      dec     ecx
      jz      .z
      lea     eax,  [edx+edx*4]
      add     eax,  eax
      jmp     short  .1     ; a=5*a;a+=a=>a=10*a
.z:       
      pop     ebx
      ret     12

สำหรับพารามิเตอร์ 'c' ช่วงเริ่มต้นจาก 0; มันจะเป็น 0..0xfffffffd หากพารามิเตอร์ b = 0 หรือ c อยู่นอกช่วง 0..0xfffffffd มันจะส่งคืน -1

Lua ขนาด 42 ไบต์

function a(n,x,d)
print((n*10^x/d)%10)
end

C, 49 43 ไบต์

f(a,b,i){for(;a=10*(a%b),i--;);return a/b;}

อาร์กิวเมนต์ 'i' คือการจัดทำดัชนี 0 รหัสทดสอบและผล

main()
{int i;
 for(i=0;i<20;++i)
     printf("%u", f(12,11,i));

 printf("\nf(1,2,3)=%d\n",f(1,2,3));
 printf("f(5,6,0)=%d\n",f(5,6,0));
 printf("f(5,6,1)=%d\n",f(5,6,1));
 printf("f(1,6,15)=%d\n",f(1,6,15));
 printf("f(1,11,2)=%d\n",f(1,11,2));
 printf("f(1,10000,9999999)=%d\n",f(1,10000,9999999));
 printf("f(11,7,1)=%d\n",f(11,7,1));
}

f(1,2,3)=0
f(5,6,0)=8
f(5,6,1)=3
f(1,6,15)=6
f(1,11,2)=0
f(1,10000,9999999)=0
f(11,7,1)=7 

Java 7, 146 139 137 133 128 122 Bytes

-3 ไบต์ขอบคุณ Erik the Outgolfer ฉันลืมการนำเข้าโดยสิ้นเชิงไม่จำเป็นต้องเป็นของตัวเอง

-4 ไบต์ขอบคุณ Qwerp-Derp สำหรับการย้าย n% d ไปยังตัวสร้าง

-6 ไบต์ขอบคุณ Kevin Cruijssen สำหรับการลบ toString ()

ฉันหวังว่านี่เป็นวิธีการนับจำนวนไบต์สำหรับฟังก์ชัน java ที่มีการนำเข้า

import java.math.*;char a(int n,int d,int x){return (new BigDecimal(n%d).divide(new BigDecimal(d),x+1,1)+"").charAt(x+2);}

ใช้คลาส BigDecimal ของ Java เพื่อรับการแทนค่าส่วนขยายทศนิยมอย่างแม่นยำ โปรดทราบว่ามันไม่ใช่รหัสที่ทำงานเร็วที่สุด แต่จะสร้างผลลัพธ์ที่ถูกต้องสำหรับกรณีทดสอบทั้งหมด รหัสไม่ได้รับการตอบกลับ:

import java.math.*;
char a(int n, int d, int x){
    BigDecimal num = new BigDecimal(n%d); // reduce improper fractions
    BigDecimal div = new BigDecimal(d);
    BigDecimal dec = num.divide(div, x+1, 1); // precision of x + 1, round down
    return (dec+"").charAt(x+2); //xth char after decimal
}

ลองออนไลน์!

Clojure, 39 ไบต์

#(mod(int(/(*(Math/pow 10 %3)%)%2))10))

ฟังก์ชั่นไม่ระบุชื่อกับข้อโต้แย้งn,d,xที่xใช้การจัดทำดัชนีตามหนึ่ง

F # (. NET Core) 30 ไบต์

let f n d x=n*pown 10I x/d%10I

ลองออนไลน์!

(ใช้การสร้างดัชนีแบบ 1 ฐาน)

Groovy ขนาด 30 ไบต์

{n,d,x->(n*10**x/d as int)%10}

x ใช้การจัดทำดัชนี 1 รายการ

คำอธิบาย:

{n,d,x->    // closure with three arguments, n, d, x
 n*10**x    // multiply n with 10 to the power of x
 /d         // divide by d
 as int     // convert from BigDecimal to int
 )%10       // modulo 10 to get the answer
}

Python 2 , 50,44,40, 36 ไบต์

lambda n,d,x:(`n*1./d%1`+'0'*x)[x+2]

ลองออนไลน์!

Ruby, 39 ไบต์

->n,m,o{(n*1.0/m).to_s.split(?.)[1][o]}

JavaScript (ES6), 34 ไบต์

(n,d,x)=>`${n/d}`.split`.`[1][x]|0

x เป็นแบบ 0

f=
(n,d,x)=>`${n/d}`.split`.`[1][x]|0

console.log(f(1,2,3))
console.log(f(5,6,0))
console.log(f(5,6,1))
console.log(f(1,6,15))
console.log(f(1,11,2))
console.log(f(1,10000,10000000))
console.log(f(11,7,1))
console.log(f(2000,7,0))

Python 2 , 32 ไบต์

ใช้การจัดทำดัชนี 0

lambda n,d,x:int(10**-~x*n/d)%10

ลองออนไลน์!

แก้ไข:

ย้อนกลับไปที่โซลูชันดั้งเดิมตามที่เห็นในคำตอบของØrjan Johansen ว่าใช้งานได้ แต่ฉันจะไม่เล่นกอล์ฟอีกต่อไป

Groovy ขนาด 55 ไบต์

{n,d,x->z='0'*x;Eval.me("$n.$z/$d.$z").toString()[x-1]}

อธิบายโดยใช้1,11,2:

{
    n,d,x->          // I've already lost to Jelly by the end of this line.
    z='0'*x;         // Set z equal to 2 0's.
    Eval.me          // Evaluate as groovy code...
    ("$n.$z/$d.$z")  // 1.00g/11.00g (Automatically set precision using # 0s).
   .toString()[x-1]  // Get 2nd digit of division.
}

ความจริง71 61 76 ไบต์

f(a:NNI,b:PI,n:NNI):NNI==(repeat(a:=10*(a rem b);n=0=>break;n:=n-1);a quo b)

n คือการจัดทำดัชนี 0 [0..M] รหัสทดสอบและผล

(19) ->    f(1,2,3)=0
   (19)  0= 0
(20) ->     f(5,6,0)=8
   (20)  8= 8
(21) ->     f(5,6,1)=3
   (21)  3= 3
(22) ->     f(1,6,15)=6
   (22)  6= 6
(23) ->     f(1,11,2)=0
   (23)  0= 0
(24) ->     f(1,10000,9999999)=0
   (24)  0= 0
(25) ->     f(11,7,1)=7
   (25)  7= 7

JavaScript (Node.js) , 43 ไบต์, พอร์ต

(a,b,i)=>eval(`for(;a=10*(a%b),i--;)a/b|0`)

ลองออนไลน์!

JavaScript (Node.js) , 51 ไบต์

(n,d,x)=>[...Array(x)].map(_=>[n*=10,u=n/d,n%=d])|u

ลองออนไลน์!

ใช้ Array แทนการเรียกซ้ำเพื่อหลีกเลี่ยงstackoverflow