Dizeleri kullanmadan (girdi veya çıktı gibi, gerekli olduğu durumlar hariç) , bir tamsayının (taban 10'da) soldan n. Basamağını hesaplayın .

Girdi şu biçimde verilecektir:

726433 5

Çıktı şöyle olmalıdır:

3

"726433" ün beşinci basamağıdır.

Girdi olacak değil örneğin "00223" baştaki sıfırları içerirler.

Test senaryoları / diğer örnekler:

9 1  ->  9
0 1  ->  0
444494 5  ->  9
800 2  ->  0

Bu kod golf; en az karakter kazanır, ancak "nthDigit (x, n)" gibi yerleşik işlevler kabul edilemez .

İşte başlamanız için bazı sahte kodlar:

x = number
n = index of the digit
digits = floor[log10[x]] + 1
dropRight = floor[x / 10^(digits - n)]
dropLeft = (dropRight / 10 - floor[dropRight / 10]) * 10
nthDigit = dropLeft

Gördüğünüz gibi ben golf kodlamak için yeni ve ben bile cevap vermeden önce bir soru sormak biraz haksızlık olsa da, gerçekten bunun ne tür cevaplar oluşturduğunu görmek istiyorum. :)

Düzenleme : Ben matematiksel cevaplar için umuyordum, bu yüzden gerçekten dizeleri dizilere dönüştürme veya rakamlar listesi olarak sayılara erişebilmek güveniyor cevapları kabul edemez.

Bir kazananımız var

Yazılan "dc", 12 bayt. By DigitalTrauma .

dc , 12 bayt

?dZ?-Ar^/A%p

Bu matematiksel bir cevaptır. Şöyle çalışır:

• ? giriş numarasını oku ve yığına it
• d yığının üstünü çoğalt
• Z Yığındaki değeri çıkar, basamak sayısını hesaplar ve iter
• ? rakam dizinini oku ve yığına it
• - basamak endeksini basamak sayısından çıkart
• A 10'u yığına it
• r yığındaki ilk 2 değeri değiştir
• ^ üs 10 ^ (basamak sayısı - basamak dizini)
• / sayıyı üslü sonuçlara böl
• A 10'u yığına it
• % Son basamağı almak için mod 10 sayısını hesaplayın ve yığının üstüne itin
• p destenin üst kısmını pop ve yazdır

Eylemde:

$ {echo 987654321; eko 1; } | dc ndigit.dc
9
$ {echo 987654321; eko 2; } | dc ndigit.dc
8
$ {echo 987654321; eko 8; } | dc ndigit.dc
2
$ {echo 987654321; yankı 9; } | dc ndigit.dc
1
$ 

GolfScript (10 bayt)

~(\10base=

Bu, girdinin bir dize (örneğin stdin aracılığıyla) olduğunu varsayar. Yığında iki tamsayı varsa, ilk ~karakter kaldırılarak 1 karakter kaydedilir.

Temel dönüşümün yerleşik işlevler kuralına kötü düştüğü düşünülürse, 16 karakterlik bir alternatifim var:

~~)\{}{10/}/=10%

CJam - 7

