문자열을 사용하지 않고 (필요한 경우 입력 또는 출력과 같은 경우 제외) 왼쪽 에서 정수의 10 번째 자릿수 (기본 10)를 계산합니다.

입력은 다음 형식으로 제공됩니다 :

726433 5

출력은 다음과 같아야합니다.

3

"726433"의 다섯 번째 자리입니다.

입력에 선행 0이 포함 되지 않습니다 ( 예 : "00223").

테스트 사례 / 추가 예 :

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

이것은 코드 골프입니다. 문자 수가 가장 적지 만 "nthDigit (x, n)"과 같은 내장 함수는 사용할 수 없습니다 .

시작하는 의사 코드는 다음과 같습니다.

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

보시다시피, 저는 골프를 처음 봤는데 질문에 대답하기 전에 질문을하는 것이 약간 불공평하다고 생각하지만, 이것이 어떤 종류의 반응을 일으키는 지보고 싶습니다. :)

편집 : 수학 답변을 원했기 때문에 문자열을 배열로 변환하거나 숫자 목록으로 숫자에 액세스 할 수있는 답변을 실제로 받아 들일 수 없습니다.

우리는 승자가있다

12 바이트 "dc"로 작성되었습니다 . 으로 DigitalTrauma .

dc , 12 바이트

?dZ?-Ar^/A%p

이것은 수학적 답입니다. 작동 방식은 다음과 같습니다.

• ? 입력 번호를 읽고 스택으로 푸시
• d 스택 상단 복제
• Z 스택에서 값을 꺼내서 자릿수를 계산하고 푸시합니다.
• ? 숫자 인덱스를 읽고 스택으로 푸시
• - 숫자 카운트에서 숫자 인덱스 빼기
• A 스택에 10을 밀어 넣습니다
• r 스택에서 상위 2 개 값 바꾸기
• ^ 지수 10 ^ (숫자 카운트-숫자 인덱스)
• / 지수화에 의한 수 나누기
• A 스택에 10을 밀어 넣습니다
• % 숫자 10을 계산하여 마지막 숫자를 가져오고 스택 맨 위로 밉니다.
• p 스택 상단을 튀어 나와 인쇄

행동 :

$ {에코 987654321; 에코 1; } | dc ndigit.dc
9
$ {에코 987654321; 에코 2; } | dc ndigit.dc
8
$ {에코 987654321; 에코 8; } | dc ndigit.dc
2
$ {에코 987654321; 에코 9; } | dc ndigit.dc
1
$ 

GolfScript (10 바이트)

