Tugas:

Tugas Anda adalah, ketika diberi tiga input:

• pembilang n
• penyebut d
• bilangan bulat lain, x

Buat program / fungsi yang menemukan xdigit nomor setelah tempat desimal.

Spesifikasi:

• Kisaran ndan dberada di antara 1dan 2^31 - 1, inklusif.
• Kisaran xantara 1dan 10,000,000termasuk.
  • Anda dapat memilih untuk menggunakan pengindeksan berbasis 1 atau pengindeksan berbasis 0 untuk x. Silakan sebutkan jawaban Anda yang mana yang Anda gunakan.
• nmungkin lebih besar dari d.
• n, ddan xdijamin bilangan bulat positif (untuk versi indeks berbasis 1 x, jika Anda memilih untuk menggunakan pengindeksan berbasis 0 untuk xmaka xbisa 0).
• Anda dapat mengambil input dengan cara yang masuk akal (Yaitu dengan cara apa pun yang bukan celah standar).

Aturan:

• Anda harus mengembalikan xdigit ke- tepat , bukan ketika dibulatkan - jadi 15digit ke-dari 1/6, misalnya, tidak 7, tetapi 6.
• Program Anda harus bekerja untuk semua di xbawah 10 juta, kecuali bahasa Anda tidak mendukung desimal hingga 10 juta tempat.

Contoh I / O:

Contoh input menggunakan pengindeksan berbasis 0, yang berarti xakan beralih dari 0ke 9,999,999. Selain itu, "input" ditulis sebagai string dengan spasi yang memisahkan angka-angka.

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 byte

Port jawaban Haskell saya, karena Python juga mendukung bignum secara default. Karena di sana, x1-diindeks.

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

Cobalah online! (meminjam pembungkus Keerthana Prabhakaran.)

Mathematica 33 Bytes

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

Pengindeksan berbasis 1.

mis. digit 10 juta Pi tepat dari titik desimal:

%[Pi,1,10^7]
7

membutuhkan sekitar 2 detik pada mesin lama saya.

Anda dapat mencobanya online di WolframAlpha (klik tanda sama dengan)

Haskell , 26 byte

Berfungsi untuk semua kasus uji. Yay bignum!

