Görev:

Göreviniz, üç girdi verildiğinde:

• bir pay n
• bir payda d
• başka bir tam sayı, x

xOndalık basamaktan sonra sayının inci basamağını bulan bir program / işlev oluşturun .

Özellikleri:

• Aralığı nve darasındadır 1ve 2^31 - 1dahil.
• Aralığı xarasında 1ve 10,000,000, dahil.
  • İçin 1 tabanlı indeksleme veya 0 tabanlı indeksleme kullanmayı seçebilirsiniz x. Lütfen cevabınızı hangisini kullandığınızı belirtiniz.
• ndaha büyük olabilir d.
• n, dVe xpozitif tamsayılar olması garanti edilir (1 tabanlı dizin versiyonu için xiçin kullanmak seçerseniz, indeksleme 0 tabanlı xsonra xolabilir 0).
• Girişleri makul bir şekilde alabilirsiniz (standart bir boşluk olmayan herhangi bir şekilde).

Kurallar:

• Tam xbasamağı döndürmelisiniz, yuvarlandığında değil - yani, örneğin 15dördüncü basamak değil .1/676
• xDiliniz 10 milyon yere kadar ondalık desteklemiyorsa, programınız 10 milyonun altındaki herkes için çalışmalıdır .

Örnek G / Ç:

Örnek giriş 0-tabanlı indekslemeyi kullanır, yani ' xden' 0ye gidecektir 9,999,999. Bunun yanı sıra, "giriş" sayıları ayıran boşluklarla bir dize olarak yazılır.

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 bayt

Python da varsayılan olarak bignumları desteklediğinden Haskell portumun limanı. Orada xolduğu gibi , 1 indeksli.

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

