पाई बनाने के लिए पाई और ई मिलाएं!


37

हर कोई पीआई को गणितीय रूप से जानता है, इसके व्यास का एक वृत्त की परिधि का अनुपात।

3.14159265358979323846264338327950288419716939937510...

आप शायद गणितीय को भी जानते हैं , एक प्राकृतिक लघुगणक का आधार।

2.71828182845904523536028747135266249775724709369996...

लेकिन ... क्या आप पाई जानते हैं ? यह सबसे महत्वपूर्ण स्थिरांक में से एक है (मेरे लिए)। यह pi और e interleaved का अंक है ।

32.1741185298216852385485997094352233854366206248373...

दशमलव विस्तार के रूप में:

3, 2, 1, 7, 4, 1, 1, 8, 5, 2, 9, 8, 2, 1, 6, 8, 5, 2...

यह OEIS अनुक्रम A001355 है

KEYWORD: नॉन, बेस, गूंगा , आसान

यह बहुत गूंगा क्रम है।

चुनौती

एक प्रोग्राम / फ़ंक्शन लिखें जो एक गैर-नकारात्मक पूर्णांक n लेता है और पाई के एनटी अंक को आउटपुट करता है ।

विशेष विवरण

  • मानक I / O नियम लागू होते हैं
  • मानक खामियों को मना किया जाता है
  • आपका समाधान प्रत्येक स्थिरांक के कम से कम 50 अंकों के लिए काम करना चाहिए, जिसका अर्थ है कि इसे अनुक्रम के कम से कम 100 शब्दों के लिए काम करना चाहिए (कृपया प्रयास करें) हार्डकोड करने की न करें: पी)।
  • 2 या 3 के लिए आउटपुट एक दशमलव बिंदु नहीं है
  • आपका समाधान या तो 0-अनुक्रमित या 1-अनुक्रमित हो सकता है लेकिन कृपया निर्दिष्ट करें कि कौन सा।
  • यह चुनौती सभी भाषाओं में सबसे छोटा दृष्टिकोण खोजने के बारे में नहीं है, बल्कि, यह प्रत्येक भाषा में सबसे छोटा दृष्टिकोण खोजने के बारे में है
  • आपका कोड बाइट्स में स्कोर किया जाएगा , आमतौर पर एन्कोडिंग UTF-8 में, जब तक कि अन्यथा निर्दिष्ट न हो।
  • इस क्रम की गणना करने वाले अंतर्निहित कार्यों की अनुमति है है, लेकिन एक समाधान है कि पर निर्भर नहीं करता सहित एक अंतर्निहित प्रोत्साहित किया जाता है।
  • स्पष्टीकरण, यहां तक ​​कि "व्यावहारिक" भाषाओं के लिए भी प्रोत्साहित किया जाता है

परीक्षण के मामलों

ये 0-अनुक्रमित हैं।

Input   Output

1       2
2       1
11      8
14      6
21      4
24      9
31      5

कुछ बेहतर प्रारूपों में:

1 2 11 14 21 24 31
1, 2, 11, 14, 21, 24, 31

2 3 12 15 22 25 32
2, 3, 12, 15, 22, 25, 32

8
OEIS के अनुसार, कीवर्ड dumbका अर्थ केवल यह है कि इसमें कोई विशेष गुण नहीं है।
ओकेएक्स

1
@Downvoter कोई कारण, शायद?
पूरी तरह से

27
कोई यह तर्क दे सकता है कि परिणाम है pei, नहींpie
ज़ेड

1
मैंने डाउन वोट नहीं किया, लेकिन शायद इसलिए कि आपने 3/14 को यह नहीं पूछा;)
txtechhelp

1
दोपहर 1:59 बजे, @txtechhelp? ;)
वैलीवेस्ट

जवाबों:


12

गणितज्ञ, 50 बाइट्स

1 अनुक्रमित

