पूर्णांक के nth अंक का उत्पादन

13

स्ट्रिंग्स का उपयोग किए बिना (जब आवश्यक हो, जैसे कि इनपुट या आउटपुट के साथ) एनटी अंक की गणना, बाईं ओर से , एक पूर्णांक (आधार 10 में)।

इस प्रारूप में इनपुट दिया जाएगा:

726433 5

आउटपुट होना चाहिए:

3

जैसा कि "726433" का पांचवा अंक है।

इनपुट में अग्रणी शून्य नहीं होगा , उदाहरण के लिए "00223"।

परीक्षण के मामले / आगे के उदाहरण:

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

यह कोड गोल्फ है; कम से कम वर्ण जीतता है, लेकिन "nDDigit (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 बाइट्स। DigitalTrauma द्वारा ।

code-golf  math 
— kukac67
स्रोत
क्या यह सिर्फ एक कार्य हो सकता है या इसे I / O को संभालने की आवश्यकता है? यदि इसे I / O को संभालने की आवश्यकता नहीं है, तो क्या यह केवल एक फ़ंक्शन के बजाय एक लैम्ब्डा हो सकता है?
— स्लीवेटमैन
आपका संपादन यह स्पष्ट नहीं करता है कि वास्तव में आपको क्या पसंद नहीं है। विशेष रूप से, "अंकों की सूची के रूप में संख्याओं तक पहुंचने में सक्षम होने के साथ", क्या यह किसी भी रूप में सरणियों का उपयोग है जो आपको पसंद नहीं है, या केवल अंतर्निहित आधार रूपांतरण दिनचर्या का अस्तित्व है?
— पीटर टेलर
@PeterTaylor अंकों के सारणी ठीक नहीं हैं, क्योंकि कोई भी आसानी से केवल सारणी में nth आइटम को पकड़ सकता है। मुझे यकीन नहीं है कि आधार-रूपांतरण बिल्कुल कैसे काम करता है, लेकिन यह आसान लगता है।
— kukac67
अंकों की सूची बनाना एक समस्या क्यों है? यह बहुत गणितीय है - यह एक बहुपद के रूप में संख्या का प्रतिनिधित्व करता है।
— 2rs2ts 16
@ 2rs2ts यदि आप गणितीय रूप से अंकों की एक सूची बना सकते हैं, यानी किसी स्ट्रिंग को एक सरणी में पार्स किए बिना, तो यह स्वीकार्य हो सकता है।
— kukac67

जवाबों:

2

डीसी , 12 बाइट्स

?dZ?-Ar^/A%p

यह एक गणितीय उत्तर है। यहां देखिए यह कैसे काम करता है:

  • ? इनपुट नंबर पढ़ें और स्टैक करने के लिए पुश करें
  • d डंठल की ऊपर की नकल
  • Z स्टॉप से ​​मानों की गणना करता है, अंकों की संख्या की गणना करता है और धक्का देता है
  • ? अंक सूचकांक पढ़ें और स्टैक करने के लिए धक्का दें
  • - डिजिट काउंट से डिजिट इंडेक्स को घटाएं
  • A स्टैक के लिए 10 धक्का
  • r स्टैक पर शीर्ष 2 मान स्वैप करें
  • ^ प्रतिपादक 10 ^ (अंक गणना - अंक सूचकांक)
  • / घातांक के परिणाम से संख्या को विभाजित करें
  • A स्टैक के लिए 10 धक्का
  • % अंतिम अंक प्राप्त करने और स्टैक के शीर्ष पर धकेलने के लिए संख्या मॉड 10 की गणना करें
  • p पॉप और ढेर के शीर्ष मुद्रित करें

कार्रवाई में:

$ {गूंज 987654321; गूंज 1; } | डीसी ndigit.dc
9
$ {गूंज 987654321; गूंज 2; } | डीसी ndigit.dc
8
$ {गूंज 987654321; गूंज 8; } | डीसी ndigit.dc
2
$ {गूंज 987654321; गूंज 9; } | डीसी ndigit.dc
1
$
— डिजिटल आघात
स्रोत
1
मुझे लगता है कि आप विजेता हैं। यह तीसरा सबसे छोटा कोड है, लेकिन सबसे कम 2 का उपयोग किया गया है base conversion -> arrays।
— kukac67
5

