Tâche:

Votre tâche consiste, lorsque vous avez reçu trois entrées:

• un numérateur n
• un dénominateur d
• un autre entier, x

Créez un programme / une fonction qui trouve le xe chiffre du nombre après la décimale.

Spécifications:

• La plage de net dest comprise entre 1et 2^31 - 1, inclusive.
• La plage de xest comprise entre 1et 10,000,000, inclusive.
  • Vous pouvez choisir d'utiliser l'indexation basée sur 1 ou l'indexation basée sur 0 pour x. Veuillez indiquer dans votre réponse laquelle vous utilisez.
• npeut être plus grand que d.
• n, det xsont garantis comme des entiers positifs (pour la version d'index basée sur 1 de x, si vous choisissez d'utiliser l'indexation basée sur 0 pour xalors xpeut l'être 0).
• Vous pouvez prendre des entrées de toute manière raisonnable (c'est-à-dire de toute façon qui n'est pas une faille standard).

Règles:

• Vous devez renvoyer le xth chiffre exact , pas lorsqu'il est arrondi - donc le 15th chiffre de 1/6, par exemple, ne l'est pas 7, mais 6.
• Votre programme doit fonctionner pour tous les xmoins de 10 millions, sauf si votre langue ne prend pas en charge les décimales jusqu'à 10 millions de lieux.

Exemple d'E / S:

L'exemple d'entrée utilise une indexation basée sur 0, ce qui signifie xqu'il ira de 0à 9,999,999. En plus de cela, "l'entrée" est écrite comme une chaîne avec des espaces séparant les nombres.

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 octets

Port de ma réponse Haskell, car Python prend également en charge les bignums par défaut. Comme là, xest indexé 1.

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