(Riffle@@(#&@@RealDigits[#,10,5!]&/@{Pi,E}))[[#]]& 

क्या आप बता सकते हैं कि यह कैसे काम करता है?
Stevoisiak

यह आसान है। यह प्रत्येक के 120 (5) तत्वों को लेता है और उन्हें
चकरा

अच्छा! मैंने टाल-मटोल कर आपके हल को पीटने की कोशिश कीRiffle , लेकिन मेरा समाधान एक बाइट छोटा है: RealDigits[If[OddQ@#,Pi,E],10,#][[1,Ceiling[#/2]]]&
मार्क एस।

यह काम नहीं करता प्रतीत होता है। यह एकल अंक लौटाता है।
डेविड 23

@DavidC हाँ! .. "पाई का nth अंक आउटपुट" बिल्कुल! आपने क्यों कम किया ???
J42161217

9

हास्केल, 154 147 146 बाइट्स, कोई हार्डकोरिंग या निर्माण भवनों का उपयोग

यह समाधान अनंत श्रृंखला का उपयोग करके और पीआई की गणना करता है और उन्हें मनमाने ढंग से सटीक निश्चित-बिंदु पूर्णांक (हास्केल के अंतर्निहित Integerप्रकार और इसके Rationalविस्तार) में संग्रहीत करता है ।

import Data.Ratio
s n=product[n,n-2..1]
r=[0..164]
f n=(show$round$(*10^50)$sum[[2*s(2*k)%(2^k*s(2*k+1)),1%product[1..k]]!!mod n 2|k<-r])!!div n 2

Ungolfed:

import Data.Ratio

semifact :: Integer -> Integer
semifact n = product [n, n-2..1]

pi_term :: Integer -> Rational
pi_term i = semifact (2*i) % (2^i * semifact (2*i+1))

--requires 164 terms to achieve desired precision
pi_sum :: Rational
pi_sum = 2 * (sum $ map (pi_term) [0..164])

--requires 40 terms to achieve desired precision
e_sum :: Rational
e_sum = sum [1 % product [1..k] | k<-[0..40]]

-- 51 digits are required because the last one suffers from rounding errors 
fifty1Digits :: Rational -> String
fifty1Digits x = show $ round $ x * 10^50

pi51 = fifty1Digits pi_sum
e51  = fifty1Digits e_sum

-- select a string to draw from, and select a character from it
pie_digit n = ([pi51, e51] !! (n `mod` 2)) !! (n `div` 2)

0 अनुक्रमित। इनपुट 0-99 के लिए सटीक, इनपुट 100-101 के लिए गलत, अन्यथा सीमा समाप्त।

स्पष्टीकरण:

की गणना करता है इस अनंत श्रृंखला का उपयोग करके पाई की । शास्त्रीय व्युत्क्रम भाज्य श्रृंखला का उपयोग करके गणना करता है । सैद्धांतिक रूप से ये उपयोग करने के लिए आदर्श सूत्र नहीं हैं, क्योंकि वे बाइटकाउंट के संदर्भ में बहुत अधिक नहीं हैं, लेकिन वे केवल वही थे जो मुझे मिल सके जो सटीकता के सत्यापन को संभव बनाने के लिए पर्याप्त रूप से परिवर्तित हुए (अन्य रकमों के लिए सैकड़ों हजारों की आवश्यकता होती है अगर लाखों नहीं)। गोल्फ के संस्करण में, की गणना बायटेकाउंट को कम करने के लिए आवश्यक की तुलना में बहुत अधिक सटीकता से की जाती है। दोनों स्थिरांक को गोलाई त्रुटियों से बचने के लिए आवश्यक से थोड़ा अधिक अंकों की गणना की जाती है (जो गलत मूल्यों की अजीब पूंछ के लिए जिम्मेदार हैं)।

स्थिरांक को मनमाने ढंग से सटीक पूर्णांक अनुपात ( Rational) के रूप में गणना की जाती है , फिर 10 ^ 50 से गुणा किया जाता है ताकि अनुपात (मनमाना परिशुद्धता) पूर्णांक ( Integer) में परिवर्तित होने पर सभी आवश्यक अंक बरकरार रहें । यह संख्या के स्ट्रिंग अभ्यावेदन में दशमलव बिंदु से बचने के मुद्दे से भी बचता है, जो फ़ंक्शन वैकल्पिक रूप से वर्णों को खींचता है।


8

टैक्सी , 749 बाइट्स

'3217411852982168523854859970943522338543662062483734873123759256062284894717957712649730999336795919' is waiting at Writer's Depot.Go to Post Office:w 1 l 1 r 1 l.Pickup a passenger going to The Babelfishery.Go to The Babelfishery:s 1 l 1 r.Pickup a passenger going to The Underground.Go to Writer's Depot:n 1 l 1 l 2 l.Pickup a passenger going to Chop Suey.Go to Chop Suey:n 3 r 3 r.[a]Pickup a passenger going to Narrow Path Park.Go to The Underground:s 1 r 1 l.Switch to plan "b" if no one is waiting.Pickup a passenger going to The Underground.Go to Narrow Path Park:n 4 l.Go to Chop Suey:e 1 r 1 l 1 r.Switch to plan "a".[b]Go to Narrow Path Park:n 4 l.Pickup a passenger going to Post Office.Go to Post Office:e 1 r 4 r 1 l.

इसे ऑनलाइन आज़माएं!

टैक्सी में पीआई या ई प्रोग्रामेटिक रूप से गणना करने की कोशिश एक बुरा सपना होगा, हालांकि मुझे यकीन है कि यह किया जा सकता है। इस प्रकार, यह अनुक्रम में पहले 100 अंको को हार्डकोड करने के लिए बहुत छोटा है। यह बहुत सस्ता लगता है लेकिन यह निश्चित रूप से सबसे छोटा टैक्सी कोड है जो चुनौती को पूरा करता है।

यह हार्ड-कोड को अनुक्रम को स्ट्रिंग्स के रूप में लेता है n, फिर इसमें ले जाता हैn नीचे है और प्रत्येक बार स्ट्रिंग में पहले वर्ण को निकालता है। जब n=0, पहला चरित्र आउटपुट। यह एक-अनुक्रमित है।

गैर-गोल्फ / स्वरूपित:

'3217411852982168523854859970943522338543662062483734873123759256062284894717957712649730999336795919' is waiting at Writer's Depot.
Go to Post Office: west 1st left 1st right 1st left.
Pickup a passenger going to The Babelfishery.
Go to The Babelfishery: south 1st left 1st right.
Pickup a passenger going to The Underground.
Go to Writer's Depot: north 1st left 1st left 2nd left.
Pickup a passenger going to Chop Suey.
Go to Chop Suey: north 3rd right 3rd right.
[a]
Pickup a passenger going to Narrow Path Park.
Go to The Underground: south 1st right 1st left.
Switch to plan "b" if no one is waiting.
Pickup a passenger going to The Underground.
Go to Fueler Up: south.
Go to Narrow Path Park: north 4th left.
Go to Chop Suey: east 1st right 1st left 1st right.
Switch to plan "a".
[b]
Go to Narrow Path Park: north 4th left.
Pickup a passenger going to Post Office.
Go to Post Office: east 1st right 4th right 1st left.

6

अजगर २ , 88 बाइट्स

-4 बाइट्स @EriktheOutgolfer के आधार रूपांतरण विचार के लिए धन्यवाद

lambda n:`int("SVBPXJDZK00YCG3W7CZRA378H4AM5553D52T52ZKAFJ17F4V1Q7PU7O4WV9ZXEKV",36)`[n]

इसे ऑनलाइन आज़माएं!

पायथन 2 + सिम्पी , 92 बाइट्स

0 अनुक्रमित। मुझे स्विच करने के लिए याद दिलाने के लिए रॉड के लिए धन्यवाद from sympy import*, जिसे मैं पूर्व में भूल गया था।

lambda n:sum([('3','2')]+zip(`N(pi,50)`,`N(E,50)`[:47]+'6996')[2:],())[n]
from sympy import*

इसे ऑनलाइन आज़माएं!

पायथन 2 , 114 बाइट्स

मुझे ईमानदारी से लगता है कि सबसे छोटा समाधान हार्डकोडिंग है, क्योंकि पायथन में उपयोगी बिल्ट-इन नहीं है।

lambda n:"3217411852982168523854859970943522338543662062483734873123759256062284894717957712649730999336795919"[n]

इसे ऑनलाइन आज़माएं!

पायथन 2 , 114 बाइट्स

@Totallyhuman द्वारा समतुल्य समाधान ।

'3217411852982168523854859970943522338543662062483734873123759256062284894717957712649730999336795919'.__getitem__

इसे ऑनलाइन आज़माएं!


डाउनवोट करने से पहले, अपने समय को एक छोटे से हल के लिए खोज लें।
श्री एक्सकोडर


@totallyhuman साभार
श्री एक्सकोडर

8
आपके द्वारा संपादित किया गया समतुल्य समाधान वास्तव में समतुल्य कोड है, समकक्ष बाइट काउंट नहीं। : P
बिलकुल अमानवीय

1
@totallyhuman लोल मैंने आपकी टिप्पणी देखी और उसे समझा लेकिन मैं पूरी तरह से ठीक करना भूल गया, क्योंकि मैं अपनी गलती के बारे में हंस रहा था। में संपादन के लिए धन्यवाद!
श्री एक्सकोडर

5

05AB1E , 10 बाइट्स

žsтžtøJþsè

स्पष्टीकरण:

žs          Get the first input digits of pi
  тžt       Get 100 digits of e
     ø      Zip them together
      J     Join into a string
       þ    Remove non-digits
        sè  0-indexed index of input in the resulting list

0 अनुक्रमित।

इसे ऑनलाइन आज़माएं!


1
बहुत सारे 05AB1E ...: P
श्री Xcoder

@ Mr.Xcoder वेल, 05AB1E, पी और ई
बिलिन के

@ Mr.Xcoder इसीलिए बनाए गए हैं।
एर्ग आउटफोलर

@totallyhuman नहीं यह नहीं है।
एर्ग आउटफोलर

@Dorian आपका संस्करण काम नहीं करता है। आप विरासत संस्करण का उपयोग कर रहे हैं, लेकिन žtतब अनंत सूची नहीं थी, यही वजह है कि ओकेएक्स अपने कार्यक्रम में ई के पहले 100 अंकों का उपयोग कर रहा है। इसे 05AB1E के नए संस्करण में बदलना (जहां pi और e दोनों एक अनंत सूची है) अभी भी आपके वर्तमान संस्करण में काम नहीं करेगा, क्योंकि ज़िप जोड़े बनाएगा और Join सब कुछ के बजाय उन जोड़ियों में शामिल हो जाएगा। 9 बाइट्स की जगह अभी भी संभव हो रहे हैं Jके साथ Sजहां नए संस्करण हालांकि, में Sयह वर्ण / अंक का चपटा सूची बनाता है
केविन Cruijssen

5

पायथन 3 , 83 80 बाइट्स

0 अनुक्रमित।

lambda n:('%d'*51%(*b' )4bD4&6UcF^#!U+B>0%"WK\<>0^GO9~1c]$O;',))[n]

इसे ऑनलाइन आज़माएं!

वहाँ कुछ गैर-मुद्रण योग्य वर्ण हैं जो किसी ब्राउज़र में ठीक से नहीं देखे जा सकते हैं।

यह (32, 17, 41, 18, 52, ...)हार्डकोड बीटस्ट्रिंग में वर्णों के ASCII कोड से टपल का निर्माण करके काम करता है । टपल को स्ट्रिंग में परिवर्तित किया जाता है '3217411852...', जिसमें से हम सही अंक का चयन करते हैं।


4

पॉलीग्लॉट, 108 बाइट्स

n=>"3217411852982168523854859970943522338543662062483734873123759256062284894717957712649730999336795919"[n]

काम में:

  • सी#
  • जावास्क्रिप्ट

मुझे लगता है कि यह सबसे छोटा है जिसे आप C # में देख सकते हैं क्योंकि यह 252 बाइट्स है पाई का Nth दशमलव खोजने के लिए ।


जेएस पॉलीग्लॉट :-)
अर्नुलड

@Arnauld अपडेटेड :)
TheLethalCoder 15

7
यह एक जावा बहुवचन नहीं है! आप जावा में गैर-ऐरे ऑब्जेक्ट्स में अनुक्रमण नहीं कर सकते।
रोमन ग्रेफ

1
यह तकनीकी रूप से काम करता है, लेकिन मैंने डाउनवोट किया क्योंकि यह बहुत प्रतिस्पर्धी नहीं है और बी) बेहद उबाऊ और तुच्छ है।
हाइपरएन्यूट्रीनो

4
@HyperNeutrino यह C # और जावास्क्रिप्ट है जब वे कभी प्रतिस्पर्धी होते हैं? और शायद उबाऊ और तुच्छ हो, लेकिन क्या आप बल्कि C # में 500 बाइट का जवाब देंगे जो कि चतुर था? कोई बात नहीं क्योंकि वह बिंदु 1 से
टकराता

4

जावा 8, 420 417 413 404 380 358 (गणना) और 115 110 (हार्डकोड) बाइट्स

परिकलित ( 420 417 413 404 380 358 ):

import java.math.*;n->{int i=1,x=99;BigDecimal e,f=e=BigDecimal.ONE;BigInteger p,a=BigInteger.TEN.pow(x);for(p=a=a.add(a);i<x;)e=e.add(e.ONE.divide(f=f.multiply(f.valueOf(i++)),new MathContext(x,RoundingMode.HALF_UP)));for(i=1;a.compareTo(a.ZERO)>0;)p=p.add(a=a.multiply(a.valueOf(i)).divide(a.valueOf(i+++i)));return n==1?50:((n%2<1?p:e)+"").charAt(-~n/2);}

इसे यहाँ आज़माएँ।
साबित करो कि यह आवश्यक 100 वस्तुओं के लिए सही परिणाम देता है।

हार्डकोड: ( 115 110 बाइट ):

"3217411852982168523854859970943522338543662062483734873123759256062284894717957712649730999336795919"::charAt

इसे ऑनलाइन आज़माएं।

0 अनुक्रमित

-9 और -5 बाइट्स @Nevay को धन्यवाद ।
-24 बाइट्स @ceilingcat की बदौलत

  • आपका समाधान प्रत्येक स्थिरांक के कम से कम 50 अंकों के लिए काम करना चाहिए, जिसका अर्थ है कि इसे अनुक्रम के कम से कम 100 शब्दों के लिए काम करना चाहिए (कृपया प्रयास करें) हार्डकोड करने की न करें: पी)
  • इस क्रम की गणना करने वाले अंतर्निहित कार्यों की अनुमति है, लेकिन एक समाधान जिसमें अंतर्निहित पर भरोसा नहीं करता है, को प्रोत्साहित किया जाता है

