Tarea:

Su tarea es, cuando se le dan tres entradas:

• un numerador n
• un denominador d
• otro entero x

Cree un programa / función que encuentre el xenésimo dígito del número después del decimal.

Especificaciones:

• El rango de ny des entre 1y 2^31 - 1, inclusive.
• El rango de xes entre 1y 10,000,000, inclusive.
  • Puede elegir usar indexación basada en 1 o indexación basada en 0 para x. Indique en su respuesta cuál está utilizando.
• npuede ser mayor que d.
• n, dy xse garantiza que son enteros positivos (para la versión de índice basada en 1 x, si elige usar la indexación basada en 0, xentonces xpuede ser 0).
• Puede tomar entradas de cualquier manera razonable (es decir, cualquier forma que no sea una laguna estándar).

Reglas:

• Debe devolver el xdígito th exacto , no cuando se redondea, por lo que el 15dígito th de 1/6, por ejemplo, no es 7, pero 6.
• Su programa debe funcionar para todos los xmenores de 10 millones, a menos que su idioma no admita decimales a 10 millones de lugares.

Ejemplo de E / S:

La entrada de ejemplo usa indexación basada en 0, lo que significa xque irá de 0a 9,999,999. Además de eso, la "entrada" se escribe como una cadena con espacios que separan los 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

El puerto de mi respuesta de Haskell, ya que Python también admite bignums por defecto. Como allí, xestá 1 indexado.

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

Pruébalo en línea! (Tomando prestado el envoltorio de Keerthana Prabhakaran).

Mathematica 33 Bytes

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

Indexación basada en 1.

ej., 10 millonésimo dígito de Pi a la derecha del punto decimal:

%[Pi,1,10^7]
7

Toma alrededor de 2 segundos en mi vieja máquina.

Puede probarlo en línea en WolframAlpha (haga clic en el signo igual)

Haskell , 26 bytes

Funciona para todos los casos de prueba. Yay bignums!

