Tarefa:

Sua tarefa é, quando são fornecidas três entradas:

• um numerador n
• um denominador d
• outro inteiro, x

Crie um programa / função que encontre o xth dígito do número após a casa decimal.

Especificações:

• O intervalo de ne destá entre 1e 2^31 - 1, inclusive.
• O intervalo de xé entre 1e 10,000,000, inclusive.
  • Você pode optar por usar a indexação baseada em 1 ou a indexação baseada em 0 x. Indique na sua resposta qual você está usando.
• npode ser maior que d.
• n, de xsão garantidos números inteiros positivos (para a versão de índice com base em 1 x, se você optar por usar a indexação com base em 0 x, xpode ser 0).
• Você pode receber entradas de qualquer maneira razoável (isto é, de qualquer maneira que não seja uma brecha padrão).

Regras:

• Você deve retornar o xdígito exato , não quando arredondado - então o 15dígito 1/6, por exemplo, não é 7, mas 6.
• Seu programa deve funcionar para todos com xmenos de 10 milhões, a menos que seu idioma não suporte decimais a 10 milhões de casas.

Exemplo de E / S:

A entrada de exemplo usa indexação baseada em 0, o que significa que xpassará de 0para 9,999,999. Além disso, a "entrada" é escrita como uma string com espaços que separam os números.

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 bytes

Porta da minha resposta Haskell, já que o Python também suporta bignums por padrão. Como lá, xé 1 indexado.

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

Experimente online! (pegando emprestado o invólucro de Keerthana Prabhakaran.)

Mathematica 33 Bytes

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

Indexação baseada em 1.

por exemplo, 10 milhões de dígitos do Pi à direita do ponto decimal:

%[Pi,1,10^7]
7

demora cerca de 2 segundos na minha máquina antiga.

Você pode experimentá-lo online no WolframAlpha (clique no sinal de igual)

Haskell , 26 bytes

Funciona para todos os casos de teste. Yay bignums!