आपने इसके लिए कहा है ..)

जावा का अंतर्निहित Math.PIऔर Math.Eडबल्स हैं, जिनकी अधिकतम सटीकता सिर्फ 16 है। इसलिए, हमें स्वयं java.math.BigIntegerऔर / या का उपयोग करके दोनों मानों की गणना करनी होगी java.math.BigDecimal
चूंकि मैंने पहले ही एक और चुनौती में पीआई की गणना की है , इसलिए मैंने उसी कोड का उपयोग किया है BigInteger। यूलर की संख्या के लिए एल्गोरिथ्म BigDecimalहालांकि उपयोग करता है ।
परिणामस्वरूप pऔर eइसलिए हैं: 31415...और2.718...

शायद केवल इसका उपयोग करके गोल्फ कर सकता BigDecimalथा, लेकिन पीआई के लिए कुछ गलत जवाब दे रहा था, इसलिए मैं अब दोनों का उपयोग करता हूं BigDecimalऔर BigInteger

स्पष्टीकरण:

import java.math.*;           // Required import for BigDecimal and BigInteger
n->{                          // Method with integer as parameter and char as return-type
  int i=1,                    //  Start index-integer at 1
      x=99;                   //  Large integer we use three times
  BigDecimal e,               //  Euler's number
             f=e=BigDecimal.ONE;
                              //  Temp BigDecimal (both `e` and `f` start at 1)
  BigInteger p,               //  PI
             a=BigInteger.TEN.pow(x);for(p=a=a.add(a);
                              //  Temp BigInteger (where both `p` and `a` starts at 10^99*2)

       i<x;)                  //  Loop (1) 99 times (the higher the better precision)
    e=e.add(                  //   Add the following to `e`:
       e.ONE.divide(f=f.multiply(f.valueOf(i++)),
                              //    First change `f` by multiplying it with `i`
        new MathContext(x,RoundingMode.HALF_UP))))
                              //    And then add 1/`f` to `e`
                              //    (RoundingMode is mandatory for BigDecimal divide)
  for(i=1;                    //  Reset `i` back to 1
      a.compareTo(a.ZERO)>0;) //  Loop (2) as long as `a` is not 0
    p=p.add(                  //   Add the following to `p`:
       a=a.multiply(a.valueOf(i))
                              //    First change `a` by multiplying it with `i`,
          .divide(a.valueOf(i+++i)));
                              //    and dividing it by `2*i+1`
                              //    And then add this new `a` to `p`
  // We now have `p`=31415... and `e`=2.718...
  return n==1?                // If the input (`n`) is 1:
          50                  //  Return 2
         :                    // Else:
          ((n%2<1?            //  If `n` is divisible by 2:
             p                //   Use `p`
            :                 //  Else:
             e)               //   Use `e` instead
    +"")                      //  Convert BigDecimal/BigInteger to String:
        .charAt(-~n/2);}      //  And return the `(n+1)//2`'th character in this string

यकीन नहीं होता कि यह आपकी मदद करेगा लेकिन पाई की गणना के लिए मेरा सी # एल्गोरिथ्म आपके जावा संस्करण की तुलना में 8 बाइट्स में आया।
TheLethalCoder

ध्यान दें कि इस प्रश्न को ठीक से काम करने के लिए इसे प्राप्त करने के लिए इसे प्राप्त (d+=2)करें ++dऔर return p%10+1बस return p%10
TheLethalCoder

@ TheLethalCoder इस चुनौती के लिए C # उत्तर देने के लिए स्वतंत्र महसूस करता है। :) हालाँकि आपको Euler की संख्या की गणना भी करनी होगी। मेरा जवाब वैसे भी lolz के लिए थोड़े है, क्योंकि हार्डकोडिंग से आउटपुट वैसे भी कम होता है ..
केविन क्रूज़सेन

1
You've asked for it.. ;)अरे, मुझे आपका पहला वाला बेहतर पसंद है। मुझे जिस तरह से उम्मीद थी उससे कहीं अधिक
कठोर

1
आप charAt(n+1>>1)एक विधि संदर्भ का उपयोग करके अपने हार्डकोड संस्करण में 5 बाइट्स का उपयोग करके अपने गणना किए गए उत्तर में 9 बाइट्स बचा सकते हैं "..."::charAt
नेवई

3

बीज , 6015 बाइट्स