(n#d)xtoma Integers y devuelve un Integer. xestá indexado en 1.

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

Pruébalo en línea!

PHP> = 7.1, 40 bytes

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

bcdiv

Versión en línea

Jalea , 7 bytes

⁵*×:ƓDṪ

Pruébalo en línea!

Una presentación de función (pero también funciona como un programa completo). Las funciones Jelly solo pueden tomar dos argumentos directamente; por lo tanto, tomo el dígito para regresar como argumento izquierdo, el numerador como argumento derecho y el denominador de la entrada estándar (en lugar de usar un tercer argumento).

Las personas acostumbradas a Jelly pueden ser conscientes de que un programa completo puede tomar más de dos argumentos, pero hacerlo hace que pierdas el acceso a la forma más estricta de escribir el entero constante 10, que es bastante relevante aquí. Como tal, este tipo de entrada mixta se siente como un exploit en lugar de un golf útil real; Personalmente no estoy de acuerdo con eso, pero la regla sobre permitir esto está actualmente en +40 / -12, por lo que mientras esté en las reglas, también podría explotarlo (y más o menos tener que ser competitivo).

Un argumento izquierdo de 1 se refiere al dígito inmediatamente después del punto decimal (el "dígito .1s"), un argumento de 2 al dígito .01s, y así sucesivamente.

Explicación

⁵*×:Ɠ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 tiene una aritmética de precisión arbitraria en enteros, por lo que al multiplicar previamente por una potencia de 10, estamos moviendo efectivamente el dígito que queremos a la posición de las unidades, donde es mucho más fácil extraerlo.

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/.+,//

Pruébalo en línea!

( Ver salida en decimal )

Toma entradas en unario y salidas en unario, y el programa está indexado en 1. Afortunadamente, esto desafío ya me ha preparado para este.

El concepto es similar, ambos implementan una división larga. Aquí realizo una división largax tiempos de , donde xestá el dígito después del lugar decimal que tengo que encontrar. Después de cada iteración, descarto los decimales anteriores porque ya no son necesarios.

Mientras hace la división, el programa está en el formato dividend;divisor;x,result.

s/$/,/ agrega esta coma, se requiere la coma para separar el resultado de todo lo demás

Luego sigue el ciclo principal del programa

:d etiqueta d

• s/,.+/,/ eliminar todo después de la coma

• : etiqueta vacía

• • s/(1+)(1*;\1;1*,)1{10}?/\21/ realice la división, agregando 1 al resultado en cada iteración, mientras que simultáneamente elimina bloques de 10 1 continuos en el resultado

• t salte a la etiqueta vacía, en otras palabras, repita hasta que se haya agotado el dividendo

• s/1*/&&&&&&&&&&/ multiplique el dividendo por 10 para prepararse para la próxima iteración

• ta rama para etiquetar un

• :aetiqueta a, esta línea y la línea de arriba son necesarias para hacer el tdtrabajo

• s/1,/,/ restar 1 de x

tdrama condicional a d, esto se activa si ha habido una sustitución exitosa desde la última rama condicional, ya s/1*/&&&&&&&&&&/que siempre es exitosa, tdsiempre se activará, pero al introducir la rama a, lo arreglamos para que solo dependa de la sustitución anterior

s/.+,// finalmente, elimine todo menos el resultado

Ruby , 34 33 bytes

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

Pruébalo en línea!

REXX, 76 bytes

(No es muy breve, pero pensé que sería un cambio hacer uno en REXX) ​​Rexx se basa en 1 por definición.

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

Explicación:

1. Leer entrada a los números
2. Garantizar suficientes dígitos significativos (el valor predeterminado es 9)
3. Calcular
4. División. Encuentre el punto decimal, cuente hacia adelante los caracteres "x", tome los siguientes caracteres y póngalos en "z"
5. Imprime el primer dígito. Rellene con 0 para estar seguro.

La fusión de 3 y 4 en realidad lo hace más largo debido al cambio en la sintaxis:

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

Para no REXXers: las cadenas y los números son totalmente intercambiables en REXX. Están determinados por cómo actúas sobre ellos. Por lo tanto, puede analizar un número utilizando funciones de picadura sin conversión. Por ejemplo

"27" + "28"

devuelve 55 y no 2728!

Lote, 70 bytes.

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

Ensamblaje del lenguaje de 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

traducción en 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 el parámetro 'c' el rango comienza desde 0; sería 0..0xfffffffd. Si los parámetros b = 0 o c fuera del rango 0..0xfffffffd devolvería -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;}

El argumento 'i' es indexación 0. Código de prueba y resultado

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 gracias a Erik the Outgolfer, olvidé totalmente que las importaciones no tenían que estar en su propia línea

-4 bytes gracias a Qwerp-Derp por mover n% d al constructor

-6 bytes gracias Kevin Cruijssen por eliminar toString ()

Espero que así es como se realiza el recuento de bytes para las funciones de Java con importaciones

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

Utiliza la clase BigDecimal de Java para obtener una representación exacta de la expansión decimal. Tenga en cuenta que no es el código que se ejecuta más rápido, pero finalmente produce el resultado correcto para todos los casos de prueba. Código sin golf:

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
}

Pruébalo en línea!

Clojure, 39 bytes

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

función anónima con argumentos n,d,xdonde xusa una indexación basada.

F # (.NET Core) , 30 bytes

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

Pruébalo en línea!

(use indexación basada en 1)

Groovy, 30 bytes

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

x usa 1 indexación basada.

Explicación:

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

Pruébalo en línea!

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 está basado en 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

Utiliza indexación 0

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

Pruébalo en línea!

Editar:

Volví a la solución original como se ve en la respuesta de Ørjan Johansen de que funciona, pero no lo seguiré jugando.

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 es indexación 0 [0..M]. Código de prueba y resultado

(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, puerto

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

Pruébalo en línea!

JavaScript (Node.js) , 51 bytes

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

Pruébalo en línea!

use Array en lugar de recursivo para evitar stackoverflow