태스크:

세 가지 입력이 주어지면 당신의 임무는 :

• 분자 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).
• 합리적인 방법으로 (즉, 표준 허점이 아닌 방식으로) 입력을받을 수 있습니다.

규칙 :

• 당신은 정확한 반환해야합니다 x그렇게 -하지 않을 때 둥근 번째 숫자 15의 일 자리 1/6예를 들어, 아니다 7,하지만 6.
• 귀하 x의 언어가 소수점 이하 자릿수를 천만 자리까지 지원하지 않는 한, 귀하의 프로그램은 천만 명 이하 에서 모두 작동해야합니다 .

예제 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

파이썬 2 , 25 바이트

파이썬은 기본적으로 큰 숫자를 지원하기 때문에 내 Haskell의 답변입니다. 거기에 따라 x1 인덱스입니다.

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

온라인으로 사용해보십시오! (케르 타나 프라 바카 란의 포장지 대여)

매스 매 티카 33 바이트

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

1 기반 인덱싱.

예 : 소수점 오른쪽 Pi의 천만 자리 :

%[Pi,1,10^7]
7

기존 컴퓨터에서 약 2 초가 걸립니다.

WolframAlpha 에서 온라인으로 시도 할 수 있습니다 (등호 클릭).

하스켈 , 26 바이트

모든 테스트 사례에서 작동합니다. 예, Bignums!

(n#d)x을 가져와을 Integer반환합니다 Integer. x1- 색인입니다.

(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Ṫ

온라인으로 사용해보십시오!

기능 제출 (전체 프로그램으로도 작동) 젤리 함수는 두 개의 인수 만 직접 취할 수 있습니다. 따라서 숫자를 왼쪽 인수로, 분자를 오른쪽 인수로, 표준 입력에서 분모를 반환합니다 (세 번째 인수 대신).

젤리에 익숙한 사람들은 전체 프로그램 이 두 개 이상의 인수를 취할 수 있다는 것을 알고있을 수 있지만, 그렇게하면 상수 정수 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의 거듭 제곱을 미리 곱하면 원하는 숫자를 단위 위치로 효과적으로 이동하여 추출하기가 더 쉽습니다.

나오지 -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

비 REXXers의 경우 : 문자열과 숫자는 REXX에서 완전히 교환 가능합니다. 그것들은 당신이 어떻게 행동하는지에 따라 결정됩니다. 따라서 변환없이 스팅 함수를 사용하여 숫자를 구문 분석 할 수 있습니다. 예를 들어

"27" + "28"

2728이 아닌 55를 반환합니다!

배치, 70 바이트

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

어셈블리 인텔 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

nasm의 traslation

; 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을 반환합니다.

루아, 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 

자바 7 146 139 137 133 128 122 바이트

Outgolfer Erik 덕분에 -3 바이트, 나는 수입품이 그들 자신의 라인에있을 필요가 없다는 것을 완전히 잊었다

nwerd를 생성자로 이동 한 Qwerp-Derp 덕분에 -4 바이트

toString () 제거에 대해 Kevin Cruijssen에게 -6 바이트 감사

수입이있는 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 클래스를 사용하여 10 진 확장을 정확하게 표시합니다. 코드가 가장 빠르게 실행되는 것은 아니지만 결국 모든 테스트 사례에 대해 올바른 출력을 생성합니다. Ungolfed 코드 :

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
}

온라인으로 사용해보십시오!

클로저, 39 바이트

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

하나의 기반 인덱싱을 사용 하는 인수가 n,d,x있는 익명 함수 x.

F # (. NET 코어) , 30 바이트

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

온라인으로 사용해보십시오!

(1 기반 색인 사용)

그루비, 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
}

파이썬 2 , 50,44,40, 36 바이트

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

온라인으로 사용해보십시오!

루비, 39 바이트

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

자바 스크립트 (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))

파이썬 2 , 32 바이트

0 인덱싱 사용

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

온라인으로 사용해보십시오!

편집하다:

Ørjan Johansen의 답변에서 볼 수 있듯이 원래 솔루션으로 롤백되었지만 더 이상 골프를 칠지는 않습니다.

그루비, 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

자바 스크립트 (Node.js) , 43 바이트, 포트

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

온라인으로 사용해보십시오!

자바 스크립트 (Node.js) , 51 바이트

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

온라인으로 사용해보십시오!

사용 배열 오히려 피하기 위해 재귀보다는 유래를