105 41100973201674650461227976639700390615120600528953176107701316721890649738810349651490948904154731057172335535600875054878204557287393379815378680878571406244365932330202793040308312687924242319799562985464135998860369933720376853281630432469462831217924775601393232895404104191613314969008627719099002734936685651970933027922574843126481552407811220371545812798263882325951724505132794956253992779856191832909434513683936955184871247159313261417328850445886987045814618325821125417040265540589403338721758954467831926977078444612065747526326682314711350486782090838673475876960125016098416460032667015813053483457246043486676622061645094043655351781242050448580132075920324099742699960838361839038297355120817832056960516761862493176616153258281345538652844974811030063414112136642097000574165433957710342430709643110444042577685157477268110199017600011209827070311299268347100419887111107237908884608557593677163764286026624394674781868689858494991328505977301270068505397030743037416430245399054325956185200430657008806539374392625804513081295070438243600044274289109395357299275275193717501822777898664715885427884193864182834402097958423697356485767670945673525604620701482288023981110598866625872386643941558021439168402392304238271452444124214301243311025121833097491087918320170873313832323794851508364788578530614246140801266858481189449278157296335592848066512127882306035576754122325822200069362884409931190620435627809384380203617488253034370361172908245852012086081807945576657014184275798330804532115103840313004678040210379846666674881048346897213048386522262581473085489039138251061251160730845385869281787222083186331344552658814775998639661361866503862291670619153718574270905089351133527806484519543645501497150560454761284099358123613642350160410944676702481576280832672884549762767667090615809061739499629798396737503512011645776394176807352443544839957773371384141101627375926404212619777658374366513665083032140398814384622434755543347503025479743718569310129255927244046638238401670388409731849963600790867434678993019370132638962549859363736476668247251402420832876258626149639101811361047924632565285870213656416957893835899254928237592711662454838295046528789720146967061486405916116778722736283489123195985053535189375957277052428901645131462087039117212488839670735246752589931585405440449333046667938628384693216121067951290025349082277568986632815062532963505690244579740140120806885104683071514922412748240497612209609661707922754236180441892543545377867355182682381812487973645406703590150722720330526173957597156314579144484166520730013480681064941752984345205140917291104888971742824066713606933406657345121342075268990055328274845008936364502884461548416337689565392911129757761902576946104722487260155373897552821908338346641549478063474748830482136404008215583192489320750526753663943267086203954602839906762640389978523894333743126288529975769945319614142422443068420170103245659109689433597701350198280212250954698442638475209618790055335813263132865176791663235801963797561493995544185124734214257034901773781134331460320221759556924556747571745834582344275416625351302153332814233497096345055392255809024712740720006219615340819493781244665414077298346378966540544979367367978334759985048507214749726072645238624803791884339024844989975370042133733339339038567691571361407296615851372112592532463329778465699812822089846474961581380707849259093905314170108054540333209088059730272087864344697983074458088984533095183089310714804468718319244214535941276969904638763288063417624586766891798378622613765728303031397998644194508610598078718347204813844240434145846888722334194516524032354042557957058092854659539699310565707914118281251563405735083553254856313838760124953245573676126601070861004186509621892263623745673900572829301771299438501543213489182375655869072568437776298051260531944785904157204006430131566234389896821642210616326951771496269255716808352415001187083781128619236455170025989777631182990311607133740812107138446626302353752098982590371714623080450836912706275397973009559314275978915463843159370230629290376520494894845680706499809017211545204670148071902560908658269183779180493590025891585269507219866461550160579656755846447951259951641828495549544791046179035585611272240116822105364823082512055639047431280117805724371019657801828634946412396263504315569042536942671358095826696817513115447079645898107923447321583282886740680340887700198072304400536529418546232473450984945589794448490331085275232352881571706521961358975744067916422124670374397682877259664913100427726059898474024964867713698696116581478101206003313106174761699804016604950094008714907179862448792216891309734208815522069346791369498202430302292199779590583788518283934542807403049256936179914953814019565550264909025345322516061595136601312434888871667940394250767164496543418483237896796108764367721411969986710930448108645039275082356457263454340220118278471652962484104099512207532103709146426640958406853240342441810465024550617909657901698718289260589269758398513490424434162831332785821428006396653475356712733072469052427934231406388810607688824035522285626563562286337967271308076321307276537761026788485320280603487776428017017298356181654076403306265118978333909378403193559129146468182910851996415072056976175613473847242292911071040966109905552914332596680497156169349277079292398091020434667210493868422848588893205157133171899819212153010393580099455957808703428739456223073813663954919146593698106305501988107196273527346690785289909397140611634970017071011599022429384594426022933102487171920965595473754661194965266230932928905708783854897164127767575976566931916632077914904360565095752466049885656187054491320449776951484812738806536727562344348761718424255018794271994537719709226236497935053971406685810778014002594041715040546776952342303797267458880802314841325359844565479173256964507237937290466116935912176054052746039378370966040054779443633371806403649852746347690237831260027483859907620684197542069045517397230169577918374265220969534695931904

बीज मेरे Befunge उत्तर के बराबर है। जैसा कि मैंने वहाँ उल्लेख किया है, Befunge प्रोग्राम यह आउटपुट TIO पर काम नहीं करता है क्योंकि TIO में 80 अक्षरों पर आंतरिक लाइन रैपिंग है।


कैसे? बस कैसे?
निएडजजकोब


3

एक्सेल, 113 बाइट्स

1 अनुक्रमित

=MID("3217411852982168523854859970943522338543662062483734873123759256062284894717957712649730999336795919",A1,1)

PI()15 अंकों तक ही सही है। के लिए भी ऐसा ही है EXP(1)

60 42 बाइट समाधान जो इनपुट के लिए काम करता है <=30 (-18 बाइट्स @Adam को धन्यवाद)

=MID(IF(ISODD(A1),PI(),EXP(1)/10)/10,A1/2+3,1)

आपके दूसरे दृष्टिकोण में मूल अवधारणा को 46 बाइट्स तक छोटा किया जा सकता है, केवल if(...)कथन के अंदर =MID(IF(ISODD(b1),PI(),EXP(1)/10)/10,b1/2+3,1)p / e विकल्प होने से : .नहीं के आस-पास pi()और exp()हालांकि
एडम

2

05AB1E , 13 बाइट्स

Éi<;žtë;žs}þθ

इसे ऑनलाइन आज़माएं!

मैजिक के जवाब के समान, लेकिन थोड़े अलग।

स्पष्टीकरण:

Éi<;žtë;žs}þθ Supports 9842 digits of e and 98411 digits of π
É             a % 2
 i    ë   }   if a==1
  <            a - 1
   ;           a / 2
    žt         e to a digits
              else
       ;       a / 2
        žs     π to a digits
           þ  keep chars in [0-9] in a
            θ a[-1]


2

जाप , 55 बाइट्स

" ®v4bØUî6UcF^#ß&6$Îø%\"Wí;<>0^GO9G1c]$O;"cs gU

इसे ऑनलाइन टेस्ट करें! कुछ अनपेक्षित शामिल हैं।

स्ट्रिंग में प्रत्येक वर्ण को उसके चारकोड के साथ बदलकर काम करता है, फिर अंक को सही सूचकांक पर लौटाता है। इस प्रोग्राम के द्वारा स्ट्रिंग तैयार की गई थी:

r"..(?=[^0]0)|25[0-5]|2[0-4].|1..|.(?=[^0]0)|..|."_n d

इसे ऑनलाइन टेस्ट करें!


2

जूलिया, 63 बाइट्स

1 अनुक्रमित

a(n)=replace(string(BigFloat(n%2>0?π:e)),'.',"")[ceil(Int,n/2)]

पी या ई को एक स्ट्रिंग में परिवर्तित करता है, दशमलव स्थान को हटाता है, और फिर उपयुक्त अंक को कॉल करता है। अंक का एक चरित्र प्रतिनिधित्व लौटाता है।


1
PPCG में आपका स्वागत है!
मार्टिन एंडर

2

बीज, 5852 5794

तेहपर्स बेफुन्ग के उत्तर के आधार पर।