Essayez-le en ligne! (empruntant l'emballage de Keerthana Prabhakaran.)

Mathematica 33 octets

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

Indexation basée sur 1.

Exemple: 10 millionième chiffre de Pi à droite du séparateur décimal:

%[Pi,1,10^7]
7

prend environ 2 secondes sur mon ancienne machine.

Vous pouvez l'essayer en ligne sur WolframAlpha (cliquez sur le signe égal)

Haskell , 26 octets

Fonctionne pour tous les cas de test. Yay bignums!

(n#d)xprend Integers et retourne un Integer. xest indexé 1.

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

Essayez-le en ligne!

PHP> = 7.1, 40 octets

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

bcdiv

Version en ligne

Gelée , 7 octets

⁵*×:ƓDṪ

Essayez-le en ligne!

Une soumission de fonction (mais fonctionne également comme un programme complet). Les fonctions Jelly ne peuvent prendre directement que deux arguments; ainsi je prends le chiffre pour retourner comme argument de gauche, le numérateur comme argument de droite et le dénominateur de l'entrée standard (au lieu d'utiliser un troisième argument).

Les gens habitués à Jelly peuvent être conscients qu'un programme complet peut prendre plus de deux arguments, mais cela vous fait perdre l'accès à la manière la plus simple d'écrire l'entier constant 10, ce qui est assez pertinent ici. En tant que tel, ce type d'entrée mixte ressemble un peu à un exploit plutôt qu'à un golf réellement utile; Personnellement, je ne suis pas d'accord avec cela, mais la règle autorisant cela est actuellement à +40 / -12, donc tant que c'est dans les règles, je peux aussi bien l'exploiter (et je dois être compétitif).

Un argument de gauche de 1 fait référence au chiffre immédiatement après la virgule décimale (le "chiffre .1s"), un argument de 2 au chiffre .01s, etc.

Explication

⁵*×:Ɠ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 a une arithmétique de précision arbitraire sur les entiers, donc en pré-multipliant par une puissance de 10, nous déplaçons effectivement le chiffre que nous voulons vers la position des unités, où il est beaucoup plus facile d'extraire.

sed -r , 93 131 136 octets

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

Essayez-le en ligne!

( Voir sortie en décimal )

Prend les entrées en unaire et les sorties en unaire, et le programme est indexé 1. Heureusement, ce défi m'a déjà préparé pour celui-ci.

Le concept est similaire, les deux implémentent une longue division. Ici, j'exécute de longs xtemps de division , où xest le chiffre après la décimale que je dois trouver. Après chaque itération, je supprime les décimales précédentes car elles ne sont plus nécessaires.

Pendant la division, le programme est au format dividend;divisor;x,result.

s/$/,/ ajoute cette virgule, la virgule est nécessaire pour séparer le résultat de tout le reste

Suit ensuite la boucle du programme principal

:d étiquette d

• s/,.+/,/ tout supprimer après la virgule

• : étiquette vide

• • s/(1+)(1*;\1;1*,)1{10}?/\21/ effectuer la division, en ajoutant 1 au résultat à chaque itération, tout en supprimant simultanément des blocs de 10 1 continus dans le résultat

• t branchez-vous sur l'étiquette vide, en d'autres termes, bouclez jusqu'à ce que le dividende soit épuisé

• s/1*/&&&&&&&&&&/ multipliez le dividende par 10 pour préparer la prochaine itération

• ta branche pour étiqueter un

• :aétiqueter a, cette ligne et la ligne ci-dessus sont nécessaires pour faire tdfonctionner

• s/1,/,/ soustraire 1 de x

tdbranche conditionnelle à d, ceci est déclenché s'il y a eu une substitution réussie puisque la dernière branche conditionnelle, depuis s/1*/&&&&&&&&&&/toujours réussie, tdsera toujours déclenchée, mais en introduisant la branche a, nous corrigeons cela de sorte que cela ne dépend que de la substitution précédente

s/.+,// enfin, supprimez tout sauf le résultat

Rubis , 34 33 octets

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

Essayez-le en ligne!

REXX, 76 octets

(Pas très court mais j'ai pensé que cela ferait un changement d'en faire un dans REXX) ​​Rexx est basé sur 1 par définition.

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

Explication:

1. Lire l'entrée des chiffres
2. Garantissez suffisamment de chiffres significatifs (la valeur par défaut est 9)
3. Calculer
4. Divisé. Trouvez la virgule décimale, comptez les caractères "x", prenez les caractères suivants et mettez-les en "z"
5. Imprimez le premier chiffre. Pad avec 0 pour être sûr.

La fusion de 3 et 4 l'allonge en fait à cause du changement de syntaxe:

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

Pour les non-REXX: les chaînes et les nombres sont totalement interchangeables dans REXX. Ils sont déterminés par la façon dont vous agissez sur eux. Vous pouvez donc analyser un nombre en utilisant des fonctions de piqûre sans conversion. Par exemple

"27" + "28"

renvoie 55 et non 2728!

Lot, 70 octets

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

Assemblage Intel x86 cpu language, 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

traduction 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

Pour le paramètre «c», la plage commence à 0; ce serait 0..0xfffffffd. Si les paramètres b = 0 ou c hors de la plage 0..0xfffffffd, il renverrait -1

Lua, 42 octets

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

C, 49 43 octets

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

L'argument «i» est l'indexation 0. Code de test et résultat

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 137 133 128 122 Octets

-3 octets grâce à Erik l'Outgolfer, j'ai totalement oublié que les importations n'avaient pas à être sur leur propre ligne

-4 octets grâce à Qwerp-Derp pour avoir déplacé n% d vers le constructeur

-6 octets remercie Kevin Cruijssen d'avoir supprimé le toString ()

J'espère que c'est ainsi que le décompte d'octets se fait pour les fonctions java avec les importations

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

Utilise la classe BigDecimal de Java pour obtenir une représentation exacte de l'expansion décimale. Notez que ce n'est pas le code le plus rapide jamais exécuté, mais qu'il produit finalement la sortie correcte pour tous les cas de test. Code non 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
}

Essayez-le en ligne!

Clojure, 39 octets

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

fonction anonyme avec des arguments n,d,xoù xutilise une indexation basée sur.

F # (.NET Core) , 30 octets

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

Essayez-le en ligne!

(utilisez l'indexation basée sur 1)

Groovy, 30 octets

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

x utilise une indexation basée sur 1.

Explication:

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

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

Essayez-le en ligne!

Rubis, 39 octets

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

JavaScript (ES6), 34 octets

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

x est basé sur 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 octets

Utilise l'indexation 0

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

Essayez-le en ligne!

Modifier:

Revenu à la solution d'origine comme le montre la réponse d'Ørjan Johansen selon laquelle cela fonctionne, mais je ne la jouerai plus

Groovy, 55 octets

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

Expliqué en utilisant 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.
}

Axiom, 71 61 76 octets

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

n est une indexation 0 [0..M]. Code de test et résultat

(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 octets, port

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

Essayez-le en ligne!

JavaScript (Node.js), 51 bytes

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

Try it online!

use Array rather than recursive to avoid stackoverflow