(n#d)xtoma se Integerretorna um Integer. xé 1 indexado.

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

Experimente online!

PHP> = 7.1, 40 bytes

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

bcdiv

Versão Online

Geléia , 7 bytes

⁵*×:ƓDṪ

Experimente online!

Um envio de função (mas também funciona como um programa completo). As funções Jelly podem levar apenas dois argumentos diretamente; portanto, pego o dígito para retornar como argumento da esquerda, o numerador como o argumento da direita e o denominador da entrada padrão (em vez de usar um terceiro argumento).

As pessoas acostumadas ao Jelly podem estar cientes de que um programa completo pode receber mais de dois argumentos, mas isso faz com que você perca o acesso à maneira mais estrita de escrever o número inteiro constante 10, o que é bastante relevante aqui. Como tal, esse tipo de contribuição mista parece mais uma exploração do que um golfe realmente útil; Pessoalmente, não concordo com isso, mas a regra sobre permitir isso atualmente é de +40 / -12, portanto, contanto que esteja dentro das regras, eu também posso explorá-lo (e praticamente preciso ser competitivo).

Um argumento à esquerda de 1 refere-se ao dígito imediatamente após o ponto decimal (o "dígito .1s"), um argumento de 2 ao dígito .01s e assim por diante.

Explicação

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

A geléia possui aritmética de precisão arbitrária em números inteiros; portanto, ao multiplicar por uma potência de 10, estamos movendo efetivamente o dígito que queremos para a posição das unidades, onde é muito mais fácil extrair.

sed -r , 93 131 136 bytes

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

Experimente online!

( Veja a saída em decimal )

Recebe entradas em unárias e saídas em unárias, e o programa é 1 indexado. Felizmente, este desafio já me preparou para este.

O conceito é semelhante, ambos implementam divisão longa. Aqui, realizo longos xtempos de divisão , onde xestá o dígito após a casa decimal que tenho que encontrar. Após cada iteração, descarto as casas decimais anteriores porque elas não são mais necessárias.

Enquanto faz a divisão, o programa está no formato dividend;divisor;x,result.

s/$/,/ adiciona essa vírgula, a vírgula é necessária para separar o resultado de todo o resto

Depois segue o loop principal do programa

:d etiqueta d

• s/,.+/,/ remova tudo após a vírgula

• : etiqueta vazia

• • s/(1+)(1*;\1;1*,)1{10}?/\21/ executar divisão, adicionando 1 ao resultado a cada iteração, removendo simultaneamente blocos de 10 1s contínuos no resultado

• t ramificar para o rótulo vazio, em outras palavras, fazer um loop até que o dividendo se esgote

• s/1*/&&&&&&&&&&/ multiplique o dividendo por 10 para se preparar para a próxima iteração

• ta ramificar para rotular um

• :arotular a, esta linha e a linha acima são necessárias para fazer o tdtrabalho

• s/1,/,/ subtrair 1 de x

tdramificação condicional em d, isso é acionado se houver uma substituição bem-sucedida desde que a última ramificação condicional, pois s/1*/&&&&&&&&&&/sempre é bem-sucedida, tdsempre será acionada, mas, ao introduzir a ramificação a, corrigimos isso para que apenas dependa da substituição anterior

s/.+,// finalmente, remova tudo, menos o resultado

Ruby , 34 33 bytes

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

Experimente online!

REXX, 76 bytes

(Não é muito curto, mas pensou que seria uma alteração fazer um no REXX) ​​O Rexx é baseado em 1 por definição.

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

Explicação:

1. Leia a entrada para os números
2. Garantir dígitos significativos suficientes (o padrão é 9)
3. Calcular
4. Dividido. Encontre o ponto decimal, conte os caracteres "x" para a frente, pegue os seguintes caracteres e coloque em "z"
5. Imprima o primeiro dígito. Almofada com 0 para ter certeza.

Mesclar 3 e 4, na verdade, torna mais longo devido à alteração na sintaxe:

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

Para não-REXXers: seqüências de caracteres e números são totalmente intercambiáveis ​​no REXX. Eles são determinados pela forma como você age sobre eles. Assim, você pode analisar um número usando as funções sting sem conversão. Por exemplo

"27" + "28"

retorna 55 e não 2728!

Lote, 70 bytes

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

Linguagem da CPU Intel x86, 50 bytes

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

tradução em 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

Para o parâmetro 'c', o intervalo começa em 0; seria 0..0xfffffffd. Se os parâmetros b = 0 ou c estiverem fora do intervalo 0..0xfffffffd, ele retornará -1

Lua, 42 bytes

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

C, 49 43 bytes

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

O argumento 'i' é de indexação 0. Código e resultado do teste

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 bytes graças a Erik, o Outgolfer, esqueci totalmente que as importações não precisavam estar em sua própria linha

-4 bytes graças ao Qwerp-Derp por mover n% d para o construtor

-6 bytes graças a Kevin Cruijssen por remover o toString ()

Espero que seja assim que a contagem de bytes é feita para funções java com importações

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

Usa a classe BigDecimal do Java para obter uma representação exata da expansão decimal. Observe que não é o código de execução mais rápida de todos os tempos, mas acaba produzindo a saída correta para todos os casos de teste. Código não destruído:

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
}

Experimente online!

Clojure, 39 bytes

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

função anônima com argumentos em n,d,xque xusa uma indexação baseada.

F # (.NET Core) , 30 bytes

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

Experimente online!

(use a indexação baseada em 1)

Groovy, 30 bytes

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

x usa 1 indexação baseada.

Explicação:

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

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

Experimente online!

Ruby, 39 bytes

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

JavaScript (ES6), 34 bytes

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

x é baseado em 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 bytes

Usa indexação 0

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

Experimente online!

Editar:

Revertida para a solução original, como visto na resposta de Ørjan Johansen de que funciona, mas não vou mais jogar golfe

Groovy, 55 bytes

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

Explicado usando 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.
}

Axioma, 71 61 76 bytes

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

n é indexação 0 [0..M]. Código e resultado do teste

(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 bytes, porta

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

Experimente online!

JavaScript (Node.js) , 51 bytes

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

Experimente online!

use Array em vez de recursivo para evitar o fluxo de pilha