1051130021648715907393149878290493079600376561988348664272369051219541158034251323778110172612675089859184605166991106040693833909592598132115295033728752738087105881243462563076466678196376225832661747114302365429787133716511111381612588140144307910362782924144996564529411691568302571546828919454271683233497896594149189544327214969302848984257909609092418942847813158570493297692245428646803536815345759334224247677074872671057296478697076157019699466324478990259351466108726578472175001474585821629778406880297836753303012207209976229264609834293181367664486642493394085473509253813676093779567738697465957519812706192139261472118908699638816640825554051850436762061721281771892466822470585742923158999350909054375916612667405594051622229969696110285582900916410099224974902720736021096981441362371398922887585642863359978062601767338412679956208026294953110185271056006145171920926497396179933553547647876354874445336583594285656870801545177578902705927733720249211636847884869491097054175976937629709200212494761217184873108852140655722895359613462156833646123152648220793295854627649452190956799160703532861477096009725706141202331131287901266622861560576869037209421378739125115765163010112273561384890274706972479335859548424507413589440122160717697618157336618754196528390529316634155057447126317467878320143220148685911507025731721669456692292309133633447284353130542004299981319048073637696567634889623949341630372505055435189663767044165063763216111834588696399179737702861529836947970901482712510136315042152110633215913241916694919566433112405210063414042670097562256073600916103886503591248191758835092924394147776204171675226850914902590401360360345796925181247981647089261884952039081268986586818659090505317955579671089885915745568661758883469031230794272571159213300281445730703294269295310767401339422952480777920786878410780792687195268799097885426801795242758273587841272731685278721369746727313447085996142152811199340656395207452343492937579702451111716453371016654791322834865918860033642314402995240481293652425792697358895577606699947511030416728684352022506710677976841690749387202992493347056114389784733211172448656007595582911222364847293116425714996343958156522448560363063094260073906846664112391722958505451464414025605603413323283807093107521955579711235903403153357003170132938512689946882757999117710160645821945148763813674548797981224375547254576063310479473749044201972863935442758458424285806147218666471747061869918574545072745631758049982372007444866300485095061433951914878373501952670216546435388818497342311417254246013304856715094953051481317438104933875171470343900106719705171102058673610594748846178562080370992488881764909402902065625464750558527389775735939044400858705229893243673486621988009838791971714603625037310885148140796813757120291067372196872928228321095156712054303101901959874384063672886495472796070113365603843687513322867176197917489855537726934095360491472497352567147140246395682503059404971449739625647398820598964158265302668783916501984956044969021302601920487717382879106303683795359905325347814473318519391344565458920270463279174784746656360314070464241666622240210385245184959282222666398870656274940629675453574246097799383361429014800618720780346294542185892116417842240524776835458087900018007896901140383243611793705883547791450682392261960643824271328189332116466519255567441515615925840284456154022304291978218634565379575148642711337622789721842048696443945213454162713556316912301346193615227854869318871089808249776555077834342492281888561676171087168150941237306007109521081900169693331625918138699682645157924632842546989812618292449480799580909720292280095095845962850721356554807680991288722147671740885576811339492549454926901594927338274410385863276725958781460924134466358260089533908525106740467122470973368676988277207568882122479840074670300214980511007665457235218290742394089204192282508491125777180151491866961638111244962953268398339686189772372983926068579350047402754803068232034594024872791141428095120311259087973136353149728638143035136784730999270266072749004567217555438270988124997549762230020689881669285499865374963053282530118570884108038975805335341098720577305266629567047445192403700472887794782423940658412176424370062158626834653405675401415679083822191617061925174149189203359499283160374801737260780407460559147326758994495549579747033361234471750470244513311080274649191860724511086222353696966556035904101416366866518427071604705222938635947781869520181137451408849640159586041113639598272540062185768190959707775362176381804238896341317485410279831458927597060094913931822437950489034755418876566165098609145551163170170060968550804192429683076682433548504113044161906874992120619724109268394986529182050977866104283639955069424323124118234270471868688405770066267298550544345355480568344482162465184049105391961294335245926910436280167548428908725073049063187423431751542064521517069452498182346407984197390998799924644160478679731476796691938148057603728267749331459031937823996495889234787060791079241854542581243078812931046333013380737766914161425371301455762684652883345176576166320850926855173197613536554369628772428747263956045786416295429184651985570482338242016559363725421100270243627030197439290918962948652873397874243832067459791837014394278403085907234616003231621600132126403225123227458214686006897240158060744989458215243787817148717936756981074208678765977744940577875579654698779849605118845010395906232293740180888137656291524050590071724242335942378834532707622396324405477279768052696927856056064019532570357101573277570040254706775462396160275876038886428146097798897998315086627358220951838049046100218938610753230860169099104474379950181692561834872540511195903774693113510283120187768500261160296892119883913289017641545057765550924909632887927659777449405778755796546987798496051188450103959062322937401808881376562915240505900717242423359423788345327076223963244054772797680526969278560560640195325703571015732775700402547067754623961602758760388864281460977988979983150866273582209518380490461002189386107532308601690991044743799501816925618348725405111959037746931135102831201877685002611602968921198839132890176415450577655509249096328879276597774494057787557965469877984960511884501039590623229374018088813765629152405059007172424233594237883453270762239632440547727976805269692785605606401953257035710157327757004025470677546239616027587603888642814609779889799831508662735822095183804904610021893861075323086016909910447437995018169256183487254051119590377469311351028312018776850026116029689211988391328901764154505776555092490963288792

अच्छी नौकरी! मैं थोड़ा उत्सुक हूँ कि आपने इसे कैसे गढ़ा।
तेहपर्स

2

Malbolge Unshackled (20-ट्रिट रोटेशन वैरिएंट), 3,64E6 बाइट्स

