¡Obtén el decimal!

23

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
clismique
fuente
2
Este desafío es un subconjunto de este
Bassdrop Cumberwubwubwub
8
Tampoco creo que sea un subconjunto del Pi, ya que ese habla de 1 número irracional específico, ya que este habla de cada número racional
Felipe Nardi Batista
1
@FelipeNardiBatista Hmmm ... Podría argumentar que esto debería ser al revés, ya que este desafío se especifica más con los rangos y esas cosas (esto ha sucedido antes, donde un desafío más antiguo se marca como un engaño de un desafío más nuevo). Sin embargo, no estoy seguro.
clismique
2
Es posible hacer el ejercicio, con facilidad, incluso en un idioma que no tiene número grande ...
RosLuP

Respuestas:

12

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).

Ørjan Johansen
fuente
Muy bien, pasé un par de minutos preguntándome "¿fue realmente tan fácil"? Un puerto a Ruby tendría solo 21 bytes.
GB
6

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)

Kelly Lowder
fuente
6

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!

Ørjan Johansen
fuente
5

PHP> = 7.1, 40 bytes

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

bcdiv

Versión en línea

Jörg Hülsermann
fuente
Recibo este error cuando ejecuto su código:<br /> <b>Notice</b>: Uninitialized string offset: -1 in <b>[...][...]</b> on line <b>6</b><br />
clismique
@ Qwerp-Derp Lo sentimos, necesita una versión PHP gte 7.1 y el sitio será la primera visita, no lo cambie a la versión más alta
alta
4

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.


fuente
4

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

Kritixi Lithos
fuente
3

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!

theblitz
fuente
¿Podría agregar un enlace a un intérprete? Me imagino que muchos usuarios no están familiarizados con este lenguaje.
Mego
tutorialspoint.com/execute_rexx_online.php único problema es que no pude averiguar cómo ingresar valores en el intérprete. Entonces, para propósitos de prueba, usé asignaciones para establecer los valores al comienzo.
theblitz
1
Parece que ese intérprete funciona si le das a CLI una entrada como rexx main.rexx 1 2 3. Debe mencionar en su respuesta que la entrada está indexada en 1.
Mego
No noté la posibilidad de entrada porque simplemente hice clic en el botón de ejecución en la parte superior. Duh
theblitz
2

Lote, 70 bytes.

@set n=%1
@for /l %%x in (0,1,%3)do @set/an=n%%%2*10
@cmd/cset/an/%2
Neil
fuente
@FelipeNardiBatista Me funcionó cuando lo probé.
Neil
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

RosLuP
fuente
1

Lua, 42 bytes

function a(n,x,d)
print((n*10^x/d)%10)
end
Connor Belli
fuente
1
Hola y bienvenidos a PPCG! Esta es una gran primera respuesta!
NoOneIsHere
1

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 
RosLuP
fuente
1

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!

PunPun1000
fuente
Los espacios después de las comas y la nueva línea después del punto y coma se pueden eliminar, creo.
Erik the Outgolfer
Cuento
Debe haber contado mal gracias
PunPun1000
¿No puedes reemplazar BigDecimal(n)con BigDecimal(n%d), y deshacerse de la n=n%d?
clismique
Puede eliminar .toString()y usar +""en su lugar (con dos paréntesis adicionales).
Kevin Cruijssen
1

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.

Matias Bjarland
fuente
1

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)

Solo otro metaprogramador
fuente
Cuento 33 bytes. También sugeriría agregar un ¡ Pruébelo en línea! enlazar.
wastl
Tenía la función incorrecta en mi portapapeles. Gracias.
Solo otro metaprogramador
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
}
Matias Bjarland
fuente
0

Python 2 , 50,44,40, 36 bytes

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

Pruébalo en línea!

Keerthana Prabhakaran
fuente
no funciona para1,7,10000000
Felipe Nardi Batista
0

Ruby, 39 bytes

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

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

Weedoze
fuente
Desafortunadamente, como mi solución, esto fallará con decimales largos; prueba f(1,7,10000000), por ejemplo.
Shaggy
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.

Felipe Nardi Batista
fuente
2
Si no es válido, debería eliminarse.
Erik the Outgolfer
como la mayoría de las respuestas hasta ahora
Felipe Nardi Batista
@EriktheOutgolfer lo arregló ...
Felipe Nardi Batista
¿Utiliza la indexación 1?
Erik the Outgolfer
Pruébalo en línea!
Jonathan Allan
0

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.
}
Urna de pulpo mágico
fuente
0

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
RosLuP
fuente