任务：

当给出三个输入时，您的任务是：

• 分子 n
• 分母 d
• 另一个整数 x

创建一个程序/函数，以找到x小数点后第一个数字。

眼镜：

• 的范围n和d之间1和2^31 - 1，包括端值。
• 的范围x介于1和之间10,000,000，包括在内。
  • 您可以选择使用基于1的索引或基于0的索引x。请在回答中说明您使用的是哪个。
• n可能大于d。
• n，d并x保证是正整数（为基于1的索引版本x，如果您选择使用基于0的索引功能x则x可以0）。
• 您可以采用任何合理的方式（即非标准漏洞的任何方式）进行输入。

规则：

• 您必须返回精确的xth位数，而不是四舍五入-因此，例如的15th位数1/6不是7，而是6。
• x除非您的语言不支持小数到1000万位，否则您的程序必须能满足1000万以下的所有要求。

I / O示例：

示例输入使用基于0的索引，这意味着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

在线尝试！（借用Keerthana Prabhakaran的包装纸。）

Mathematica 33字节

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

基于1的索引。

例如，小数点右边的Pi的1千万位：

%[Pi,1,10^7]
7

我的旧机器大约需要2秒钟。

您可以在WolframAlpha上在线尝试 （单击等号）

Haskell，26个字节

适用于所有测试用例。是的，bignums！

(n#d)x接受Integers并返回Integer。x是1索引的。

(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表示.01s位数，依此类推。

说明

⁵*×:Ɠ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对整数具有任意精度的算术，因此通过预乘以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/.+,//

在线尝试！

（请参见十进制输出）

一元输入，一元输出，程序为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,/,/ 从x减去1

td有条件分支到d，如果自上一个条件分支以来一直存在成功替换，则触发该操作，因为s/1*/&&&&&&&&&&/它总是成功，所以td将始终被触发，但是通过引入分支a，我们将其固定为仅依赖于先前的替换

s/.+,// 最后，除去结果以外的所有内容

红宝石，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

对于非REXXer：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

鼻腔翻译

; 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字节

-3个字节感谢Outgolfer的Erik，我完全忘记了导入并不需要自己决定

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

使用Java的BigDecimal类获取十进制扩展的精确表示。请注意，这不是运行速度最快的代码，但最终它会为所有测试用例产生正确的输出。取消程式码：

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

在线尝试！

编辑：

回滚到ØrjanJohansen的回答中可以看到的原始解决方案，但我不会再打它了。

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

在线尝试！

使用数组而不是递归来避免堆栈溢出