इस उत्तर का आकार अधिकतम पोस्ट करने योग्य प्रोग्राम आकार (eh) से अधिक है, इसलिए कोड मेरे GitHub रिपॉजिटरी में स्थित है (ध्यान दें: CTRL + A और CTRL + C का उपयोग करके कोड को कॉपी न करें, बस राइटक्लिक करें और "इस रूप में सहेजें" तत्व पर क्लिक करें। .. ")।

इसे कैसे चलाएं?

यह एक मुश्किल हिस्सा हो सकता है, क्योंकि भोले हास्कल दुभाषिया इसे चलाने के लिए उम्र पर उम्र ले लेंगे। TIO में अच्छे Malbogle Unshackled दुभाषिया हैं, लेकिन दुख की बात है कि मैं इसका (सीमाएं) उपयोग नहीं कर पाऊंगा।

सबसे अच्छा एक जो मुझे मिल सकता है वह है निर्धारित 20-ट्रिट रोटेशन चौड़ाई वाला संस्करण, जो बहुत अच्छा प्रदर्शन करता है, तुरंत गणना करता है (बहुत ज्यादा)

दुभाषिया को थोड़ा तेज करने के लिए, मैंने माथियास लुटर के मालब्लोज अनकशल्ड इंटरप्रेटर से सभी चेक हटा दिए हैं।

#include <malloc.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

const char* translation = "5z]&gqtyfr$(we4{WP)H-Zn,[%\\3dL+Q;>U!pJS72Fh"
        "OA1CB6v^=I_0/8|jsb9m<.TVac`uY*MK'X~xDl}REokN:#?G\"i@";

typedef struct Word {
    unsigned int area;
    unsigned int high;
    unsigned int low;
} Word;

void word2string(Word w, char* s, int min_length) {
    if (!s) return;
    if (min_length < 1) min_length = 1;
    if (min_length > 20) min_length = 20;
    s[0] = (w.area%3) + '0';
    s[1] = 't';
    char tmp[20];
    int i;
    for (i=0;i<10;i++) {
        tmp[19-i] = (w.low % 3) + '0';
        w.low /= 3;
    }
    for (i=0;i<10;i++) {
        tmp[9-i] = (w.high % 3) + '0';
        w.high /= 3;
    }
    i = 0;
    while (tmp[i] == s[0] && i < 20 - min_length) i++;
    int j = 2;
    while (i < 20) {
        s[j] = tmp[i];
        i++;
        j++;
    }
    s[j] = 0;
}

unsigned int crazy_low(unsigned int a, unsigned int d){
    unsigned int crz[] = {1,0,0,1,0,2,2,2,1};
    int position = 0;
    unsigned int output = 0;
    while (position < 10){
        unsigned int i = a%3;
        unsigned int j = d%3;
        unsigned int out = crz[i+3*j];
        unsigned int multiple = 1;
        int k;
        for (k=0;k<position;k++)
            multiple *= 3;
        output += multiple*out;
        a /= 3;
        d /= 3;
        position++;
    }
    return output;
}

Word zero() {
    Word result = {0, 0, 0};
    return result;
}

Word increment(Word d) {
    d.low++;
    if (d.low >= 59049) {
        d.low = 0;
        d.high++;
        if (d.high >= 59049) {
            fprintf(stderr,"error: overflow\n");
            exit(1);
        }
    }
    return d;
}

Word decrement(Word d) {
    if (d.low == 0) {
        d.low = 59048;
        d.high--;
    }else{
        d.low--;
    }
    return d;
}

Word crazy(Word a, Word d){
    Word output;
    unsigned int crz[] = {1,0,0,1,0,2,2,2,1};
    output.area = crz[a.area+3*d.area];
    output.high = crazy_low(a.high, d.high);
    output.low = crazy_low(a.low, d.low);
    return output;
}

Word rotate_r(Word d){
    unsigned int carry_h = d.high%3;
    unsigned int carry_l = d.low%3;
    d.high = 19683 * carry_l + d.high / 3;
    d.low = 19683 * carry_h + d.low / 3;
    return d;
}

// last_initialized: if set, use to fill newly generated memory with preinitial values...
Word* ptr_to(Word** mem[], Word d, unsigned int last_initialized) {
    if ((mem[d.area])[d.high]) {
        return &(((mem[d.area])[d.high])[d.low]);
    }
    (mem[d.area])[d.high] = (Word*)malloc(59049 * sizeof(Word));
    if (!(mem[d.area])[d.high]) {
        fprintf(stderr,"error: out of memory.\n");
        exit(1);
    }
    if (last_initialized) {
        Word repitition[6];
        repitition[(last_initialized-1) % 6] =
                ((mem[0])[(last_initialized-1) / 59049])
                    [(last_initialized-1) % 59049];
        repitition[(last_initialized) % 6] =
                ((mem[0])[last_initialized / 59049])
                    [last_initialized % 59049];
        unsigned int i;
        for (i=0;i<6;i++) {
            repitition[(last_initialized+1+i) % 6] =
                    crazy(repitition[(last_initialized+i) % 6],
                        repitition[(last_initialized-1+i) % 6]);
        }
        unsigned int offset = (59049*d.high) % 6;
        i = 0;
        while (1){
            ((mem[d.area])[d.high])[i] = repitition[(i+offset)%6];
            if (i == 59048) {
                break;
            }
            i++;
        }
    }
    return &(((mem[d.area])[d.high])[d.low]);
}

unsigned int get_instruction(Word** mem[], Word c,
        unsigned int last_initialized,
        int ignore_invalid) {
    Word* instr = ptr_to(mem, c, last_initialized);
    unsigned int instruction = instr->low;
    instruction = (instruction+c.low + 59049 * c.high
            + (c.area==1?52:(c.area==2?10:0)))%94;
    return instruction;
}

int main(int argc, char* argv[]) {
    Word** memory[3];
    int i,j;
    for (i=0; i<3; i++) {
        memory[i] = (Word**)malloc(59049 * sizeof(Word*));
        if (!memory) {
            fprintf(stderr,"not enough memory.\n");
            return 1;
        }
        for (j=0; j<59049; j++) {
            (memory[i])[j] = 0;
        }
    }
    Word a, c, d;
    unsigned int result;
    FILE* file;
    if (argc < 2) {
        // read program code from STDIN
        file = stdin;
    }else{
        file = fopen(argv[1],"rb");
    }
    if (file == NULL) {
        fprintf(stderr, "File not found: %s\n",argv[1]);
        return 1;
    }
    a = zero();
    c = zero();
    d = zero();
    result = 0;
    while (!feof(file)){
        unsigned int instr;
        Word* cell = ptr_to(memory, d, 0);
        (*cell) = zero();
        result = fread(&cell->low,1,1,file);
        if (result > 1)
            return 1;
        if (result == 0 || cell->low == 0x1a || cell->low == 0x04)
            break;
        instr = (cell->low + d.low + 59049*d.high)%94;
        if (cell->low == ' ' || cell->low == '\t' || cell->low == '\r'
                || cell->low == '\n');
        else if (cell->low >= 33 && cell->low < 127 &&
                (instr == 4 || instr == 5 || instr == 23 || instr == 39
                    || instr == 40 || instr == 62 || instr == 68
                    || instr == 81)) {
            d = increment(d);
        }
    }
    if (file != stdin) {
        fclose(file);
    }
    unsigned int last_initialized = 0;
    while (1){
        *ptr_to(memory, d, 0) = crazy(*ptr_to(memory, decrement(d), 0),
                *ptr_to(memory, decrement(decrement(d)), 0));
        last_initialized = d.low + 59049*d.high;
        if (d.low == 59048) {
            break;
        }
        d = increment(d);
    }
    d = zero();

    unsigned int step = 0;
    while (1) {
        unsigned int instruction = get_instruction(memory, c,
                last_initialized, 0);
        step++;
        switch (instruction){
            case 4:
                c = *ptr_to(memory,d,last_initialized);
                break;
            case 5:
                if (!a.area) {
                    printf("%c",(char)(a.low + 59049*a.high));
                }else if (a.area == 2 && a.low == 59047
                        && a.high == 59048) {
                    printf("\n");
                }
                break;
            case 23:
                a = zero();
                a.low = getchar();
                if (a.low == EOF) {
                    a.low = 59048;
                    a.high = 59048;
                    a.area = 2;
                }else if (a.low == '\n'){
                    a.low = 59047;
                    a.high = 59048;
                    a.area = 2;
                }
                break;
            case 39:
                a = (*ptr_to(memory,d,last_initialized)
                        = rotate_r(*ptr_to(memory,d,last_initialized)));
                break;
            case 40:
                d = *ptr_to(memory,d,last_initialized);
                break;
            case 62:
                a = (*ptr_to(memory,d,last_initialized)
                        = crazy(a, *ptr_to(memory,d,last_initialized)));
                break;
            case 81:
                return 0;
            case 68:
            default:
                break;
        }

        Word* mem_c = ptr_to(memory, c, last_initialized);
        mem_c->low = translation[mem_c->low - 33];

        c = increment(c);
        d = increment(d);
    }
    return 0;
}

यह 3646 से अधिक बाइट्स जैसा दिखता है
H.PWiz

@ H.PWiz ई को भूल गया, क्षमा करें
Krzysztof Szewczyk

1

05AB1E , 14 बाइट्स

žssžt‚øJ'.Ks<è

इसे ऑनलाइन आज़माएं!


यह उत्तर 0-अनुक्रमित है।

žs              # pi to N digits.
  sžt           # e to N digits.
     ‚øJ        # Interleave.
        '.K     # No decimal points.
           s<è  # 0-indexed digit from string.

मुझे पता है कि पहले से ही तीन अन्य 05AB1E उत्तर हैं, इसलिए यह वास्तव में मायने नहीं रखता है, लेकिन आप को बदलने और हटाने के '.Kलिए 3 बाइट्स को गोल्फ कर सकते हैं । (यह निश्चित नहीं है कि आपने इसे क्यों शामिल किया है , क्योंकि आप अपना उत्तर 0-अनुक्रमित बताते हैं। आपका वर्तमान उत्तर 1-अनुक्रमित है ।)þ<<<
केविन क्रूज़सेन

हम्म .. आप भी निकाल सकते हैं ,क्योंकि जिप इस तरह से करता है, लेकिन मुझे लगता है कि यह लगभग अन्य 10-बाइट के उत्तर के समान ही है ..
केविन क्रूज़सेन

1

पायथन 3 + सिम्पी , 109 बाइट्स

0-अनुक्रमित इसे ऑनलाइन आज़माएं!

from mpmath import*
mp.dps=51
print(''.join(['32']+[str(pi)[i]+str(e)[i]for i in range(2,51)])[int(input())])

5 बाइट से हार्डकोडिंग मारो !! लेकिन शायद बेहतर हो सकता है। लेकिन हार्डकोडिंग से मुझे अच्छा महसूस होता है :)


1

पायथ, 35 बाइट्स

@.i`u+/*GHhyHyK^T99rJ^2T0Z`sm/K.!dJ

परीक्षण सूट

चूँकि पाइथ में बिल्ट-इन मनमानी परिशुद्धता पाई और ई स्थिरांक नहीं हैं, मैं उन्हें सीधे गणना करता हूँ।

गणना की पाई:

