Berechnen Sie ohne Verwendung von Zeichenfolgen (außer bei Bedarf, z. B. bei Eingabe oder Ausgabe) die n-te Ziffer einer Ganzzahl von links (in Basis 10).

Die Eingabe erfolgt in folgendem Format:

726433 5

Die Ausgabe sollte sein:

3

da dies die fünfte Ziffer von "726433" ist.

Eingabe wird nicht enthält führenden Nullen, z. B. "00223".

Testfälle / weitere Beispiele:

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

Das ist Code Golf; Die geringste Anzahl von Zeichen gewinnt, aber alle eingebauten Funktionen wie "nthDigit (x, n)" sind nicht akzeptabel .

Hier ist ein Pseudocode, mit dem Sie beginnen können:

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

Wie Sie sehen, ist es etwas unfair, wenn ich eine Frage stelle, bevor ich überhaupt eine beantworte. Ich würde gerne sehen, welche Art von Antworten dadurch generiert werden. :)

Bearbeiten : Ich hatte auf mathematische Antworten gehofft, daher kann ich Antworten, die auf der Konvertierung von Zeichenfolgen in Arrays oder dem Zugriff auf Zahlen als Ziffernliste beruhen, nicht wirklich akzeptieren.

Wir haben einen Sieger

Geschrieben in "dc", 12 Bytes. Von DigitalTrauma .

Gleichstrom , 12 Bytes

?dZ?-Ar^/A%p

Dies ist eine mathematische Antwort. So funktioniert das:

• ? Eingangsnummer lesen und zum Stapeln drücken
• d Doppelte Oberseite des Stapels
• Z Lässt den Wert vom Stapel fallen, berechnet und gibt die Anzahl der Stellen aus
• ? Ziffernindex lesen und zum Stapeln drücken
• - subtrahieren Sie den Ziffernindex von der Ziffernanzahl
• A Drücke 10 auf den Stapel
• r Tauschen Sie die obersten 2 Werte auf dem Stapel aus
• ^ Exponentiate 10 ^ (Ziffernanzahl - Ziffernindex)
• / Teilen Sie die Zahl durch das Ergebnis der Potenzierung
• A Drücke 10 auf den Stapel
• % Berechnen Sie die Zahl mod 10, um die letzte Ziffer zu erhalten, und drücken Sie auf die oberste Position des Stapels
• p Pop und drucken Sie die Oberseite des Stapels

In Aktion:

$ {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 Bytes)

