Bez użycia łańcuchów (z wyjątkiem, gdy jest to konieczne, na przykład z wejściem lub wyjściem) obliczyć n-tą liczbę od lewej liczby całkowitej (w podstawie 10).

Dane wejściowe zostaną podane w tym formacie:

726433 5

Dane wyjściowe powinny wynosić:

3

ponieważ jest to piąta cyfra „726433”.

Dane wejściowe nie będą zawierać zer wiodących, np. „00223”.

Przypadki testowe / dalsze przykłady:

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

To jest kod golfowy; wygrywa najmniej znaków, ale jakiekolwiek wbudowane funkcje, takie jak „nthDigit (x, n)” są niedopuszczalne .

Oto pseudo-kod na początek:

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

Jak widać, jestem nowy w kodowaniu golfa i choć myślę, że to trochę niesprawiedliwe, że zadaję pytanie, zanim jeszcze na nie odpowiem, naprawdę chciałbym zobaczyć, jakie to generuje odpowiedzi. :)

Edycja : Miałem nadzieję na matematyczne odpowiedzi, więc nie mogę zaakceptować odpowiedzi, które polegają na konwersji ciągów znaków na tablice lub na dostępie do liczb jako listy cyfr.

Mamy zwycięzcę

Napisane w „dc”, 12 bajtów. Przez DigitalTrauma .

dc , 12 bajtów

?dZ?-Ar^/A%p

To jest matematyczna odpowiedź. Oto jak to działa:

• ? odczytać numer wejściowy i wcisnąć do stosu
• d zduplikowany początek stosu
• Z Zrzuca wartość ze stosu, oblicza i wypycha liczbę cyfr
• ? odczytać indeks cyfr i nacisnąć na stos
• - odejmij indeks cyfr od liczby cyfr
• A pchnij 10 na stos
• r zamień 2 górne wartości na stosie
• ^ wykładnik 10 ^ (liczba cyfr - indeks cyfr)
• / podziel liczbę przez wynik potęgowania
• A pchnij 10 na stos
• % obliczyć liczbę mod 10, aby uzyskać ostatnią cyfrę i przesunąć na górę stosu
• p pop i wydrukuj górę stosu

W akcji:

{echo 987654321; echo 1; } | dc ndigit.dc
9
{echo 987654321; echo 2; } | dc ndigit.dc
8
{echo 987654321; echo 8; } | dc ndigit.dc
2)
{echo 987654321; echo 9; } | dc ndigit.dc
1
$ 

GolfScript (10 bajtów)