(n#d)xmengambil Integers dan mengembalikan sebuah Integer. xdiindeks 1.

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

Cobalah online!

PHP> = 7.1, 40 Bytes

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

bcdiv

Versi Online

Jelly , 7 byte

⁵*×:ƓDṪ

Cobalah online!

Pengajuan fungsi (tetapi juga berfungsi sebagai program lengkap). Fungsi Jelly hanya dapat mengambil dua argumen secara langsung; jadi saya mengambil digit untuk kembali sebagai argumen kiri, pembilang sebagai argumen benar, dan penyebut dari input standar (sebagai pengganti menggunakan argumen ketiga).

Orang yang terbiasa dengan Jelly mungkin sadar bahwa program lengkap dapat mengambil lebih dari dua argumen, tetapi hal itu menyebabkan Anda kehilangan akses ke cara tersest untuk menulis integer 10 konstan, yang cukup relevan di sini. Dengan demikian, input campuran semacam ini terasa agak seperti eksploit daripada golf yang sebenarnya berguna; Saya pribadi tidak setuju dengan itu, tetapi aturan tentang mengizinkan ini saat ini di +40 / -12, jadi selama itu ada dalam aturan, saya mungkin juga mengeksploitasinya (dan cukup banyak harus kompetitif).

Argumen kiri dari 1 merujuk ke digit segera setelah titik desimal ("digit .1s"), argumen 2 ke digit .01s, dan seterusnya.

Penjelasan

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

Jelly memiliki aritmatika presisi sembarang pada bilangan bulat, jadi dengan pra-mengalikannya dengan kekuatan 10, kami secara efektif memindahkan digit yang kami inginkan ke posisi unit, di mana jauh lebih mudah untuk mengekstrak.

sed -r , 93 131 136 byte

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

Cobalah online!

( Lihat output dalam desimal )

Mengambil input di unary dan output di unary, dan program ini diindeks 1. Untungnya, tantangan ini telah mempersiapkan saya untuk yang ini.

Konsepnya sama, keduanya menerapkan pembagian panjang. Di sini, saya melakukan pembagian xwaktu yang lama , di manax digit setelah tempat desimal yang harus saya temukan. Setelah setiap iterasi, saya membuang tempat desimal sebelumnya karena tidak lagi diperlukan.

Saat melakukan pembagian, program ini dalam format dividend;divisor;x,result.

s/$/,/ menambahkan koma ini, koma diperlukan untuk memisahkan hasil dari yang lainnya

Kemudian ikuti loop program utama

:d label d

• s/,.+/,/ hapus semuanya setelah koma

• : label kosong

• • s/(1+)(1*;\1;1*,)1{10}?/\21/ melakukan pembagian, menambahkan 1 ke hasil setiap iterasi, sementara secara bersamaan menghapus blok 10 1 dalam hasil

• t bercabang ke label kosong, dengan kata lain, loop sampai dividen telah habis

• s/1*/&&&&&&&&&&/ kalikan dividen dengan 10 untuk mempersiapkan iterasi berikutnya

• ta cabang untuk memberi label a

• :alabel a, baris ini dan baris di atas diperlukan untuk membuat tdpekerjaan

• s/1,/,/ kurangi 1 dari x

tdcabang bersyarat ke d, ini dipicu jika telah ada substitusi yang berhasil sejak cabang bersyarat terakhir, karena s/1*/&&&&&&&&&&/selalu sukses, tdakan selalu terpicu, tetapi dengan memperkenalkan cabang a, kami memperbaikinya sehingga hanya bergantung pada substitusi sebelumnya

s/.+,// akhirnya, hapus semuanya kecuali hasilnya

Ruby , 34 33 byte

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

Cobalah online!

REXX, 76 byte

(Tidak terlalu singkat tetapi berpikir itu akan membuat perubahan untuk melakukan satu di REXX) ​​Rexx adalah 1 berbasis oleh defintion.

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

Penjelasan:

1. Baca input ke angka
2. Menjamin angka yang cukup signifikan (standarnya adalah 9)
3. Menghitung
4. Membagi. Temukan titik desimal, hitung maju karakter "x", ambil karakter berikut dan masukkan ke "z"
5. Cetak digit pertama. Pad dengan 0 untuk memastikan.

Penggabungan 3 dan 4 sebenarnya membuatnya lebih lama karena perubahan sintaksis:

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

Untuk non-REXXers: String dan angka benar-benar dapat dipertukarkan di REXX. Mereka ditentukan oleh bagaimana Anda bertindak terhadap mereka. Jadi Anda dapat menguraikan angka menggunakan fungsi sengatan tanpa konversi. Sebagai contoh

"27" + "28"

mengembalikan 55 dan bukan 2728!

Batch, 70 byte

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

Perakitan bahasa cpu Intel x86, 50 byte

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

Untuk parameter 'c' rentang mulai dari 0; itu akan menjadi 0..0xfffffffd. Jika parameter b = 0 atau c di luar kisaran 0..0xfffffffd, ia akan mengembalikan -1

Lua, 42 byte

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

C, 49 43 byte

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

Argumen 'i' adalah pengindeksan 0. Kode uji dan hasil

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 byte terima kasih kepada Erik the Outgolfer, saya benar-benar lupa impor tidak harus di jalur mereka sendiri

-4 byte terima kasih kepada Qwerp-Derp untuk memindahkan n% d ke konstruktor

-6 byte terima kasih Kevin Cruijssen karena telah menghapus toString ()

Saya harap ini adalah bagaimana penghitungan byte dilakukan untuk fungsi java dengan impor

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

Menggunakan kelas BigDecimal Java untuk mendapatkan representasi yang tepat dari ekspansi desimal. Perhatikan ini bukan kode tercepat yang pernah berjalan tetapi pada akhirnya menghasilkan output yang benar untuk semua kasus uji. Kode tidak dikunci:

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
}

Cobalah online!

Clojure, 39 byte

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

fungsi anonim dengan argumen di n,d,xmana xmenggunakan pengindeksan satu berbasis.

F # (.NET Core) , 30 byte

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

Cobalah online!

(gunakan pengindeksan berbasis 1)

Groovy, 30 byte

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

x menggunakan 1 pengindeksan berbasis.

Penjelasan:

{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 byte

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

Cobalah online!

Ruby, 39 byte

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

JavaScript (ES6), 34 byte

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

x berbasiskan 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 byte

Menggunakan pengindeksan 0

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

Cobalah online!

Edit:

Digulung kembali ke solusi asli seperti yang terlihat dalam jawaban Ørjan Johansen bahwa itu berfungsi, tapi saya tidak akan bermain golf lebih jauh

Groovy, 55 byte

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

Dijelaskan menggunakan 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.
}

Aksioma, 71 61 76 byte

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

n adalah pengindeksan 0 [0..M]. Kode uji dan hasil

(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 byte, port

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

Cobalah online!

JavaScript (Node.js) , 51 byte

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

Cobalah online!

gunakan Array daripada rekursif untuk menghindari stackoverflow