u+/*GHhyHyK^T99rJ^2T0

यह पीआई की गणना करने के लिए निम्नलिखित पुनरावृत्ति जारी अंश का उपयोग करता है 2 + 1/3*(2 + 2/5*(2 + 3/7*(2 + 4/9*(2 + ...)))):। मुझे यह पीपीसीजी के एक और जवाब से मिला । यह यहां 23-25 ​​समीकरणों में व्युत्पन्न है

मैं इसे अंदर से बाहर की गणना करता हूं, 1024 वीं से परे सभी शर्तों का पालन करता हूं, क्योंकि बाद की शर्तों का संख्या पर बहुत कम प्रभाव पड़ता है, और मैं यह सुनिश्चित करने के लिए 99 अंको की सटीकता रखता हूं कि पहले 50 सही हैं।

ई की गणना:

sm/K.!dJ

सटीक के 99 अंकों के लिए, मैं पहले 1024 नंबरों के पारस्परिक योग का योग करता हूं।

फिर, मैं दोनों संख्याओं को स्ट्रिंग्स में परिवर्तित करता हूं, उन्हें इंटरलेस करता हूं, और इंडेक्स करता हूं।


1

MATLAB, 93 बाइट्स

n=input('');
e=num2str(exp(1));
p=num2str(pi);
c=[];
for i=1:length(p)
 c=[c p(i) e(i)];
end;
c(n)

एक सरल व्याख्या यह है कि यह पहले e और pi को स्ट्रिंग्स में परिवर्तित करता है, फिर अंकों को समेटते हुए लूप से गुजरता है। यहाँ, c पाई है, p pi है, और e e है।

मैंने इसे पठनीयता के लिए कई लाइनों में भी तोड़ दिया है, लेकिन वास्तविक कोड न्यूनतम रिक्ति के साथ एक पंक्ति में है।


साइट पर आपका स्वागत है!
DJMcMayhem

धन्यवाद, मैं काफी समय से कोड गोल्फ ब्राउज़ कर रहा था, और आखिरकार इसे खुद ही देने का फैसला किया।
a13a22

इसके कुछ मुद्दे हैं, मुख्य रूप से यह बिना किसी इनपुट के प्रतीत होता है। आपको अपने फ़ंक्शन को संशोधित करने की आवश्यकता है ताकि पूर्णांक दिया जाए n, यह nthपाई अनुक्रम के अंक का उत्पादन करेगा । आप अपने चरवाहों के नाम को एक चर
टेलर स्कॉट

क्षमा करें, मैंने बाइट गिनती के लिए चर नाम तय किए हैं। Nth अंक के लिए, क्या मैं सिर्फ n =? को परिभाषित करने वाला हूं या क्या मैं एक उपयोगकर्ता इनपुट लेने वाला हूं?
a13a22

आप की तरह लग रहा पहले से ही लगा बाहर है, लेकिन आप इनपुट के लिए उपयोगकर्ता के लिए प्रेरित करेगा, तथापि, यह आवश्यक नहीं है किसी भी है कि शीघ्र से जुड़ी स्वरूपण के लिए है, इसलिए यदि आप एक प्रयोग input('')के स्थान परinput('n')
टेलर स्कॉट

1

C # + BigDecimal , 377 372 बाइट्स

d=>{if(d%2<1){d/=2;int l=++d*10/3+2,j=0,i=0;long[]x=new long[l],r=new long[l];for(;j<l;)x[j++]=20;long c,n,e,p=0;for(;i<d;++i){for(j=0,c=0;j<l;c=x[j++]/e*n){n=l-j-1;e=n*2+1;r[j]=(x[j]+=c)%e;}p=x[--l]/10;r[l]=x[l++]%10;for(j=0;j<l;)x[j]=r[j++]*10;}return p%10;}else{CognitioConsulting.Numerics.BigDecimal r=1,n=1,i=1;for(;i<99;)r+=n/=i++;return(r+"").Remove(1,1)[d/2]-48;}}

सहेजे गए 5 बाइट @Kevin क्रूज़सेन के लिए धन्यवाद।

बाहरी पुस्तकालय के कारण कोई TIO लिंक नहीं, दुर्भाग्यवश C # में BigDecimalकक्षा में निर्मित नहीं है, इसलिए इस बाहरी को करना होगा। शायद कुछ गोल्फ अभी भी संभव है, लेकिन अभी कोई समय नहीं है।

पूर्ण / स्वरूपित संस्करण:

namespace System.Linq
{
    class P
    {
        static void Main()
        {
            Func<int, long> f = d =>
            {
                if (d % 2 < 1)
                {
                    d /= 2;

                    int l = ++d * 10 / 3 + 2, j = 0, i = 0;
                    long[] x = new long[l], r = new long[l];

                    for (; j < l;)
                        x[j++] = 20;

                    long c, n, e, p = 0;

                    for (; i < d; ++i)
                    {
                        for (j = 0, c = 0; j < l; c = x[j++] / e * n)
                        {
                            n = l - j - 1;
                            e = n * 2 + 1;
                            r[j] = (x[j] += c) % e;
                        }

                        p = x[--l] / 10;
                        r[l] = x[l++] % 10;

                        for (j = 0; j < l;)
                            x[j] = r[j++] * 10;
                    }

                    return p % 10;
                }
                else
                {
                    CognitioConsulting.Numerics.BigDecimal r = 1, n = 1, i = 1;

                    for (; i < 99;)
                        r += n /= i++;

                    return (r + "").Remove(1,1)[d/2] - 48;
                }
            };

            for (int i = 0; i < 100; ++i)
            {
                Console.Write(f(i));
            }
            Console.WriteLine();

            Console.ReadLine();
        }
    }
}

आप -2 बाइट्स के लिए कोष्ठक को चारों ओर x[j++]/eसे c=(x[j++]/e)*nखोद सकते हैं; इसके अलावा, मुझे लगता है कि आप +""दो रिटर्न स्टेटमेंट पर दोनों को निकाल सकते हैं और स्ट्रिंग के बजाय एक इंट वापस कर सकते हैं, और फिर -48दूसरे रिटर्न स्टेटमेंट में चार को इंट आउटपुट में बदल सकते हैं (-1 बाइट के लिए)।
केविन क्रूज़सेन

@KevinCruijssen दोनों काम ठीक धन्यवाद!
TheLethalCoder

1

पायथन 2 , 82 बाइट्स

lambda n:`7*ord('L?J$rg$"79n*i.71&<B@[>)!Y8l:.pUo4GZ9c0a%'[n/2])`[n%2+1]

इसे ऑनलाइन आज़माएं!

ASCII के कुछ पात्र शामिल हैं। flornquake ने दो बाइट्स बचाए।


यह n = 64, n = 65 के लिए ब्रेक करता है। निश्चित नहीं है कि सबसे अच्छा तरीका क्या है, जिसे ठीक करना lambda n:('%02d'%ord('...'[n/2]))[n%2], हालांकि, शायद कुछ बेहतर है।
फलावना

@flornquake darn, आप सही कह रहे हैं। मैंने एक फिक्स लिखा जो एक बाइट कम है। कुछ भी बेहतर नहीं सोच सकता
लिन

अच्छा लगा। यहाँ कुछ और भी छोटा है, आपके विचार के आधार पर: TIO
flornquake

1

ब्रेनफक , 402 बाइट्स

--->+>->+>>+>+>>->->+>+>+>-->->+>+>>>->->+>+>>+>+>->+>>+>+>>+>->->>-->>>->+>>+>->->->->+>+>>->+>->+>>->>-->->>>->>>+>->->->->>->>+>-->+>+>+>>+>>>+>->->>+>>->->+>+>->>+>->->>+>->->++[[>+++<-]<+++]>>+>->+>>+>->+>+>+>+>+>+>+>+>->+>->+>>->->->>+>->->->->+>>->>>>+>+>+>>>+>>->+>>->+>->>->+>->+>>->>+>+>>+>+>+>->>>+>+>>>>+>->+>+>->+>+>>>->>>+>>>>+>->>>+>>>>->->->->->>+>,[<[-]>[<+>-]<-]++++[<+++++++++++>-]<.

इसे ऑनलाइन आज़माएं!

चरित्र कोड के रूप में इनपुट (उदाहरण के लिए "ए" = 65)

अंक इनपुट के साथ इसे ऑनलाइन आज़माएं!

कोड:

build a value list (3217411852... reversed and each digit incremented by four)
--->+>->+>>+>+>>->->+>+>+>-->->+>+>>>->->+>+>>+>+>->+>>+>+>>+>->->>-->>>->+>>
+>->->->->+>+>>->+>->+>>->>-->->>>->>>+>->->->->>->>+>-->+>+>+>>+>>>+>->->>+>
>->->+>+>->>+>->->>+>->->++[[>+++<-]<+++]>>+>->+>>+>->+>+>+>+>+>+>+>+>->+>->+
>>->->->>+>->->->->+>>->>>>+>+>+>>>+>>->+>>->+>->>->+>->+>>->>+>+>>+>+>+>->>>
+>+>>>>+>->+>+>->+>+>>>->>>+>>>>+>->>>+>>>>->->->->->>+

>,                      get input
[                       while input > 0
  <[-]                      set next previous cell = 0
  >[<+>-]                   copy input cell to that cell
  <-                        and decrement it
]
++++[<+++++++++++>-]    add 44 to it
<.                      print it


0

Befunge , 105 बाइट्स

3217411852982168523854859970943522338543662062483734873123759256062284894717957712649730999336795919&0g,@

TIO पर काम नहीं करता है क्योंकि ऐसा लगता है कि किसी कारण से 80 वर्णों पर आंतरिक रूप से लाइनें लपेटी गई हैं। आप प्रत्येक अंक को एक नई लाइन पर रखकर, और पहली पंक्ति के &0g,@बाद होने पर TIO पर काम कर सकते हैं 3


1
TIO पर Befunge 98 के साथ ठीक काम करता है: tio.run/##Hcg7DsJAEATRqzgiwtJO9/w64yxIxhkiIeD0y0JUppc/Hu/neezq/…
pppery

0

जावास्क्रिप्ट ( ईएस 6 ) + मैथज , 78 बाइट्स

(n,m=math.create({number:"BigNumber"}))=>`${n%2?m.e:m.pi}`.match(/\d/g)[n/2|0]

शून्य अनुक्रमित और 128 नंबर (127 का अधिकतम इनपुट) पर काम करता है।

टेस्ट स्निपेट

let f=
(n,m=math.create({number:"BigNumber"}))=>`${n%2?m.e:m.pi}`.match(/\d/g)[n/2|0]
<script src="https://cdnjs.cloudflare.com/ajax/libs/mathjs/3.16.0/math.min.js"></script>
<input type=number min=0 value=0 oninput="O.innerHTML=this.value.length>0?f(+this.value):''"><pre id=O>3


0

MATLAB (w / प्रतीकात्मक टूलबॉक्स), 89 82 बाइट्स

प्रतीकात्मक टूलबॉक्स का उपयोग करके, यह उत्तर पी और ई के मूल्यों को हार्डकोड किए बिना एक आउटपुट प्रदान करता है।

एक मज़ेदार बोनस के रूप में यह कोड इनपुट के रूप में या तो एक इंडेक्स, या इंडेक्स की एक सरणी ले सकता है और साथ ही प्रदान किए गए सभी इंडेक्स वैल्यू के लिए आउटपुट वैल्यू प्रदान करेगा (जैसे 1:10 प्रदान करना पहले 10 मानों को आउटपुट करेगा)।

a=char(vpa({'exp(1)';'pi'},51));
a(a=='.')=[];
n=input('');
a(9+fix(n/2)+56*mod(n,2))

(पठनीयता के लिए नई लाइनें जोड़ी गईं, निष्पादन के लिए आवश्यक नहीं, इसलिए बाइट काउंट में शामिल नहीं)

दुर्भाग्य से TIO द्वारा उपयोग किया गया ऑक्टेव संस्करण प्रतीकात्मक आदानों का समर्थन नहीं करता है vpa फ़ंक्शन , इसलिए TIO लिंक पर प्रदान नहीं कर सकता है।

MATLAB में एक फ़ंक्शन से रिटर्न वेक्टर में अनुक्रमण उसी तरह संभव नहीं है जैसे कि ऑक्टेव के साथ जिसका अर्थ है कि यह केवल एक गुमनाम फ़ंक्शन के बजाय एक पूर्ण कार्यक्रम है। कार्यक्रम एक इनपुट के लिए पूछेगाn निष्पादन के दौरान - यह एक अनुक्रमित मूल्य है जिसके लिए तत्व की आवश्यकता होती है। कार्यक्रम के अंत में मान को स्पष्ट रूप से मुद्रित किया जाता है।

कार्यक्रम के लिए हम का उपयोग vpaसमारोह जो 51 दशमलव स्थानों के मूल्य के प्रदान करता है piऔर exp(1)(ङ)। यह सैद्धांतिक रूप से अनंत परिशुद्धता की अनुमति देने के लिए प्रतीकात्मक रूप से किया जाता है। 100 से अधिक तत्वों के लिए विस्तार करने के लिए, बस 51सीमा बढ़ाने के लिए कोड में मूल्य बढ़ाएं।

रैपिंग vpaमें char(यानी char(vpa(...))) एक स्ट्रिंग के बजाय एक प्रतीकात्मक मूल्य के लिए समारोह के उत्पादन में परिवर्तित करने के लिए आवश्यक है। परिणामी आउटपुट स्ट्रिंग है:

matrix([[2.71828182845904523536028747135266249775724709369996], [3.14159265358979323846264338327950288419716939937511]])

इसमें 51 दशमलव स्थानों तक ई और पीआई दोनों शामिल हैं - हमारे आउटपुट के 100 अंकों की अनुमति देने के लिए पर्याप्त है (हमें गोल मूल्यों को प्रिंट करने से बचने के लिए आवश्यक से थोड़ा अतिरिक्त डीपी करना होगा)

इस गड़बड़ी को अनुक्रमित करने के लिए, हमें कम से कम दशमलव बिंदुओं से छुटकारा पाने की आवश्यकता है ताकि अंकों के दोनों तार सन्निहित हों। मूल रूप से मैंने किसी भी चीज का एक सरल रेगेक्स प्रतिस्थापन का उपयोग किया, जो कि कुछ भी नहीं के साथ एक अंक है। हालाँकि मैं केवल कोड का उपयोग करके दशमलव बिंदु से छुटकारा पाकर 7 बाइट्स बचा सकता हूं:

a(a=='.')=[];

परिणामी स्ट्रिंग अब है:

matrix([[271828182845904523536028747135266249775724709369996], [314159265358979323846264338327950288419716939937511]])

इसमें वे सभी अंक होते हैं जिनकी हमें लगातार अनुक्रमित में pi और e chunks दोनों की आवश्यकता होती है।

फिर हम आपूर्ति किए गए इंडेक्स को ऐसे परिवर्तित कर सकते हैं कि विषम संख्याएँ pi chunk तक पहुँचती हैं और यहाँ तक कि संख्याएँ गणना का उपयोग करके e chunk तक पहुँचती हैं:

9+fix(n/2)+56*mod(n,2)

उपरोक्त स्ट्रिंग में उस (उन) सूचकांक (सूचकांक) को एक्सेस करना सही आउटपुट प्रदान करेगा।


0

Axiom, 148 बाइट्स

g(x,n)==floor(numeric(x)*10^n)::INT rem 10
f(n:NNI):NNI==(m:=digits((n+4)::PI);x:=n quo 2;if n rem 2=1 then r:=g(%e,x)else r:=g(%pi,x);digits(m);r)

0 आधारित सरणी। परिणाम

(10) -> [f(i) for i in 0..20]
   (10)  [3,2,1,7,4,1,1,8,5,2,9,8,2,1,6,8,5,2,3,8,5]
                                            Type: List NonNegativeInteger
(11) -> f(100001)
   (11)  6
                                                    Type: PositiveInteger

0

गूगल शीट्स, 47 बाइट्स

नोट: एक्सेल और गूगल शीट्स में संग्रहीत स्थिरांक की लंबाई के कारण, यह समाधान केवल 20 अंकों के हिसाब से सटीक है

बेनामी वर्कशीट फ़ंक्शन जो सेल से इनपुट लेता है A1और पाई के उस अंक को कॉलिंग सेल में आउटपुट करता है

=Mid(.1*If(IsOdd(A1),Pi(),.1*Exp(1)),3+A1/2,1

हार्डकोड संस्करण, 112 बाइट्स

यह संस्करण पूरी तरह से कार्यक्रम विनिर्देश को पूरा करता है, लेकिन आम तौर पर मजेदार नहीं है।

बेनामी वर्कशीट फ़ंक्शन जो पाई की 1-अनुक्रमित सूची में nth अंक लौटाता है

=Mid("3217411852982168523854859970943522338543662062483734873123759256062284894717957712649730999336795919",A1,1

दशमलव बिंदु (SUBSTITUTE के अनुसार) को स्थानांतरित करने के लिए 10 से विभाजित करना पहले समाधान में कुछ बाइट्स बचा सकता है।
वेर्निस्क

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.