~(\10base=

Dies setzt voraus, dass die Eingabe als Zeichenfolge erfolgt (z. B. über stdin). Wenn es sich um zwei Ganzzahlen auf dem Stapel handelt, sollte die Initiale ~entfernt werden, um 1 Zeichen zu sparen.

Wenn die Basisumwandlung als Verstoß gegen die Regel für integrierte Funktionen eingestuft wird, habe ich eine 16-Zeichen-Alternative:

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

CJam - 7

l~(\Ab=

CJam ist eine neue Sprache, die ich entwickle, ähnlich wie GolfScript - http://sf.net/p/cjam . Hier ist die Erklärung:

lLiest eine Zeile von der Eingabe,
~wertet sie die Zeichenfolge aus (wodurch die beiden Zahlen ermittelt werden),
(dekrementiert die zweite Zahl,
\tauscht die Zahlen aus,
Aist eine Variable, die vorinitialisiert ist, und führt eine Basisumwandlung durch
b, wobei ein Array mit den Basis-10-Ziffern der ersten Zahl erstellt wird
= die gewünschte erhält Element des Arrays

Das Programm ist im Grunde eine Übersetzung von Peter Taylors Lösung.

Haskell 60 Bytes und lesbar

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

Keine Saiten!

*Main> nth 1234567 4
4

J - 15 24 char

Eine ausreichend "mathematische Antwort".

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

Gleiche Ergebnisse wie unten, jedoch mit der mystischen Eigenschaft, mathematisch zu sein.

Die Kurzversion mit Base-10-Erweiterung.

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

Wir stellen eine 0 voran, um die 1-basierte Indizierung anzupassen.

Verwendung:

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

Dies verwendet Arrays.

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

Ignorieren Sie einfach alle Warnungen.

Und ja, in C sind Strings wirklich nur Arrays, das ist also ziemlich billig.

Mathematischer:

C 83

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

bc (getrieben von bash), 41 29

Ich denke, dies ist die erste Antwort, die dies mathematisch und nicht mit Zeichenfolgen ausführt:

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

Die Verwendung von length()scheint vielleicht etwas fad zu sein, aber in der Manpage von bc geht es um die Anzahl der Ziffern und nicht um die Länge der Zeichenfolge:

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

Ausgabe:

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

Dieser ist irgendwie offensichtlich :)

IntegerDigits[#][[#2]]&

Beispiel:

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

Ausgabe:

3

Sie können es kürzer machen, indem Sie zwei ganze Zahlen hartcodieren, z

IntegerDigits[n][[m]]

aber dann musst du erst schreiben n = 726433; m = 5;. Der Funktionsaufruf fühlte sich einem Programm ähnlicher an.

C 145

Das Programm findet den Abstand vom Ende der ganzen Zahl und dividiert, bis der Index erreicht ist, und verwendet dann Modul 10, um die letzte Ziffer zu erhalten.

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 - zwischen 40 und 43

Natürlich kann ich diesen IntegerDigitsTrick, der nicht untergeht, vollkommen verteidigen

alle eingebauten Funktionen wie "nthDigit (x, n)"

Aber weil meine vorherige Antwort immer noch ein bisschen schummeln wollte, ist hier eine Alternative. Leider ist es etwas länger, aber ich habe nicht mehr gekürzt als ich.

Zählen auf ähnliche Weise wie zuvor (mit dem kaufmännischen Und, ohne Argumente zu übergeben),

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

hat 43 Zeichen. Durch Negieren des Exponenten und Mischen der Terme kann ich einen arithmetischen Operator verlieren ( 10^(...)xwird als Multiplikation interpretiert).

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

Ich habe Mathematica nicht zum Testen zur Hand, ich bezweifle, dass es so sein wird. Wie ich vermutet habe (und wie freundlicherweise von kukac67 bestätigt wurde ), wird dies in Mathematica nicht akzeptiert, aber es läuft in WolframAlpha .

Ich bin im Zweifel über die Verwendung von RealDigits, weil ich mich darauf beschränkt habe, IntegerDigitsdiese Antwort zu verwenden, und sie sind ziemlich ähnlich. Wenn ich es mir jedoch erlaube, es einzuschließen (schließlich werden die ganzen Zahlen nicht direkt zurückgegeben, wie viele es auch gibt), kann ich zwei weitere Zeichen durchtrennen:

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

Tcl (42 Bytes, Lambda):

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

(49 Bytes, Funktion):

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

(83 Bytes, wenn wir Eingaben von der Shell akzeptieren müssen):

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

R (60)

Behebung des Problems mit log10 zur Berechnung der Stellenzahl. Der Sonderfall x == 0 kostet 13 Zeichen, seufz.

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

Verwendung

> f(898,2)
[1] 9

Scala ( 133 99 Bytes):

Funktioniert für alle positiven Eingänge. Dividiert durch 10 zur Potenz der von rechts gesuchten Ziffer und nimmt dann modulo 10.

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

Vielen Dank, dass Sie den Fehler in der vorherigen Formel bemerkt haben. Dieser ist kürzer.

Haskell, 142

Ich bin nicht sicher, ob ich die Frage richtig verstanden habe, aber ich denke, Sie wollten Folgendes: stdin (string) lesen, die beiden Zahlen int (nicht string) machen, einige algorithmische Dinge tun und dann das Ergebnis (string) ausgeben. Ich habe es in 142 Zeichen gepackt, was viel zu viel ist:

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

Beispielverwendung:

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

Rein mathematisch, keine Saiten, keine von ihnen. Übernimmt die erste Nummer in der ersten Eingabeaufforderung und die zweite Nummer in der zweiten Eingabeaufforderung.

Testfall :

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

Perl, 38, 36   keine 30 Zeichen

(ohne Zeilenvorschub)

Das ist wohl ein Betrug aufgrund des Befehlsschalters, aber danke, dass ich spielen durfte :-)

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

bearbeiten :

Konnte 2 Zeichen entfernen:

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

... dann noch 6:

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

Wie

Wir teilen die Eingabe des ersten Arguments in das Skript $ARGV[0]nach Zeichen ( split//) auf, um ein Array mit Index Null zu erstellen. Wenn Sie $ARGV[1]dem Skript ein Argument zum zweiten Argument hinzufügen, entspricht dies dem Element an dieser Position in der Zeichenfolge oder im ersten Argument. Wir halten dann den Ausdruck in ()einer Liste mit einem Element, die saydurchlaufen wird. Für die kürzere Kurzversion verwenden wir nur shiftdas erste Argument und den verbleibenden Teil von @ARGV für den Index - einmal bearbeitet, shiftbleibt uns nur das zweite Argument übrigpop() subtrahieren es und 1.

Soll das eine Matheübung sein? Ich habe gerade gemerkt, dass ich einen von der Eingabe gelesenen String indiziere, also ... ich vermute, ich verliere? Markieren Sie mich, wenn ich auf einem parallelen Golfplatz Sinn habe, und ich werde es - mathematisch gesehen - in einer separaten Antwort erneut versuchen.

Prost,

PHP, 58

Nur mit Mathe

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

~ - ~! - 94 93

Biegt die Regeln ein bisschen - es ist eine Funktion, die n als Eingabe verwendet und davon ausgeht, dass die zu findende Ziffer n in '''''- und ~ - ~ gespeichert ist ! unterstützt keine floats.

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

'''''=~~~~,~~,~~,~~,~~,~~:''''''=''''&~:führt in zu ''''''sein ~~(2) ( '' ''‘= 128).

Python 2.7 (89 Byte)

Ich transformiere die ganze Zahl in ein "Polynom", indem ich eine Liste von Ziffern verwende. Ich weiß, dass Sie sagen, dass Sie das nicht akzeptieren können, aber ich verstehe nicht, warum nicht, da das mathematische Konzept der Darstellung von Zahlen als Polynome ihrer Basen verwendet wird. Es wird nur fehlschlagen, wenn die übergebene Ganzzahl ist 0, aber Sie sagten, keine aufgefüllten Nullen;)

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]

Ausführen als test.py:

$ python test.py 726489 5
8

Ich nehme an, Sie wollten eine Shell-Eingabe und ich konnte nicht ausnutzen, dass es sich bei der Eingabe um Zeichenfolgen handelt. Beim Überspringen der Shell-Eingabe sind es nur 43 Byte.

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

Obwohl ich unnötige Iterationen verwende, spare ich einige Bytes, indem ich kein zusätzliches Dekrement hinzufüge n.

Erweitertes BrainFuck : 49

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

Verwendung:

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

Außer dem Multiplikationsoperator (z. B. 10+ => ++++++++++) verwende ich derzeit keine besonderen Funktionen von EBF . Ansonsten ist es meistens reines BrainFuck

Wie es funktioniert:

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

Schema (R6RS): 100 (ohne unnötiges Leerzeichen)

(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. trimme Ziffern durch Division, beginnend mit maximal möglich für vorzeichenlose 32-Bit-Int
2. Wenn wir die linke Seite der Ganzzahl treffen, gibt int ($ 1 / d) einen Wert ungleich Null zurück
3. Setzen Sie danach n ($ 2) Ziffern fort

Ungolfed:

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

Scala (83)

Verwendet keine Scala-Sonderfunktionen. Eher die Standardlösung.

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, ungültig, da Arrays verwendet werden.

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

Aufgrund des eingebauten Operators. Die Arithmetik mit beliebiger Genauigkeit ermöglicht eine beliebige Größe int.

Stichprobe

julia> d(1231198713987192871,10)
3

Perl (etwas matheiger / nicht sehr golfig) - 99 Zeichen

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

Führen Sie es aus als:

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

Perl6 - 85 Zeichen

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

Smalltalk, 44

Obwohl DC unschlagbar ist, ist hier eine Smalltalk-Lösung:

Argumente, n Zahl; d Ziffer-Nr. zum Extrahieren:

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