Çevrimiçi deneyin! (Keerthana Prabhakaran'ın ambalajını ödünç alıyor.)

Mathematica 33 Bayt

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

1 tabanlı indeksleme.

örneğin, ondalık basamağın 10 milyonuncu Pi sağındaki rakam:

%[Pi,1,10^7]
7

eski makinemde yaklaşık 2 saniye sürüyor.

WolframAlpha'da çevrimiçi deneyebilirsiniz (eşittir işaretine tıklayın)

Haskell , 26 bayt

Tüm test durumları için çalışır. Yay bignums!

(n#d)xIntegers alır ve bir döndürür Integer. x1 indeksli.

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

Çevrimiçi deneyin!

PHP> = 7.1, 40 Bayt

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

bcdiv

Çevrimiçi sürüm

Jöle , 7 bayt

⁵*×:ƓDṪ

Çevrimiçi deneyin!

Bir işlev sunumu (ancak aynı zamanda tam bir program olarak çalışır). Jelly işlevleri doğrudan iki argüman alabilir; bu nedenle, sol argüman olarak geri dönmek, doğru argüman olarak payer ve standart girdiden payda almak için üçüncü bir argüman kullanın (üçüncü bir argüman kullanmak yerine).

Jelly’e alışkın olan insanlar, tam bir programın ikiden fazla argüman alabileceğinin farkında olabilirler, ancak bunu yapmak, burada oldukça ilgili olan sabit tamsayı 10’u yazmanın en ters yoluna erişiminizi kaybetmenize neden olur. Dolayısıyla, bu tür karma girdiler fiili kullanışlı golf oynamaktan çok bir istismar gibi geliyor; Ben şahsen buna katılmıyorum, ama buna izin vermeyle ilgili kural şu anda +40 / -12 seviyesinde.

1 'in sol argümanı ondalık noktasından hemen sonraki haneye (".1s basamağı"), 2 ila .01s basamağının argümanına vb. Atıfta bulunur.

açıklama

⁵*×:Ɠ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, tamsayılar üzerinde keyfi bir aritmetik özelliğine sahiptir, bu yüzden 10'luk bir güçle çarparak, elde etmek istediğimiz rakamı, çıkarmanın çok daha kolay olduğu birimler konumuna getiriyoruz.

sed -r , 93 131 136 bayt

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

Çevrimiçi deneyin!

( Ondalık çıktıya bakınız )

Tekdüzen girdi alır ve tekdüzen çıktı alır ve program 1 indekslidir. Neyse ki, bu zorluk beni bunun için hazırladı.

Kavramı benzer, her ikisi de uzun bölünme uygular. Burada, uzun bölme xzamanları xyapıyorum, bulmam gereken ondalık sayısından sonraki basamak. Her yinelemeden sonra, artık gerekli olmadıkları için önceki ondalık basamakları atarım.

Bölünme yaparken, program biçimindedir dividend;divisor;x,result.

s/$/,/ Bu virgül ekler, virgül sonucu her şeyden ayırmak için gereklidir

Ardından ana program döngüsünü takip eder

:d d etiketi

• s/,.+/,/ virgülden sonra her şeyi kaldır

• : boş etiket

• • s/(1+)(1*;\1;1*,)1{10}?/\21/ Her yinelemenin sonucuna 1 ekleyerek bölme yapın, sonuçta 10 sürekli 1'lik blokları eşzamanlı olarak çıkartırken

• t boş etikete dal, diğer bir deyişle, temettü tükenene kadar döngü

• s/1*/&&&&&&&&&&/ Bir sonraki tekrarlamaya hazırlanmak için kar payını 10 ile çarpın

• ta bir etiketlemek için şube

• :aa etiketi, bu satır ve yukarıdaki satırın tdçalışması için gereklidir

• s/1,/,/ x'i 1'den çıkar

tdkoşullu daldan d'ye, bu s/1*/&&&&&&&&&&/her zaman başarılı olduğu için son koşullu daldan bu yana başarılı bir yer değiştirmenin gerçekleşmesi durumunda tdtetiklenir, ancak tetiklenir her zaman tetiklenir, ancak dalın tanıtılmasıyla, bunu yalnızca önceki yer değiştirmeye bağlı olacak şekilde düzeltiriz.

s/.+,// Sonunda, sonuç dışındaki her şeyi kaldırın.

Ruby , 34 33 bayt

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

Çevrimiçi deneyin!

REXX, 76 bayt

(Çok kısa değil, ancak REXX’te bir değişiklik yapacağı düşünülüyor) Rexx tanım gereği 1 tabanlıdır.

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

Açıklama:

1. Rakamlara okuma girişi
2. Yeterince önemli basamak garanti (varsayılan 9)
3. Hesaplamak
4. Bölünmüş. Ondalık noktayı bulun, "x" karakterlerini sayın, aşağıdaki karakterleri alın ve "z" ye koyun
5. İlk basamağı yazdır. Emin olmak için 0 tuşunu kullanın.

3 ve 4'ü birleştirmek aslında sözdizimindeki değişiklik nedeniyle daha uzun sürüyor:

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

REXX üyesi olmayanlar için: REXX'te stringler ve sayılar tamamen birbiriyle değiştirilebilir. Onlar üzerinde nasıl davrandığınıza göre belirlenirler. Böylece, sting işlevlerini dönüştürmeden kullanarak bir sayı ayrıştırabilirsiniz. Örneğin

"27" + "28"

55 döndürür 2728!

Toplu iş, 70 bayt

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

Assembly Intel x86 işlemci dili, 50 bayt

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 içinde dökülme

; 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' parametresi için aralık 0'dan başlar; 0..0xfffffffd olacaktır. B = 0 veya c parametreleri 0..0xfffffffd aralığının dışındaysa -1 döndürür

Lua, 42 bayt

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

C 49 43 bayt

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

'i' argümanı 0 indekslemedir. Test kodu ve sonucu

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 Bayt

-3 bayt, Outgolfer Erik sayesinde, ithalatın kendi satırında olması gerekmediğini tamamen unutmuşum

% N oluşturucuya taşınması için Qwerp-Derp sayesinde -4 bayt

-6 bayt, toString'i () çıkardığı için Kevin Cruijssen'e teşekkür etti.

İnşallah Java ile java fonksiyonları için byte sayımı bu şekilde yapılır.

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

Ondalık genişletmenin tam gösterimini elde etmek için Java'nın BigDecimal sınıfını kullanır. Unutmayın, şimdiye kadarki en hızlı çalışan kod değil ama sonunda tüm test durumları için doğru çıktılar üretiyor. Ungolfed kod:

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
}

Çevrimiçi deneyin!

Clojure, 39 bayt

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

argümanlarla anonim işlev n,d,xnerede xbir bazlı indeksleme kullanır.

F # (.NET Çekirdeği) , 30 bayt

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

Çevrimiçi deneyin!

(1 tabanlı dizin oluşturma kullanın)

Harika, 30 bayt

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

x 1 tabanlı indeksleme kullanır.

Açıklama:

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

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

Çevrimiçi deneyin!

Ruby, 39 bayt

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

JavaScript (ES6), 34 bayt

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

x 0 tabanlıdır

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 bayt

0 indeksleme kullanır

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

Çevrimiçi deneyin!

Düzenle:

Ørjan Johansen'in cevabının işe yaradığı cevabında görüldüğü gibi orijinal çözüme geri döndü, ancak daha fazla golf oynamayacağım

Groovy, 55 bayt

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

Kullanarak açıkladı 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.
}

Aksiyom, 71 61 76 bayt

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 indekslemedir [0..M]. Test kodu ve sonucu

(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 bayt, bağlantı noktası

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

Çevrimiçi deneyin!

JavaScript (Node.js) , 51 bayt

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

Çevrimiçi deneyin!

Kullanım Dizisi ziyade önlemek için özyinelemeli daha stackoverflow