~(\10base=

이것은 입력이 문자열로 가정합니다 (예 : stdin을 통해). 스택에서 정수가 두 개이면 첫 글자 ~를 제거하여 1자를 저장해야합니다.

기본 변환이 내장 함수 규칙에 위배되는 것으로 간주되면 16 문자 대안이 있습니다.

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

CJam-7

l~(\Ab=

CJam은 GolfScript- http: //sf.net/p/cjam과 비슷한 새로운 언어 입니다. 설명은 다음과 같습니다.

l입력으로부터 라인 읽기
~문자열 (따라서 두 숫자 점점) 평가
(번째 숫자 감소
\교환 수를
A10 preinitialized 변수가
b첫 번째 숫자의 기초 10 자리 배열을 만드는 기본 변환을 수행
=하여 원하는 도착 배열의 요소

이 프로그램은 기본적으로 Peter Taylor의 솔루션을 번역 한 것입니다.

Haskell 60 바이트 및 읽기 가능

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

문자열이 없습니다!

*Main> nth 1234567 4
4

J- 15 24 자

충분히 "수학적 답".

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

아래와 같은 결과이지만 수학적인 신비로운 특성이 부여됩니다.

기본 10 확장을 사용하는 짧은 버전입니다.

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

1 기반 인덱싱에 맞게 0을 추가합니다.

용법:

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

파이썬 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

이것은 배열을 사용합니다.

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

모든 경고를 무시하십시오.

그리고 그렇습니다. C에서 문자열은 실제로 배열 일 뿐이므로 값이 싸습니다.

더 수학적 :

C, 83

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

기원전 (bash에 의해 구동), 41 29

나는 이것이 문자열이 아닌 수학적으로 이것을하는 첫 번째 대답이라고 생각합니다.

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

length()아마도 문자열을 사용하는 것은 다소 까다로울 수 있지만 bc 맨 페이지는 문자열의 길이가 아닌 자릿수에 대해 이야기합니다.

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

산출:

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

매스 매 티카 -24 23

이것은 분명하다 :)

IntegerDigits[#][[#2]]&

예:

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

산출:

3

두 정수를 하드 코딩하면 더 짧아 질 수 있습니다.

IntegerDigits[n][[m]]

하지만 먼저 작성해야합니다 n = 726433; m = 5;. 함수 호출은 프로그램과 더 비슷하다고 느꼈습니다.

C 145

프로그램은 정수의 끝에서 거리를 찾아 인덱스에 도달 할 때까지 나눈 다음 계수 10을 사용하여 마지막 숫자를 얻습니다.

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

볼프람 알파-40 ~ 43

물론, 나는 사용하는 IntegerDigits것이 속지 않는 트릭임을 완전히 방어 할 수 있습니다.

"nthDigit (x, n)"과 같은 내장 함수

그러나 이전의 대답은 여전히 ​​약간의 바람을 피우는 것처럼 느껴졌으므로 여기에 대안이 있습니다. 불행히도 그것은 조금 더 길지만, 내가했던 것보다 더 짧게하는 방법을 보지 못했습니다.

이전과 비슷한 방식으로 계산합니다 (인수를 사용하지 않고 앰퍼샌드로).

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

43 자입니다. 지수를 부정하고 용어를 섞으면 서 하나의 산술 연산자를 잃을 수 있습니다 ( 10^(...)x곱셈으로 해석됩니다)

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

나는 테스트 할 Mathematica를 가지고 있지 않습니다 .Mathematica 에서 의심되는 (그리고 kukac67에 의해 친절하게 검증 된 ) 이것이 받아 들여지지는 않지만 WolframAlpha에서 실행됩니다 .

이 답변에 대한 RealDigits사용 IntegerDigits을 제한 했으며 매우 유사 하기 때문에 의 사용에 대해 의문의 여지가 있습니다 . 그러나, 나는 나 자신을 포함 (결국, 그것은 얼마나 직접 정수를 반환하지 않습니다 허용하는 경우 많은 , 내가 다른 두 개의 문자를 슬래시 수있다 그들 중) :

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

Tcl (42 바이트, 람다) :

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

(49 바이트, 기능) :

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

(셸에서 입력을 받아야하는 경우 83 바이트) :

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

R (60)

자릿수를 계산하기 위해 log10을 사용하여 문제를 해결했습니다. 특수한 경우 x == 0은 13 자 (한숨)입니다.

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

언 골프 드 :

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

용법

> f(898,2)
[1] 9

스칼라 ( 133 99 바이트) :

모든 긍정적 인 입력에 작동합니다. 오른쪽에서 찾은 숫자의 거듭 제곱으로 10을 나눈 다음 모듈로 10을 취합니다.

데프 k (i : 배열 [문자열]) = {val m = i (0) .toInt
(m * Math.pow (10, i (1) .toInt-1-Math.log10 (m) toInt)). toInt % 10}

이전 공식의 버그를 확인해 주셔서 감사합니다. 이것은 더 짧습니다.

하스켈, 142

나는 질문을 올바르게 이해했는지 잘 모르겠지만 이것이 내가 원하는 것입니다 : stdin (문자열)을 읽고 두 숫자를 int (문자열 아님)로 만들고 알고리즘을 수행 한 다음 결과 (문자열)를 출력하십시오. 나는 그것을 142 문자로 넣었습니다.

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

사용법 예 :

> echo 96594 4 | getIndex
9

자바 스크립트-84

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

순전히 수학적이고, 문자열도없고, 그들도 없습니다. 첫 번째 프롬프트에서 첫 번째 숫자를, 두 번째 프롬프트에서 두 번째 숫자를 취합니다.

테스트 사례 :

Input: 97654 5
Output: 4

Input: 224658 3
Output: 4

Ungolfed Code :

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

펄, 38, 36   , 30 자

(줄 바꿈을 세지 않음)

이것은 명령 스위치로 인해 부정 행위 일 것입니다.하지만 게임 해 주셔서 감사합니다 :-)

~/$ 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

편집 :

2자를 제거 할 수있었습니다 :

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

... 6 명 더 :

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

어떻게

첫 번째 인수의 입력을 $ARGV[0]문자 ( split//)로 분할하여 인덱스가없는 배열을 만듭니다. $ARGV[1]스크립트에 두 번째 인수 에 1을 추가 하면 문자열 또는 첫 번째 인수에서 해당 위치의 요소에 해당합니다. 그런 다음 표현식 을 반복 할 ()하나의 요소 목록으로 보유합니다 say. 짧은 짧은 버전의 shift경우 첫 번째 인수로 @ARGV의 나머지 부분을 사용하여 인덱스에 사용합니다. 한 번만 shift두 번째 인수 만 남아 있으므로 pop()1을 뺍니다.

이것은 수학 연습으로되어 있습니까? 방금 입력에서 읽은 문자열을 인덱싱하고 있다는 것을 깨달았습니다. 병렬 골프 코스에서 의미가 있다면 표시해두면 더 수학적으로 별도의 답변으로 다시 시도 할 것입니다.

건배,

PHP, 58

수학 만 사용

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

~-~! - 94 93

규칙을 약간 구부리십시오-그것은 n을 입력으로 취하고 숫자 n을 찾는 숫자가 '''''-및 ~-~에 저장되어 있다고 가정하는 함수입니다 ! 수레를 지원하지 않습니다.

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

'''''=~~~~,~~,~~,~~,~~,~~:''''''=''''&~:초래할 것 ''''''인 ~~(2) ( '' '' '= 128).

파이썬 2.7 (89 바이트)

숫자 목록을 사용하여 정수를 "다항식"으로 변환합니다. 나는 당신이 그것을 받아 들일 수 없다고 말하지만, 그것이 수의 다항식으로 표현되는 수의 수학적 개념을 사용하기 때문에 왜 그런지 알지 못합니다. 전달 된 정수가 인 경우에만 실패 0하지만 패딩 된 0은 없다고 말합니다.)

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]

다음으로 실행 test.py:

$ python test.py 726489 5
8

쉘 입력을 원했고 입력이 문자열이라는 사실을 사용할 수 없다고 가정합니다. 쉘 입력을 건너 뛰면 43 바이트에 불과합니다.

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

불필요한 반복을 사용하지만에 추가 감소를 추가하지 않고 바이트를 절약합니다 n.

확장형 BrainFuck : 49

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

용법:

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

곱셈 연산자 (예 :)를 제외한 EBF의 특별한 기능을 실제로 사용하고 있지 않습니다 10+ => ++++++++++. 그 외에는 대부분 순수한 BrainFuck입니다

작동 방식 :

+                ; 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

구성표 (R6RS) : 100 (필요한 공백 없음)

(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 비트 부호없는 int에 대해 가능한 최대로 시작하여 나누기 숫자 자르기
2. 정수의 왼쪽을 치면 int ($ 1 / d)는 0이 아닌 값을 반환합니다.
3. 그 이후로 n ($ 2) 자릿수 계속

언 골프 드 :

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

스칼라 (83)

스칼라 특수 기능을 사용하지 않습니다. 오히려 표준 솔루션입니다.

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

언 골프 드 :

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, 배열 사용으로 인해 유효하지 않습니다.

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

줄리아 37

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

내장 ^ 연산자로 인해. 임의의 정밀한 산술은 모든 크기의 int를 허용합니다.

견본

julia> d(1231198713987192871,10)
3

펄 (약간 더 많은 수학 / 매우 골프)-99 자

 ~/$ 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);

다음과 같이 실행하십시오.

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

Perl6-85 자

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

스몰 토크, 44

dc는 타의 추종을 불허하지만 Smalltalk 솔루션은 다음과 같습니다.

인수, n 수; 추출 할 d digit-nr :

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