GolfScript (10 बाइट्स)

~(\10base=

यह मानता है कि इनपुट एक स्ट्रिंग के रूप में है (जैसे स्टडिन के माध्यम से)। यदि यह स्टैक पर दो पूर्णांक के रूप में है, तो प्रारंभिक ~को हटा दिया जाना चाहिए, जिससे 1 चार्ट बच जाएगा।

यदि बेस कन्वर्ज़न को बिल्ट-इन फ़ंक्शंस नियम के आधार पर गलत माना जाता है, तो मेरे पास 16-चार विकल्प हैं:

~~)\{}{10/}/=10%
— पीटर टेलर
स्रोत
आधार रूपांतरण के साथ आपका पहला कार्यक्रम केवल पहला अंक आउटपुट करता है जब आप "0" दर्ज करते हैं और दूसरा यदि आप "1" दर्ज करते हैं। golfscript.apphb.com/?c=MjcwNiAxCgpcMTBiYXNlPQ%3D%3D
— kukac67
@ kukac67, तय किया गया।
— पीटर टेलर
4

CJam - 7

l~(\Ab=

CJam एक नई भाषा है जिसे मैं विकसित कर रहा हूं, जैसे कि GolfScript - http://sf.net/p/cjam । यहाँ स्पष्टीकरण है:

lइनपुट से एक पंक्ति को पढ़ता है
~स्ट्रिंग का मूल्यांकन करता है (इस प्रकार दो नंबर प्राप्त करता है)
(दूसरी संख्या को कम करता है
\स्वैप संख्याओं
Aका एक चर है जो 10 का
bआधार रूपांतरण करता है, पहले नंबर के आधार -10 अंकों के साथ एक सरणी बनाने
=से वांछित हो जाता है। सरणी का तत्व

कार्यक्रम मूल रूप से पीटर टेलर के समाधान का अनुवाद है।

— aditsu छोड़ दिया क्योंकि SE EVIL है
स्रोत
मैं तर्क दूंगा कि आधार 10 अंकों को एक सरणी में रखना एक गणितीय ऑपरेशन की तुलना में एक स्ट्रिंग ऑपरेशन का अधिक है।
— डिजिटल ट्रामा
4

हास्केल 60 बाइट्स और पठनीय 

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

कोई तार शामिल नहीं!

*Main> nth 1234567 4
4
— मार्टिन द्रुतज़बर्ग
स्रोत
— क्रिस्टियान
वाह आप हर बाइट के लिए लड़े। 1 <2 "के बजाय" सच "- प्यारा।
— मार्टिन ड्रुट्ज़बर्ग
— क्रिश्चियन लुपस्कु
3

जे - 15 24 चार

पर्याप्त रूप से "गणितीय उत्तर"।

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

समान परिणाम नीचे दिए गए हैं, लेकिन गणितीय होने के रहस्यमय गुण से संपन्न है।

बेस -10 विस्तार का उपयोग करते हुए लघु संस्करण।

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

हम 1-आधारित अनुक्रमण के लिए समायोजित करने के लिए 0 को पूर्व निर्धारित करते हैं।

उपयोग:

   ({0,10&#.inv)~/ 1234567 3
3
   ({0,10&#.inv)~/ 444494 5
9
— algorithmshark
स्रोत
2
स्ट्रिंग्स की अनुमति नहीं है।
— 0xcaff
2

पायथन 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
— विलेम
स्रोत
आपको इसे fn के रूप में परिभाषित करने की आवश्यकता नहीं है:def f(i,n): ... return d
— smci
आपको if n>k: return -1मामले की जांच करने की आवश्यकता नहीं है ।
— smci
... और आपको निश्चित रूप से केवल k (i में अंकों की संख्या) को गिनने के लिए एक प्रथम-पास बनाने की आवश्यकता नहीं है, ताकि इसे n की तुलना में पवित्रता की तुलना में।
— 10
2

सी, 50

यह सरणियों का उपयोग करता है।

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

बस सभी चेतावनियों को नजरअंदाज करें।

और हाँ, सी में, स्ट्रिंग्स वास्तव में सिर्फ सरणियाँ हैं, इसलिए यह सस्ते की तरह है।

अधिक गणितीय:

सी, 83

main(int c,char**a){printf("%d",(atoi(a[1])/pow(10,strlen(a[1])-atoi(a[2])))%10);}
— स्टेट बैंक ऑफ इंडिया
स्रोत
यह स्ट्रिंग / सरणी फ़ंक्शन का उपयोग नहीं कर रहा है?
— VX
पहले एक करता है, जैसे कि यह कहता है;) दूसरा एक स्पष्ट रूप से नहीं है, इसके अलावा स्ट्रलेन, जिसे मैंने केवल इसलिए चुना क्योंकि यह लॉग का उपयोग करने से कम है। यदि यह एक समस्या है तो यह एक आसान समाधान है, मैं इसे घर आने पर जोड़ सकता हूं।
— SBI
वहाँ हम जाते हैं, विशुद्ध गणितीय संस्करण को जोड़ा।
— एसबीआई
2
गणित - एक बार भी नहीं!
— पोटज़ब्लिट्ज
2

bc (bash द्वारा संचालित), ४१ २ ९

मुझे लगता है कि यह गणितीय रूप से ऐसा करने का पहला उत्तर है और तार के साथ नहीं:

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

length()शायद इसका उपयोग थोड़ा कठोर लगता है, लेकिन बीसी मैन पेज अंकों की संख्या और स्ट्रिंग की लंबाई के बारे में बात करता है:

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

आउटपुट:

$ ./ndigits.bc.sh 726433 5
3
$ ./ndigits.bc.sh ९ १
9
$ ./ndigits.bc.sh 0 1
0
$ ./ndigits.bc.sh 444494 5
9
$ ./ndigits.bc.sh 800 2
0
$
— डिजिटल आघात
स्रोत
1
@ kukac67 मैं स्वीकृति मत की सराहना करता हूँ! लेकिन मुझे लगता है कि कोड-गोल्फ सवालों के लिए यह प्रथागत है कि अधिक उत्तरों को प्रोत्साहित करने के लिए 2 घंटे से अधिक खुला छोड़ दिया जाए। शायद एक हफ्ता। अगर आप इस उत्तर को स्वीकार नहीं करेंगे तो मैं नाराज नहीं
— होऊंगा
1
ठीक। मैं तब डे-एक्सेप्ट करूंगा। आशा है कि आप नहीं जीतेंगे! : P
— kukac67
1

गणितज्ञ - २४ २३

यह एक तरह का स्पष्ट है :)

IntegerDigits[#][[#2]]&

उदाहरण:

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

आउटपुट:

3

आप इसे हार्ड-कोडिंग दो पूर्णांकों द्वारा छोटा कर सकते हैं, जैसे

IntegerDigits[n][[m]]

लेकिन फिर आपको सबसे पहले लिखना होगा n = 726433; m = 5;। फ़ंक्शन कॉल एक प्रोग्राम के समान अधिक महसूस हुआ।

— CompuChip
स्रोत
1
आप संख्या को गिरा सकते हैं 1।
— 13
अब यह धोखा है ..: D
— kukac67
1

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);
}
— bacchusbeale
स्रोत
यह काफी गोल्फ हो सकता है। इन युक्तियों से शुरू करें
— डिजिटल ट्रॉमा
एक शुरुआत के लिए, (इंट) जातियां और संबंधित परिंदे अनावश्यक हैं
— डिजिटल ट्रामा
1
मैं विरोध नहीं कर सका। मैंने इसे 87 वर्णों तक सीमित किया है i,a;main(){scanf("%d%d",&i,&a);for(a=log(i)/log(10)+1-a;a--;)i/=10;printf("%d",i%10);}:।
— डिजिटल ट्रॉमा
1

वोल्फ्राम अल्फा - 40 और 43 के बीच

बेशक, मैं पूरी तरह से बचाव कर सकता हूं कि उपयोग IntegerDigitsकरना एक चाल है जो नीचे नहीं आती है

"nDDigit (x, n)" जैसे कार्यों में निर्मित

लेकिन क्योंकि मेरा पिछला जवाब अभी भी लगा था कि थोड़ा सा धोखा, यहाँ एक विकल्प है। दुर्भाग्य से यह काफी लंबा है, लेकिन मैंने यह नहीं देखा कि इसे जितना मैंने किया था, उससे अधिक छोटा कैसे किया जाए।

पहले की तरह (किसी भी तर्क में पारित किए बिना, एम्पर्सैंड के साथ),

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

43 अक्षर हैं। प्रतिपादक की उपेक्षा करके और शर्तों को फेरबदल करते हुए, मैं एक अंकगणितीय ऑपरेटर खो सकता हूं ( 10^(...)xइसे व्याख्या के रूप में समझा जाएगा)

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

मेरे पास परीक्षण करने के लिए हाथ में मैथेमेटिका नहीं है, मुझे संदेह है कि मैथेमेटिका में जैसा कि मुझे संदेह है (और कृपया विनम्रतापूर्वक kukac67 द्वारा सत्यापित किया गया था ) यह स्वीकार नहीं किया गया है, लेकिन यह वुल्फ्रेमअल्फा में चलता है ।

मैं इसके उपयोग के बारे में संदेह में RealDigitsहूं, क्योंकि मैंने IntegerDigitsइस उत्तर के लिए खुद को इस्तेमाल करने से प्रतिबंधित कर दिया है और वे काफी समान हैं। हालांकि, अगर मैं इसे शामिल करने की अनुमति देता हूं (आखिरकार, यह सीधे पूर्णांक वापस नहीं करता है, बस उनमें से कितने हैं), मैं एक और दो वर्णों को मिटा सकता हूं:

Mod[Trunc[10^(#2-RealDigits[#]-1)#],10]&
— CompuChip
स्रोत
मैंने इसे Mathematica में आज़माया, यह एक मूल्य आउटपुट नहीं करता है। 43 चरित्र एक यह Mod[Trunc[57 2^(3 - Trunc[Log[456]/Log[10]])5^Trunc[Log[456]/Log[10]]], 10]
— बताता है
हाँ, मुझे लगा। वुल्फ्राम अल्फा इनपुट की व्याख्या करने में थोड़ा अधिक उदार है। सौभाग्य से मैंने इसे सही हेडर दिया;)
— कंपूशिप
लेकिन मैं इसे वुल्फरामअल्फा पर काम करता हूं।
— kukac67 16
{संपादित करें} हालांकि मुझे लगता है कि लिंक टूटा हुआ है ... जाहिरा तौर पर [वे एन्कोड किए जाने पर भी पात्रों को पसंद नहीं करते हैं। मैं इसे URL शॉर्टनर के माध्यम से खींचूंगा। {edit2} जाहिरा तौर पर W.Alpha ने एक - लिंक को बदल दिया है।
— कंपूचिप
1

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]
— slebetman
स्रोत
यह कैसे काम करता है?
— kukac67 16
जोड़ा गया स्पष्टीकरण। यह गणितीय रूप से करने का सबसे स्पष्ट तरीका है। आप इसे कागज पर कैसे करेंगे।
— स्लीपबेटमैन
मुझे लगता है कि आप गलत सिरे से गिन रहे हैं।
— पीटर टेलर
हम्म .. हाँ। ऐसा दिखता है। मैं इसे संशोधित करने के लिए छोड़ दिया फार्म की गणना करेंगे।
— स्लीपबेटमैन
मैं 31 बाइट्स स्वीकार करूंगा। हालांकि मेमना कैसे चलाया जा सकता है? क्या Tcl में एक दुभाषिया है जो इसका उपयोग कर सकता है? या केवल एक कार्यक्रम के भाग के रूप में जो तर्कों को परिभाषित करता है?
— kukac67
1

आर (60)

अंकों की संख्या की गणना करने के लिए लॉग 10 का उपयोग करके समस्या का समाधान किया। विशेष मामला x == 0 की लागत 13 वर्ण है, आह।

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

प्रयोग

> f(898,2)
[1] 9
— lambruscoAcido
स्रोत
1

स्काला ( 133 99 बाइट्स):

सभी सकारात्मक आदानों के लिए काम करता है। अंकों की शक्ति को 10 से विभाजित करके दाईं ओर से देखा जाता है, फिर इसे 10 modulo लेता है।

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

पिछले सूत्र में बग को नोट करने के लिए धन्यवाद। यह छोटा है।

— मिकैल मेयर
स्रोत
मुझें यह पसंद है! :) अप-
— वोटेड
समाधान का परीक्षण किया: k (Array ("1234", "7")) जो देता है 9. यह n> #digits (x) के लिए काम नहीं करता है?
— लैंब्रुस्कोअकिडो
ऐसा इसलिए है क्योंकि इस अंकन में 10 ^ -1 सटीक नहीं है, इसलिए जब आप 10% pow (10, -1) लेते हैं तो एक राउंडिंग त्रुटि होती है जिसे शून्य दिया जाना चाहिए था, लेकिन इसके बदले 0.0999 दिया गया था। इस दुष्परिणाम को व्यक्त करने के लिए मेरे उत्तर को ठीक किया।
— मिकैल मेयर
1

हास्केल, 142

मुझे यकीन नहीं है कि मैंने प्रश्न को सही ढंग से समझा है, लेकिन यह वही है जो मुझे लगता है कि आप चाहते थे: स्टडिन (स्ट्रिंग) पढ़ें, दो नंबरों को इंट (स्ट्रिंग नहीं) बनाएं, कुछ एल्गोरिदमिक चीजें करें, और फिर परिणाम (स्ट्रिंग) को आउटपुट करें। मैंने इसे 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
— Flonk
स्रोत
1

जावास्क्रिप्ट - 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

अ-कोड कोड:

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
— गौरांग टंडन
स्रोत
1

पर्ल, 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]स्क्रिप्ट में एक दूसरे तर्क को जोड़ना फिर स्ट्रिंग या पहले तर्क में उस स्थिति में तत्व से मेल खाता है। हम तब ()एक तत्व सूची के रूप में अभिव्यक्ति को पकड़ते हैं, जो sayइसके माध्यम से पुनरावृति करेगा। छोटे लघु संस्करण के लिए हम सिर्फ shiftपहले तर्क में और @ARGV के शेष भाग का उपयोग सूचकांक के लिए करने के लिए करते हैं - एक बार shiftकेवल दूसरा तर्क एड होता है इसलिए हम pop()इसे 1 घटाते हैं।

क्या यह एक गणित अभ्यास माना जाता है? मुझे बस एहसास हुआ कि मैं इनपुट से पढ़े गए स्ट्रिंग को अनुक्रमित कर रहा हूं, इसलिए ... मुझे लगता है कि मैं हार गया हूं ?? यदि मुझे समानांतर गोल्फ कोर्स में समझ में आता है, तो मुझे चिह्नित करें और मैं फिर से कोशिश करूंगा - अधिक गणितीय रूप से - एक अलग उत्तर में।

चियर्स,

— जी। साइटो
स्रोत
हाँ, क्षमा करें, तार का उपयोग किए बिना । वैसे भी PPCG में आपका स्वागत है!
— डिजिटल ट्रामा
ओके सॉरी 'बाउट दैट ... अभी तक मेरे गणितीय दृष्टिकोण बहुत गोल्फ-योग्य नहीं हैं :-)
— जी। Cito
0

PHP, 58

केवल गणित का उपयोग करना

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

— dkasipovic
स्रोत
1
क्या यह सही से नहीं लगता है?
— cjfaure
2
आप इसे बदलकर 1 char को बचा सकते हैं echo$n%10।
— अमल मुरली
@ नहीं, यह वास्तव में छोरों जब तक दर्ज संख्या 10 ^ x से बड़ा नहीं है, x अंक संख्या है। इसलिए, उदाहरण के लिए, यदि आप संख्या के रूप में 3457 और अंक के रूप में 2 दर्ज करते हैं, तो यह अंतिम अंक तब तक निकाल लेगा जब तक कि संख्या 100 (10 ^ 2) से छोटी नहीं हो जाती। इसका मतलब है कि यह 5 और 7 को दूर ले जाएगा, क्योंकि तब 34 रहता है और यह 100 से बड़ा नहीं है। तब यह अंतिम अंक (4) को आउटपुट करता है।
— dasasipovic
लेकिन यह सच है कि यदि दूसरी संख्या अंकों की संख्या से बड़ी है, तो आप 9 का उत्पादन करते हैं और शून्य नहीं
— Mikaël मेयर
मैं देखता हूं, अगर संख्या अंकों की तुलना में बड़ी है तो यह अंतिम अंक को आउटपुट करता है। यदि आप 1234 और 5 वें अंक दर्ज करते हैं, तो आपको 1234 के बाद से 4 मिलेंगे, जो कि पहले से ही 10 ^ 5 से कम है।
— dasasipovic
0

~ - ~! - 94 93

नियमों को थोड़ा झुकता है - यह एक फ़ंक्शन है जो इनपुट के रूप में n लेता है और अंक n को खोजने के लिए संख्या मानता है '''''- और ~ ~ ~ में संग्रहीत किया जाता है ! फ्लोट का समर्थन नहीं करता है।

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

'''''=~~~~,~~,~~,~~,~~,~~:''''''=''''&~:''''''होने के परिणामस्वरूप ~~(2) ('' '' '= 128) होगा।

— cjfaure
स्रोत
हम्म ... फिर भी एक और गूढ़ भाषा?
— VisioN
@VisioN यह वास्तव में गूढ़ नहीं है, बस यह है कि केवल मूल डेटा प्रकार एक संख्या है और यह ओएस / इंटरनेट के साथ बातचीत नहीं कर सकता है। esolangs.org/wiki/No_Comment
— cjfaure
1
खैर, मेरे लिए हर वाक्यविन्यास जो आसानी से एक इंसान द्वारा पढ़ा नहीं जा सकता है गूढ़ है। और हाँ, पर्ल भी इस सिद्धांत के अनुसार गूढ़ है:)
— VisioN
@VisioN इसे थोड़ी देर बाद पढ़ना आसान हो जाता है। : पी
— cjfaure
0

पायथन 2.7 (89 बाइट)

मैं अंकों की सूची का उपयोग करके पूर्णांक को "बहुपद" में बदल देता हूं। मुझे पता है कि आप कहते हैं कि आप इसे स्वीकार नहीं कर सकते, लेकिन मैं नहीं देखता कि क्यों यह संख्याओं की गणितीय अवधारणा का उपयोग उनके ठिकानों के बहुपदों के रूप में प्रतिनिधित्व करता है। पूर्णांक में पास होने पर ही यह विफल होगा 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।

— 2rs2ts
स्रोत
0

विस्तारित ब्रेनफक : 49

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

उपयोग:

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

मैं गुणन ऑपरेटर (जैसे। 10+ => ++++++++++) को छोड़कर EBF की किसी विशेष सुविधा का उपयोग नहीं कर रहा हूँ । इसके अलावा यह ज्यादातर शुद्ध ब्रेनफक है

यह काम किस प्रकार करता है:

+                ; 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)))
— Sylwester
स्रोत
0

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) गैर-शून्य देता है
  3. जारी रखें n ($ 2) अंक जो पिछले हैं

Ungolfed:

{
    for(d = 1000000000; int($1 / d) != 0 || --$2; d /= 10);
    print int($1 / d) % 10;
}
— laindir
स्रोत
0

स्काला (83)

किसी भी Scala विशेष सुविधाओं का उपयोग नहीं करता है। बल्कि मानक समाधान है।

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
— lambruscoAcido
स्रोत
0

सी, 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]);}
— वीएक्स
स्रोत
मैंने एक संपादन में सरणियाँ अस्वीकृत कर दीं (इससे पहले कि आप इसे पोस्ट करें) ... लेकिन मुझे पसंद है कि आपने यह कैसे किया। :)
— kukac67
ठीक है, मैं ठीक से नहीं देख रहा था। मैंने सरणियों से बचने के लिए एक समाधान जोड़ा है।
— VX
0

जूलिया ३ 37

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

बिलियन ^ ऑपरेटर के कारण। मनमाना परिशुद्धता अंकगणित किसी भी आकार int के लिए अनुमति देता है।

नमूना

julia> d(1231198713987192871,10)
3
— waTeim
स्रोत
0

पर्ल (थोड़ा अधिक मैथी / बहुत गोल्फ नहीं) - 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
— जी। साइटो
स्रोत
0

लघुतल, ४४

यद्यपि डीसी अपराजेय है, यहाँ एक स्मालटाक समाधान है:

तर्क, एन संख्या; डी अंक-एनआर निकालने के लिए:

[:n :d|(n//(10**((n log:10)ceiling-d)))\\10]
— blabla999
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.