~(\10base=

Zakłada się, że dane wejściowe są w postaci łańcucha (np. Przez stdin). Jeśli na stosie są dwie liczby całkowite, wartość początkowa ~powinna zostać usunięta, oszczędzając 1 znak.

Jeśli uważa się, że podstawowa konwersja jest niezgodna z regułą funkcji wbudowanych, mam 16-znakową alternatywę:

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

CJam - 7

l~(\Ab=

CJam to nowy język, który rozwijam, podobny do GolfScript - http://sf.net/p/cjam . Oto wyjaśnienie:

lczyta wiersz z danych wejściowych
~ocenia ciąg znaków (w ten sposób uzyskując dwie liczby)
(zmniejsza drugą liczbę
\zamienia liczby
Ajest zmienną wstępnie zainicjalizowaną na 10
bdokonuje konwersji podstawy, dzięki czemu tablica z cyframi podstawy 10 pierwszej liczby
=otrzymuje pożądane element tablicy

Program jest w zasadzie tłumaczeniem rozwiązania Petera Taylora.

Haskell 60 bajtów i czytelny

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

bez żadnych zobowiązań!

*Main> nth 1234567 4
4

J - 15 24 znaków

Wystarczająco „matematyczna odpowiedź”.

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

Te same wyniki, co poniżej, ale mają mistyczną jakość bycia matematyką.

Krótka wersja, wykorzystująca rozszerzenie base-10.

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

Poprzedzamy 0, aby skorygować indeksowanie 1.

Stosowanie:

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

To używa tablic.

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

Po prostu zignoruj ​​wszystkie ostrzeżenia.

I tak, w C, ciągi są tak naprawdę tylko tablicami, więc jest to trochę tanie.

Więcej matematyki:

C, 83

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

bc (napędzany bash), 41 29

Myślę, że to pierwsza odpowiedź, aby zrobić to matematycznie, a nie za pomocą łańcuchów:

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

Użycie length()może wydaje się nieco rygorystyczne, ale strona podręcznika użytkownika bc mówi o liczbie cyfr, a nie o długości łańcucha:

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

Wynik:

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

Ten jest dość oczywisty :)

IntegerDigits[#][[#2]]&

Przykład:

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

Wynik:

3

Możesz go skrócić, wpisując na stałe dwie liczby całkowite, np

IntegerDigits[n][[m]]

ale najpierw musisz napisać n = 726433; m = 5;. Wywołanie funkcji wydawało się bardziej podobne do programu.

C 145

Program znajduje odległość od końca liczby całkowitej i dzieli aż do osiągnięcia indeksu, a następnie używa modułu 10, aby uzyskać ostatnią cyfrę.

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 - od 40 do 43

Oczywiście mogę całkowicie bronić tego, że używanie IntegerDigitsjest lewą, która nie podlega

wszelkie wbudowane funkcje, takie jak „nthDigit (x, n)”

Ale ponieważ moja poprzednia odpowiedź wciąż była trochę oszustwem, oto alternatywa. Niestety jest nieco dłuższy, ale nie widziałem, jak go skrócić bardziej niż ja.

Liczenie w podobny sposób jak poprzednio (z ampersand, bez przekazywania żadnych argumentów),

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

ma 43 znaków. Negując wykładnik potasowania i zmieniając terminy, mogę stracić jednego operatora arytmetycznego ( 10^(...)xzostanie zinterpretowane jako mnożenie)

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

Nie mam pod ręką Matematyki do przetestowania, wątpię, aby była tak, jak podejrzewałem (i jak to uprzejmie zweryfikował kukac67 ) w Mathematice, że nie jest to akceptowane, ale działa w WolframAlpha .

Mam wątpliwości co do użycia RealDigits, ponieważ ograniczyłem się do korzystania IntegerDigitsz tej odpowiedzi i są one dość podobne. Jednakże, jeśli mogę pozwolić sobie na włączenie go (po wszystkim, to nie zwraca liczb całkowitych bezpośrednio, podobnie jak wielu z nich istnieje), mogę ciąć się kolejne dwa znaki:

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

Tcl (42 bajty, lambda):

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

(49 bajtów, funkcja):

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

(83 bajty, jeśli musimy zaakceptować dane wejściowe z powłoki):

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

R (60)

Rozwiązano problem za pomocą log10 do obliczenia liczby cyfr. Przypadek specjalny x == 0 kosztuje 13 znaków, westchnienie.

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

Nie golfowany:

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

Stosowanie

> f(898,2)
[1] 9

Scala ( 133 99 bajtów):

Działa dla wszystkich pozytywnych danych wejściowych. Dzieli przez 10 na potęgę cyfry poszukiwanej z prawej strony, a następnie przyjmuje modulo 10.

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

Dziękujemy za zauważenie błędu w poprzedniej formule. Ten jest krótszy.

Haskell, 142

Nie jestem pewien, czy poprawnie zrozumiałem pytanie, ale myślę, że chciałeś tego: przeczytaj stdin (ciąg), utwórz dwie liczby int (nie ciąg), zrób kilka algorytmicznych rzeczy, a następnie wyślij wynik (ciąg). Wcisnąłem go w 142 znaki, co jest zdecydowanie za dużo:

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

przykładowe użycie:

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

Czysto matematyczny, bez zobowiązań, bez żadnego z nich. Pobiera pierwszą liczbę w pierwszym monicie i drugą liczbę w drugim monicie.

Przypadek testowy :

Input: 97654 5
Output: 4

Input: 224658 3
Output: 4

Nieskluczony 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   nr 30 znaków

(nie licząc linii)

Prawdopodobnie jest to oszustwo ze względu na przełącznik poleceń, ale dzięki za umożliwienie mi gry :-)

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

edycja :

Był w stanie usunąć 2 znaki:

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

... a potem jeszcze 6:

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

W jaki sposób

Podzieliliśmy wejście pierwszego argumentu do skryptu $ARGV[0]według znaków ( split//), tworząc tablicę indeksowaną zerowo; dodanie jednego do drugiego argumentu $ARGV[1]w skrypcie odpowiada następnie elementowi w tej pozycji w ciągu lub pierwszym argumencie. Następnie przechowujemy wyrażenie w środku ()jako listę jednego elementu, która saybędzie się powtarzać. W przypadku krótszej krótkiej wersji używamy tylko shiftpierwszego argumentu i używamy pozostałej części @ARGV do użycia dla indeksu - raz shifted pozostaje tylko drugi argument, więc pop()go odejmujemy 1.

Czy to ma być ćwiczenie matematyczne? Właśnie zdałem sobie sprawę, że indeksuję ciąg odczytany z danych wejściowych, więc ... Myślę, że przegrałem? Zaznacz mnie, jeśli mam sens na równoległym polu golfowym i spróbuję ponownie - bardziej matematycznie - w osobnej odpowiedzi.

Twoje zdrowie,

PHP, 58

Używanie tylko matematyki

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

~ - ~! - 94 93

Wygina nieco reguły - jest to funkcja, która przyjmuje n jako dane wejściowe i zakłada, że ​​liczba, aby znaleźć cyfrę n, jest przechowywana w '''''- i ~ - ~! nie obsługuje pływaków.

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

'''''=~~~~,~~,~~,~~,~~,~~:''''''=''''&~:spowoduje ''''''bycie ~~(2) („” „= 128).

Python 2.7 (89 bajtów)

Przekształcam liczbę całkowitą na „wielomian” za pomocą listy cyfr. Wiem, że mówisz, że nie możesz tego zaakceptować, ale nie rozumiem, dlaczego nie, ponieważ wykorzystuje matematyczną koncepcję liczb reprezentowanych jako wielomiany ich podstaw. Nie powiedzie się to tylko wtedy, gdy podana jest liczba całkowita 0, ale nie powiedziałeś żadnych dopełnianych zer;)

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]

Uruchom jako test.py:

$ python test.py 726489 5
8

Zakładam, że chciałeś danych wejściowych powłoki i że nie mogłem skorzystać z faktu, że dane wejściowe byłyby łańcuchami. Pomijanie danych wejściowych powłoki to zaledwie 43 bajty, z:

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

Chociaż używam niepotrzebnej iteracji, oszczędzam niektóre bajty, nie dodając do nich dodatkowego zmniejszenia n.

Extended BrainFuck : 49

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

Stosowanie:

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

Nie używam żadnych specjalnych funkcji EBF poza operatorem mnożenia (np. 10+ => ++++++++++). Poza tym jest to w większości czysty BrainFuck

Jak to działa:

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

Schemat (R6RS): 100 (bez niepotrzebnych białych znaków)

(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. przycinaj cyfry według dzielenia, zaczynając od maks. możliwej dla 32 bitów bez znaku int
2. kiedy uderzymy w lewą stronę liczby całkowitej, int (1 $ / d) zwraca wartość niezerową
3. kontynuuj n (2 $) cyfry za tym

Nie golfowany:

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

Scala (83)

Nie używa żadnych specjalnych funkcji Scala. Raczej standardowe rozwiązanie.

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

Nie golfowany:

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, nieprawidłowa z powodu użycia tablic.

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

Dzięki wbudowanemu operatorowi ^. Arbitralna precyzja arytmetyczna pozwala na dowolny rozmiar int.

Próba

julia> d(1231198713987192871,10)
3

perl (nieco więcej mathy / niezbyt golfy) - 99 znaków

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

Uruchom jako:

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

Perl6 - 85 znaków

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

Smalltalk, 44

Chociaż dc jest nie do pobicia, oto rozwiązanie Smalltalk:

argumenty, liczba n; d cyfra-nr do wyodrębnienia:

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