l~(\Ab=

CJam, GolfScript'e benzer şekilde geliştirdiğim yeni bir dildir - http://sf.net/p/cjam . İşte açıklama:

lgirdi bir satır okur
~değerlendirir (böylece iki sayı elde)
(azalır ikinci sayının sayıları
\takas sayılar
A10
bbir temel dönüşüm için önceden başlatılmış bir değişkendir , ilk sayının baz-10 basamaklı bir dizi
=istenen alır dizinin elemanı

Program temelde Peter Taylor'ın çözümünün bir çevirisidir.

Haskell 60 bayt ve okunabilir

nth x n
        | x < (10^n) = mod x 10
        | True = nth (div x 10) n

dizge yok!

*Main> nth 1234567 4
4

J - 15 24 karakter

Yeterince "matematiksel bir cevap".

(10|[<.@*10^]-10>.@^.[)/

Aşağıdaki ile aynı sonuçlar, ancak matematiksel olmanın mistik kalitesi ile donatılmıştır.

Base-10 genişletme kullanan kısa versiyon.

({0,10&#.inv)~/

1 tabanlı dizine eklemek için 0 başına başlıyoruz.

Kullanımı:

   ({0,10&#.inv)~/ 1234567 3
3
   ({0,10&#.inv)~/ 444494 5
9

Python 127

def f(i,n):
 b=10;j=i/b;k=1;d=i-j*b
 while j>0:
  k+=1;j/=b
 if n>k:
  return -1
 while k>n:
  k-=1;j/=b;i/=b;d=i-j*b
 return d

C, 50

Bu dizileri kullanır.

main(int c,char**a){putchar(a[1][atoi(a[2])-1]);}

Tüm uyarıları dikkate almayın.

Ve evet, C'de, dizeler gerçekten sadece diziler, bu yüzden bu biraz ucuz.

Daha Matematiksel:

C, 83

main(int c,char**a){printf("%d",(atoi(a[1])/pow(10,strlen(a[1])-atoi(a[2])))%10);}

m.ö. (bash tarafından tahrik edilen), 41 29

Bence bu, dizelerle değil, matematiksel olarak yapılan ilk cevaptır:

bc<<<"$1/A^(length($1)-$2)%A"

length()Belki de kullanımı biraz ip gibi görünüyor, ancak bc man sayfası dize uzunluğundan değil basamak sayısından bahsediyor:

  length ( expression )
          The value of the length function is the  number  of  significant
          digits in the expression.

Çıktı:

$ ./ndigits.bc.sh 726433 5
3
$ ./ndigits.bc.sh 9 1
9
$ ./ndigits.bc.sh 0 1
0
$ ./ndigits.bc.sh 444494 5
9
$ ./ndigits.bc.sh 800 2
0
$ 

Mathematica - 24 23

Bu biraz açık :)

IntegerDigits[#][[#2]]&

Misal:

IntegerDigits[#][[#2]]& [726433, 5]

Çıktı:

3

İki tamsayıyı kodlayarak daha kısaltabilirsiniz, örn.

IntegerDigits[n][[m]]

ama önce yazmalısınız n = 726433; m = 5;. İşlev çağrısı bir programa daha çok benziyordu.

C 145

Program, tamsayı sonundan mesafeyi bulur ve dizine erişilene kadar bölünür ve son basamağı almak için modül 10'u kullanır.

int main()
{
int i,a,b,d,n;
scanf("%d %d",&i,&a);
d=(int)(log(i)/log(10))+1;
n=d-a;
while(n--){i=(int)(i/10);}
b=i%10;
printf("%d",b);
}

Wolfram Alpha - 40 ila 43 arasında

Tabii ki, tamamen kullanmanın IntegerDigitsbir hile olduğunu savunabilirim

"nthDigit (x, n)" gibi yerleşik işlevler

Ama önceki cevabım hala biraz hile gibi geldiğinden, işte bir alternatif. Ne yazık ki biraz daha uzun, ama benden daha fazla kısaltmayı görmedim.

Önceki gibi benzer şekilde sayma (ve işareti ile, herhangi bir argüman iletmeden),

Mod[Trunc[#/10^(Trunc[Log10[#]]-#2+1)],10]&

43 karakterden oluşur. Üsleri yok sayarak ve terimleri karıştırarak bir aritmetik operatörü kaybedebilirim ( 10^(...)xçarpma olarak yorumlanacak)

Mod[Trunc[10^(#2-Trunc[Log10[#]]-1)#],10]&

Mathematica'yı test etmek için elimde değil, Mathematica'da şüphelendiğim (ve kukac67 tarafından doğrulandığı gibi) olacağından şüphe ediyorum , bu kabul edilmiyor, ancak WolframAlpha'da çalışıyor .

Kullanımı hakkında şüphem var RealDigits, çünkü kendimi IntegerDigitsbu cevap için kullanmaktan kısıtladım ve oldukça benzerler. Ancak, kendime dahil etmeme izin verirseniz (sonuçta, tamsayıları doğrudan döndürmez, sadece kaç tane var), başka bir iki karakteri kesebilirim:

Mod[Trunc[10^(#2-RealDigits[#]-1)#],10]&

Tcl (42 bayt, lambda):

{{x y} {expr $x/10**int(log10($x)+1-$y)%10}}

(49 bayt, işlev):

proc f {x y} {expr $x/10**int(log10($x)+1-$y)%10}

(Kabuktan gelen girdileri kabul etmemiz gerekirse 83 bayt):

puts [expr [lindex $argv 0]/10**int(log10([lindex $argv 0])+1-[lindex $argv 1])%10]

R (60)

Rakam sayısını hesaplamak için log10 kullanarak problem çözüldü. Özel durum x == 0 13 karakter, iç çeker.

f=function(x,n)if(x)x%/%10^(trunc(log10(x))-n+1)%%10 else 0

Ungolfed:

f=function(x,n)
  if(x) 
    x %/% 10^(trunc(log10(x)) - n + 1) %% 10
  else
    0

kullanım

> f(898,2)
[1] 9

Scala ( 133 99 bayt):

Tüm pozitif girişler için çalışır. Sağdan aradığınız rakamın gücüne 10 ile bölünür, sonra modulo 10'u alır.

def k (i: Dizi [Dize]) = {val m = i (0) .toInt
(M, * Math.pow (10 i (1) .toInt-1-Math.log10 (m) toInt)). ToInt% 10}

Önceki formüldeki hatayı fark ettiğiniz için teşekkür ederiz. Bu daha kısadır.

Haskell, 142

Soruyu doğru anladığımdan emin değilim, ama istediğini düşünüyorum: stdin (dize) okuyun, iki sayıyı int (dize değil) yapın, bazı algoritmik şeyler yapın ve sonra sonucu (dize) çıkarın. Ben 142 karakter içine sıkışmış, ki bu çok fazla:

import System.Environment
a%b|a>9=div a 10%(b+1)|1<2=b
x#n=x`div`10^(x%1-n)`mod`10
u[a,b]=read a#read b
main=fmap(u.words)getContents>>=print

örnek kullanım:

> echo 96594 4 | getIndex
9

JavaScript - 84

p=prompt,x=+p(),m=Math;r=~~(x/m.pow(10,~~(m.log(x)/m.LN10)+1-+p()));p(r-~~(r/10)*10)

Tamamen matematiksel, dizgi yok, hiçbiri. İlk istemdeki ilk sayıyı, ikinci istemdeki ikinci sayıyı alır.

Test Durumu :

Input: 97654 5
Output: 4

Input: 224658 3
Output: 4

Kodlanmamış Kod:

p = prompt,
x = +p(), // or parseInt(prompt())
m = Math;

r = m.floor( x / m.pow(10, m.floor(m.log(x) / m.LN10) + 1 - +p()) )
//                                               ^-- log(10) ^-- this is `n`

p(r - ~~(r / 10) * 10) // show output

perl, 38, 36   hayır 30 karakter

(satır beslemeyi saymaz)

Bu, komut anahtarı nedeniyle tartışmalı olarak hile yapıyor, ancak oynamama izin verdiğiniz için teşekkürler :-)

~/$ cat ndigits.pl
say((split//,$ARGV[0])[$ARGV[1]-1]);
~/$ tr -cd "[:print:]" < ndigits.pl |wc -m 
36
~/$ perl -M5.010 ndigits.pl 726433 5 
3

düzenleme :

2 karakteri kaldırabildi:

 say for(split//,$ARGV[0])[$ARGV[1]-1];
 say((split//,$ARGV[0])[$ARGV[1]-1]);

... sonra 6 tane daha:

 say((split//,shift)[pop()-1]);

Nasıl

İlk argümanın girdisini sıfır indeksli dizi oluşturarak $ARGV[0]karakter ( split//) ile böldük; $ARGV[1]betiğe ikinci bağımsız değişkene bir tane eklemek , dizede veya ilk bağımsız değişkende o konumdaki öğeye karşılık gelir. Daha sonra içindeki ifadeyi yineleyecek ()tek bir öğe listesi olarak tutarız say. Daha kısa kısa versiyon için sadece shiftilk argümandayız ve @ARGV'nin kalan kısmını dizin için kullanmak için kullanıyoruz - bir kez shifted sadece ikinci argüman kalır pop()ve biz 1 çıkarırız.

Bu bir matematik egzersizi mi olmalı? Ben sadece girdi dize okunan bir dize indeksleme fark, bu yüzden ... Sanırım kaybetmek ?? Paralel golf sahasında bir anlam ifade edersem beni işaretleyin ve daha matematiksel olarak ayrı bir cevapta tekrar deneyeceğim.

şerefe,

PHP, 58

Yalnızca matematik kullanma

<?$n=$argv[1];while($n>pow(10,$argv[2]))$n/=10;echo $n%10;

~ - ~! - 94 93

Kuralları biraz büker - n'yi girdi olarak alan ve n'nin basamağını bulmak için sayının '''''- ve ~ - ~! şamandıraları desteklemez.

'=~~~~~,~~:''=|*==~[']<''&*-~>,'|:'''=|*==%[%]~+*/~~~~/~~|:''''=|'''''/''&<<'''&'''''>-*-~>|:

'''''=~~~~,~~,~~,~~,~~,~~:''''''=''''&~:neden olur ''''''olmak ~~(2) ( '' '''= 128).

Python 2.7 (89 bayt)

Rakamların listesini kullanarak tamsayıyı "polinom" a dönüştürüyorum. Bunu kabul edemeyeceğini söylediğini biliyorum, ama nedenlerinin matlarının polikomiyalleri olarak temsil edilen matematiksel kavramları kullandığından neden göremiyorum. Yalnızca iletilen tam sayı olduğunda başarısız olur 0, ancak yastıklı sıfır yok dediniz;)

import sys;v=sys.argv;p,x,n=[],int(v[1]),int(v[2])
while x:p=[x%10]+p;x//=10
print p[n-1]

Farklı çalıştır test.py:

$ python test.py 726489 5
8

Kabuk girdisini istediğinizi ve girdinin dizeler olacağı gerçeğinden yararlanamayacağımı varsayıyorum. Kabuk girdisini atlamak, sadece 43 bayttır:

p=[]
while x:p=[x%10]+p;x//=10
print p[n-1]

Gereksiz yineleme kullanmama rağmen, ek bir azalma eklemeyerek bazı baytları kaydediyorum n.

Genişletilmiş BrainFuck : 49

+[>>,32-]<<-[<<-],49-[->>>[>>]+[<<]<]>>>[>>]<33+.

Kullanımı:

% bf ebf.bf < nth-digit.ebf > nth-digit.bf
% echo "112234567 7" | bf nth-digit.bf 
5

Ben çarpma operatörü (örn. 10+ => ++++++++++) Dışında EBF herhangi bir özel özelliklerini kullanmıyorum . Bunun dışında çoğunlukla saf BrainFuck

Nasıl çalışır:

+                ; Make a 1 in the first cell
[>>,32-]         ; while cell is not zero: read byte 2 to the right and reduce by 32 (space)
<<-[<<-]         ; move back to the first cell by reducing every cell with 1
,49-             ; read index, reduce by 49 so that ascii 1 becomes 0
[->>>[>>]+[<<]<] ; use that to fill a trail of breadcrumbs to the desired number
>>>[>>]          ; follow the breadcrumbs
<33+.            ; go to value part, increase by 33 (32 + 1 which we substracted) and print

Şema (R6RS): 100 (gereksiz boşluk olmadan)

(let*((x(read))(n(read))(e(expt 10(-(floor(+(/(log x)(log 10))1))n))))
  (exact(div(mod x(* e 10))e)))

awk - 53

{for(d=10^9;!int($1/d)||--$2;d/=10);$0=int($1/d)%10}1

1. 32 bit imzasız int için mümkün olan maksimum değerden başlayarak rakamları bölünerek kırpın
2. tamsayının sol tarafına bastığımızda, int ($ 1 / d) sıfırdan farklı bir değer döndürür
3. devam etmek için n ($ 2) basamak

Ungolfed:

{
    for(d = 1000000000; int($1 / d) != 0 || --$2; d /= 10);
    print int($1 / d) % 10;
}

Scala (83)

Herhangi bir Scala özelliği kullanmaz. Aksine standart çözüm.

def f(x:Int,n:Int)=if(x==0)0 else x/(math.pow(10,math.log10(x).toInt-n+1)).toInt%10

Ungolfed:

def f(x:Int,n:Int) = 
  if(x==0)
    0
  else
    x / (math.pow(10, math.log10(x).toInt - n + 1)).toInt % 10 

C, 94

main(x,y,z,n){scanf("%d%d",&x,&y);for(z=x,n=1-y;z/=10;n++);for(;n--;x/=10);printf("%d",x%10);}

C, 91, diziler kullanıldığından geçersiz.

main(x,y,z){int w[99];scanf("%d%d",&x,&y);for(z=0;x;x/=10)w[z++]=x%10;printf("%d",w[z-y]);}

Julia 37

d(x,y)=div(x,10^int(log10(x)-y+1))%10

Yerleşik ^ operatörü sayesinde. Keyfi hassasiyet aritmetiği herhangi bir boyut int sağlar.

Örneklem

julia> d(1231198713987192871,10)
3

perl (biraz daha mathy / çok golf değil) - 99 karakter

 ~/$ cat ndigits2.pl
  ($n,$i)=@ARGV;
  $r=floor($n/10**(floor(log($n)/log(10)+1)-$i));
  print int(.5+($r/10-floor($r/10))*10);

Şu şekilde çalıştırın:

 perl -M5.010 -MPOSIX=floor ndigits.pl 726433 1

Perl6 - 85 karakter

my ($n,$i)=@*ARGS;
my$r=$n/10**(log10($n).round-$i);
say (($r/10-floor($r/10))*10).Int;

Smalltalk, 44

Dc rakipsiz olsa da, işte bir Smalltalk çözümü:

argümanlar, n sayısı; d basamak-çıkarmak için:

[:n :d|(n//(10**((n log:10)ceiling-d)))\\10]