पाई को आपका नंबर मिल गया

30

चुनौती :

पाई को अनंत माना जाता है। इसका मतलब है कि हर संख्या पाई के दशमलव भाग के अंदर समाहित है। आपका कार्य इनपुट पर धनात्मक पूर्णांक लेना और आउटपुट पर pi अंकों में इस संख्या की स्थिति को वापस करना होगा।

उदाहरण के लिए, यदि इनपुट है 59, तो हम लौट आएंगे4

यहाँ क्यों है: हम 59पाई के अंकों में संख्या की तलाश करेंगे

3.14159265...
     ^^

मान 4 अंक से शुरू होता है, इसलिए आउटपुट होगा 4।

कुछ अन्य उदाहरण:

input : 1      output : 1
input : 65     output : 7
input : 93993  output : 42
input : 3      output : 9

नियम:

  • आपको पहले 200 अंकों के भीतर मौजूद अंकों को संभालने की आवश्यकता नहीं है
  • मानक खामियां, हमेशा की तरह, निषिद्ध हैं।
  • यह कोडगोल्फ है , इसलिए कम बाइट्स जीतता है।
code-golf  pi 
— यादृच्छिक आदमी
स्रोत
41
आपके द्वारा उल्लेख की गई संपत्ति की संख्या सामान्य संख्या के रूप में जानी जाती है । एक अनंत दशमलव विस्तार, भले ही गैर-आवधिक हो, सामान्यता का मतलब नहीं है। 0.101001000100001 ... एक प्रतिरूप है।
— डेनिस
38
और, बिल्कुल, पाई को अनंत नहीं माना जाता है। यह दशमलव प्रतिनिधित्व है, हालांकि, अनंत अंक हैं।
— rafa11111
11
@ डेनिस नॉर्मल बहुत मजबूत स्थिति (ऑल-यूनिफॉर्म बनाम ऑल-
— वेज
6
क्या हमें 0-अनुक्रमित nवें सूचकांक के आउटपुट की अनुमति है ? तो पाठ मामलों वापसी होगी 0, 6, 41, 8बजाय 1, 7, 42, 9।
— केविन क्रूज़सेन
7
@ rafa11111 मैं सहमत हूं। हमें पूर्णांक को छोड़ देना चाहिए और बेस-पीआई में संख्याओं का उपयोग करना चाहिए। तब पूर्णांकों के बजाय अनंत अंक होंगे।
— mbomb007

जवाबों:

22

पायथन 2, 69 75 71 67 बाइट्स

Caird coinheringaahing के कारण 4 बाइट्स सहेजे गए ।

x=p=1333
while~-p:x=p/2*x/p+2*10**200;p-=2
print`x`.find(input(),1)

3शून्य शून्य 6 6 बाइट की स्थिति में नहीं । इनपुट एक स्ट्रिंग के रूप में दिया गया है।

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

अनबाउंड संस्करण

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

def g():
 q,r,t,i,j=1,0,1,0,1
 while True:
  i+=1;j+=2;q,r,t=q*i,(2*q+r)*j,t*j;n=(q+r)/t
  if n*t>4*q+r-t:yield n;q,r=10*q,10*(r-n*t)
a=input()
l=len(`a`)
s=z=10**l;i=1-l
p=g().next;p()
while s!=a:s=(s*10+p())%z;i+=1
print i

ऊपर उपयोग किए गए समान सूत्र के आधार पर एक अनबिके स्पिगोट का उपयोग करना।

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

तेज़ संस्करण

from gmpy2 import mpz
def g():
  # Ramanujan 39, multi-digit
  q, r, s ,t = mpz(0), mpz(3528), mpz(1), mpz(0)
  i = 1
  z = mpz(10)**3511
  while True:
    n = (q+r)/(s+t)
    if n == (22583*i*q+r)/(22583*i*s+t):
      for d in digits(n, i>597 and 3511 or 1): yield d
      q, r = z*(q-n*s), z*(r-n*t)
    u, v, x = mpz(1), mpz(0), mpz(1)
    for k in range(596):
      c, d, f = i*(i*(i*32-48)+22)-3, 21460*i-20337, -i*i*i*24893568
      u, v, x = u*c, (u*d+v)*f, x*f
      i += 1
    q, r, s, t = q*u, q*v+r*x, s*u, s*v+t*x

def digits(x, n):
  o = []
  for k in range(n):
    x, r = divmod(x, 10)
    o.append(r)
  return reversed(o)

a=input()
l=len(`a`)
s=z=10**l;i=1-l
p=g().next;p()
while s!=a:s=(s*10+p())%z;i+=1
print i

रामानुजन # 39 पर आधारित एक बहुत तेज़ गति से चलने वाला स्पिगोट ।

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

— Primo
स्रोत
न तो, न तो हार्डकोड और न ही बिल्ट-इन का उपयोग करें (क्योंकि पायथन में कोई भी नहीं है)
— user202729
1
— caird coinheringaahing
2
@ डेनिस 31
— प्रिमो
2
यह कौन सा सन्निकटन एल्गोरिथ्म है? क्या यह यहाँ सूचीबद्ध है? en.wikipedia.org/wiki/Approximations_of_%CF%80
— Sphinxxx
4
@Sphinxxx यह ल्युनिज़ श्रृंखला में यूलर ट्रांसफॉर्म को लागू करने का पुनर्भरण है। मैंने पिछली पोस्ट में एक व्युत्पत्ति पोस्ट की है ।
— प्रिमो
19

भूसी , 5 बाइट्स

€tİπd

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

व्याख्या

€tİπd                              59
    d  Convert to base-10 digits   [5,9]
  İπ     The digits of pi          [3,1,4,1,5,9..]
 t       Remove the first element  [1,4,1,5,9,2..]
€      Index of the sublist        4
— FYR
स्रोत
1
हास्यास्पद - ​​लेकिन मुझे मानना ​​पड़ेगा कि मैं प्रभावित हूँ।
— फ्लोरिस
6
गोल्फिंग भाषाओं के साथ, यह आमतौर पर एक स्पष्टीकरण जोड़ने के लिए एक अच्छा विचार है, क्योंकि कोई व्यक्ति जो भाषा नहीं जानता है वह इसे पढ़ने में सक्षम नहीं होगा। अगर मैं इसे सही ढंग से समझता हूं: पीआई ( ) के अंकों के €पहले आइटम (प्रमुख 3) हटाए गए ( t) के साथ ( ) के सूचकांक को लें İπ, इसे बेस -10 dऔर (एसटीडीयूटी (अनुमानित रूप से) में आउटपुट में परिवर्तित करें ।
— केविन क्रूज़सेन
सहमत, मुझे नहीं पता कि मैं क्या देख रहा हूं।
— JA Terroba
1
@gggg ऐसा लगता है कि यह एक आलसी प्रतिनिधित्व उदाहरण है , सत्यापन
— ASCII-
1
@gggg İπअंकों की एक अनंत सूची है, जो एक
— अनगढ़ स्पिगोट
18

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

=FIND(A1,"14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196")

एक्सेल केवल 15 दशमलव स्थानों को संभालता है, इसलिए पीआई सिर्फ हार्ड-कोडेड है। इस चुनौती के लिए यह एक बहुत कमजोर ऊपरी बाध्य होना चाहिए।

— इंजीनियर टोस्ट
स्रोत
4
मुझे अपने स्वयं के पोस्ट पर टिप्पणी करने के लिए खेद है, लेकिन क्या कुछ upvoters मुझे बता सकते हैं कि उन्हें यह उत्तर क्यों पसंद है? यह एक Excel सूत्र में हो सकता है के रूप में गोल्फ है, लेकिन यह बहुत लंबा है और बिल्कुल चालाक नहीं है।
— इंजीनियर टोस्ट
6
मुझे यह पसंद है क्योंकि यह उन गोल्फिंग भाषाओं पर निर्भर नहीं करता है जिनके पास एक मनमाना दशमलव स्थान के लिए पाई की गणना करने के लिए बिलिन हैं। यह रचनात्मक नहीं हो सकता है, लेकिन यह व्यावहारिक है (व्यावहारिकता यहां मायने नहीं रखती है)।
— स्कॉट
जैसा कि यह प्रश्न निर्दिष्ट नहीं करता है कि इनपुट या उत्तर का आधार 10 होना चाहिए, क्या आप इसका उपयोग करके CONCATऔर BBP फॉर्मूला को by-आधार 16 के पहले 200 अंकों की गणना करने और इसके बजाय हेक्साडेसिमल में खोजने के लिए गोल्फ कर सकते हैं ? (365 नहीं है, इसलिए परीक्षण नहीं कर सकते)
— क्रोनोसाइडल
2
केवल Office 365: का उपयोग करना CONCAT, CODEऔर MIDमैंने PI वर्ण को 202 वर्णों (inc कोट्स) से CONCAT(CODE(MID(".ÜÁ£ÙÏ ¦®š«¦ Ï²œÔ“ÇŧÝËŠº”ᱬ»—‡ÑÀ†œ¾ˆãÖœƒ°™¢•‘†ÏÒŽÐÖ³ ÒžÂ¯‰¦¬¼ß²º–ŸÈµ»¨Ñœ°‹‘­‚ÔŠ›ÝÕ•Š·»À®–Þٶ݃Ñà",2*ROW(A1:A100)-1,2))-32)
— घटा
1
Office365 के साथ परीक्षण, ऐसा लगता है कि यह इनपुट के बावजूद 14 आउटपुट देता है?
— मैथ्यू श्लैचर
9

जावा 8, 615 217 202 184 182 166 165 बाइट्स ( 999 200 अंकों की गणना )

n->{var t=java.math.BigInteger.TEN.pow(200);var r=t;for(int p=667;p-->1;)r=t.valueOf(p).multiply(r).divide(t.valueOf(p-~p)).add(t).add(t);return(r+"").indexOf(n,1);}

1 अनुक्रमित

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

जावा के बिलिन Math.PIमें कई अन्य भाषाओं की तरह 15 दशमलव मान हैं। अधिक अंक प्राप्त करने के लिए, आपको उनके साथ BigIntegersया उनके साथ स्वयं की गणना करनी होगी BigDecimals। यह ऊपर ऐसा करने का एक तरीका है .. हो सकता है कि कोई इसे 211 बाइट्स से नीचे गोल्फ कर सकता है, lol ..
EDIT: @primo के पायथन 2 उत्तर का एक पोर्ट बनाया गया है (उसे उखाड़ने के लिए सुनिश्चित करें!), इसलिए कठिन समय की गणना करें। -कोड अब तक नहीं लाया गया है। यह छोटा होने के लिए गोल्फ को सिर्फ 7 और बाइट्स।

-15 बाइट्स @ @ धन्यवाद के लिए धन्यवाद , इसे नीचे दिए गए हार्ड-कोडेड उत्तर की तुलना में छोटा बना देता है!
-36 बाइट्स @primo का धन्यवाद ।
-1 बाइट में बदल रहा java.math.BigInteger t=null,T=t.TEN.pow(200),r=T;है var T=java.math.BigInteger.TEN.pow(200);var r=T;, क्योंकि var1 बाइट से छोटा है null(नए जावा 10 से प्यार होगा)।

स्पष्टीकरण:

n->{                            // Method with String parameter and integer return-type
  var t=java.math.BigInteger.TEN.pow(200);
                                //  Temp BigInteger with value 10^200
  var r=t;                      //  Result BigInteger, also starting at 10^200
  for(int p=667;                //  Index-integer, starting at 667
      p-->1;)                   //  Loop as long as this integer is still larger than 1
                                //  (decreasing `p` by 1 before every iteration with `p--`)
    r=                          //   Replace the Result BigInteger with:
      t.valueOf(p)              //    `p`
       .multiply(r)             //    multiplied by `r`,
       .divide(t.valueOf(p-~p)) //    divided by `2*p+1`
       .add(t).add(t);          //    And add 2*10^200
  return(r+"")                  //  Convert the BigInteger to a String
    .indexOf(n,                 //  And return the index of the input,
               1);}             //  skipping the 3 before the comma

जावा 8, 211 बाइट्स (हार्ड-कोडेड 200 अंक)

"14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196"::indexOf

0 अनुक्रमित

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

— केविन क्रूज़सेन
स्रोत
1
!p.equals(t.ONE)शायद? इसके अलावा, indexOf(n,1)-1काम करता है मुझे लगता है। या 2 बाइट्स सहेजें और इसे 1-अनुक्रमित करें।
— नील
निश्चित नहीं है कि मैं पहली बार कैसे चूक गया, लेकिन दूसरा मुझे वास्तव में याद रखने की आवश्यकता है। पता नहीं था कि कोई ऐसा indexOfतरीका है जो पहले mपात्रों को छोड़ देता है । टीआईएल, धन्यवाद!
— केविन क्रूज़सेन
1
कैसे रखने के बारे में पी एक पूर्णांक ?
— Primo
1
आप pप्रत्येक बार ( for(int p=667;p-->1;)) और फिर गुणा करके pऔर विभाजित करके एक-एक करके घटा सकते हैं p-~p।
— प्रिमो
1
का प्रारंभिक मूल्य rवस्तुतः कुछ भी हो सकता है, हालांकि चरम मूल्यों को अधिक पुनरावृत्तियों की आवश्यकता होगी। सबसे अच्छा बीज (कम से कम पुनरावृत्तियों) वास्तव में है 4e200।
— प्रिमो
6

05AB1E , 6 बाइट्स

₁žs¦¹k

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

कैसे?

₁        push 256
 žs      push pi to 256 places
   ¦     remove the leading 3
    ¹    push the input
     k   index inside that string
— Uriel
स्रोत
यदि आपके बाद मुझे उसी भाषा में समान 6-बाइट समाधान मिलता है, तो क्या मैं अपना उत्तर हटा दूंगा?
— 15
@nicael आमतौर पर इससे कोई फर्क नहीं पड़ता, लेकिन आपका समाधान 3वैसे भी विफल रहता है
— Uriel
ओह, वास्तव में, thnks
— nicael
6

MATL , 16 15 बाइट्स

YP8WY$4L)jXfX<q

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

व्याख्या

YP     % Push pi as a double
8W     % Push 2^8, that is, 256
Y$     % Compute pi with 256 significant digits using variable-precision arithmetic
       % The result as a string
4L)    % Remove first character. This is to avoid finding '3' in the integer part
       % of pi
j      % Push input as a string
Xf     % Strfind: gives array of indices of occurrences of the input string in the
       % pi string
X<     % Mimimum
q      % Subtract 1. Implicitly display
— लुइस मेंडो
स्रोत
बहुत अच्छा और छोटा! क्या आप बता सकते हैं कि यह कैसे काम करता है?
— यादृच्छिक लड़का
@Therandomguy ज़रूर, स्पष्टीकरण जोड़ा
— लुइस
4

आर + संख्या पैकेज, 52 बाइट्स

regexec(scan(),substring(numbers::dropletPi(200),3))

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

dropletPiपहले 200 दशमलव अंकों की गणना करता है, piलेकिन 3.शुरुआत में इसमें शामिल होता है , इसलिए हम इसे बाहर निकालते हैं substringऔर फिर मैच करते हैं regexec, जो मैच के सूचकांक के साथ मैच के बारे में कुछ मेटाडेटा देता है।

— ग्यूसेप
स्रोत
हो सकता है regexpr(scan(),numbers::dropletPi(200))-2?
— djhurio
@djhurio जो काम नहीं करता है क्योंकि हमें दशमलव बिंदु के बाद अंकों में मेल खाना है। यह मेरा पहला विचार था, लेकिन उस मामले ने इसे बर्बाद कर दिया। शायद एक "if"?
— Giuseppe
मुझे यहां कोई समस्या नहीं दिख रही है। गैर इनपुट में निहित होगा 3.(मेरा मानना ​​है कि हम पूर्णांकों से निपटते हैं जो इनपुट में नहीं होते हैं)। परीक्षण के उदाहरण इसके साथ काम करते हैं।
— djhurio
3
@djhurio सही लेकिन regexpr(3,numbers::dropletPi(200))-2रिटर्न -1 जब यह वापस आ जाएगी 9, यह कोशिश
— ग्यूसेप
3

जेली , 23 बाइट्स

⁵*⁹Ḥ;ȷḊ+J$¤×⁹:2¤:ɗ\SṾḊw

वर्णों की सूची (खोजने के लिए पूर्णांक) और सूचकांक को वापस करने वाला एक मानद लिंक। Π के दशमलव भाग के पहले 252 अंकों के भीतर निहित आदानों के लिए काम करता है।

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

कैसे?

यह अग्रणी के साथ पहले 253 अंकों की गणना करने के लिए Le के लिए लाइबनिज सूत्र का उपयोग करता है 3(प्लस चार अनुगामी गलत अंक)। अग्रणी 3तब गिरा दिया जाता है और इनपुट का सूचकांक पाया जाता है:

⁵*⁹Ḥ;ȷḊ+J$¤×⁹:2¤:ɗ\SṾḊw - Link: list of characters
⁵                       - literal ten
  ⁹                     - literal 256
 *                      - exponentiate = 10000...0 (256 zeros)
   Ḥ                    - double       = 20000...0
          ¤             - nilad followed by links as a nilad:
     ȷ                  -   literal 1000
      Ḋ                 -   dequeue -> [2,3,4,5,...,1000]
         $              -   last two links as a monad:
        J               -     range of length -> [1,2,3,4,...,999]
       +                -     addition (vectorises) -> [3,5,7,9,...,1999]
    ;                   -   concatenate -> [20000...0,3,5,7,9,...,1999]
                  \     - cumulative reduce with:
                 ɗ      -   last three links as a dyad:
               ¤        -     nilad followed by link(s) as a nilad:
            ⁹           -       chain's right argument (the right of the pair as we traverse the pairs in the list -- 3, 5, 7, 9, ...)
              2         -       literal two
             :          -       integer division (i.e. 1, 2, 3, ...)
           ×            -     multiply (the left of the pair, the "current value", by that)
                :       -   integer divide by the right argument (i.e. 3, 5, 7, 9, ...)
                   S    - sum up the values (i.e. 20000...0 + 66666...6 + 26666...6 + 11428...2 + ... + 0)
                    Ṿ   - un-evaluate (makes the integer become a list of characters)
                     Ḋ  - dequeue (drop the '3')
                      w - first (1-based) index of sublist matching the input

यदि आप इनपुट उपयोग ⁵*⁹Ḥ;ȷḊ+J$¤×⁹:2¤:ɗ\SDḊw(23 भी) के रूप में अंकों की एक सूची पसंद करते हैं , जबकि यदि आप वास्तव में इसे पूर्णांक उपयोग ⁵*⁹Ḥ;ȷḊ+J$¤×⁹:2¤:ɗ\SDḊwD(24 के लिए) देना चाहते हैं ।

— जोनाथन एलन
स्रोत
आपका तात्पर्य है कि यूलर का परिवर्तन लाइबनिज सूत्र पर लागू हुआ। लाइबनिट्स फॉर्मूले के साथ 252 अंकों की गणना करने में ज्यादातर लोगों की प्रतीक्षा करने की तुलना में थोड़ा अधिक समय लगेगा।
— Primo
हाँ, इसे कच्चे रूप में एक लंबा समय लगेगा (यह अभी भी "लाइबनिट्स सूत्र का उपयोग करके" मुझे विश्वास है!)
— जोनाथन एलन
3

BASH (GNU / Linux), 75 67 66 बाइट्स

सोफिया लेचनर के लिए 1 बाइट धन्यवाद, और गायों के लिए 7 बाइट्स धन्यवाद।

a=`bc -l<<<"scale=999;4*a(1)"|tail -c+2|grep -ob $1`;echo ${a%%:*}

यह एक शेल स्क्रिप्ट है जो एकल तर्क लेता है, जो कि संख्या है। के साथ टेस्ट करें

$ bash <script-path> 59
4

यह स्क्रिप्ट पहले तीन आदेशों की एक पाइपलाइन निष्पादित करती है:

bc -l<<<"scale=999;4*a(1)"|    #produce pi with its first 999 fractional digits
tail -c+2|                     #cut off the "3."
grep -ob $1                    #compute the byte offsets of our argument in the string

इस पाइपलाइन का परिणाम शेल चर को सौंपा गया है a, जिसे बाद में किसी भी चीज से बाहर निकाल दिया गया है लेकिन पहले नंबर को हटा दिया गया है:

a=`...`;         #assign the result of the pipeline to a variable
echo ${a%%:*}    #cleave off the first : character and anything following it

दुर्भाग्य से, bcजब वे बहुत लंबे हो जाते हैं, तो उत्पादन लाइनों को तोड़ने की प्रवृत्ति होती है। यह गलत परिणाम हो सकता है यदि पाया जाने वाला नंबर पहली पंक्ति में नहीं है। आप पर्यावरण चर सेट करके इससे बच सकते हैं BC_LINE_LENGTH:

export BC_LINE_LENGTH=0

यह लाइन ब्रेकिंग फीचर को पूरी तरह से निष्क्रिय कर देता है।

जाहिर है, यदि अन्य आउटपुट को सहन किया जाता है, तो अंतिम दो कमांड को छोड़ा जा सकता है।
यह 48 बाइट्स की एक गिनती देता है :

bc -l<<<"scale=999;4*a(1)"|tail -c+2|grep -ob $1

परिणामी आउटपुट के साथ:

$ bash <script-path> 59
4:59
61:59
143:59
179:59
213:59
355:59
413:59
415:59
731:59
782:59
799:59
806:59
901:59
923:59
940:59
987:59
— cmaster
स्रोत
अच्छा! आप के बीच -lऔर <<<यद्यपि उस स्थान की आवश्यकता नहीं है ।
— सोफिया लेचनर
आप एक प्रोग्राम में कनवर्ट कर सकते हैं और कुछ बाइट्स को बचाने के लिए sed का उपयोग कर सकते हैं, इसे ऑनलाइन आज़माएं!
— कृति लिथोस
@ Cowsquack क्या मुझे बाइट की गिनती में फिर से एक शेबबैंग लाइन को शामिल करने की आवश्यकता नहीं होगी?
— सेमीस्टर
@cmaster शेलबैंग लाइनों को किसी भी भाषा के लिए बाइट काउंट में शामिल नहीं किया जाता है
— Kritii Lithos
@Cowsquack सुझाव के लिए धन्यवाद। हालाँकि, यदि आप अतिरिक्त आउटपुट की अनुमति देते हैं, तो आप साथ ही साथ छोड़ सकते हैं sed(मेरे उत्तर का दूसरा भाग देखें)। फिर भी, एक कार्यक्रम में बदलने से मुझे 7 बाइट्स मिल गए, इसलिए इसके लिए धन्यवाद! मैंने शेल ब्वॉय जादू के साथ tr/ headकॉम्बो को भी बदल दिया है ताकि एक अन्य बाइट को बचाया जा सके।
— सेमीस्टर
2

जावास्क्रिप्ट, 197 187

-10: धन्यवाद, नील !

x=>"50ood0hab15bq91k1j9wo6o2iro3by0h94bg3geu0dnnq5tcxz7lk62855h72el61sx7vzsm1thzibtd23br5tr3xu7wsekkpup10cek737o1gcr6t00p3qpccozbq0bfdtfmgk".replace(/.{9}/g,a=>parseInt(a,36)).search(x)+1

नौ अंकों के बेस -36 पूर्णांक की एक श्रृंखला लेता है, उन्हें बेस 10 में परिवर्तित करता है, और पीआई के पहले 200 अंकों को बनाने के लिए उन्हें समेटता है।

— apsillers
स्रोत
अच्छा है, आप डेटा को पानी से बाहर निकालने के लिए मेरे प्रयासों को उड़ाते हैं, आपका दृष्टिकोण कच्चे डेटा पर 38 बाइट्स बचाता है।
— नाइट
+1 - मैं ठीक उसी दृष्टिकोण को पोस्ट करने वाला था।
— darrylyeo
x=>'50...'.replace(/.{9}/g,a=>parseInt(a,36)).search(x)+110 बाइट बचाने के लिए उपयोग करें ।
— नील
2

पहली बार कोड गोल्फ कर रहा हूं। फ़ंक्शन कॉल को कम करने के लिए प्रतिनिधियों और लैम्ब्डा अभिव्यक्तियों का उपयोग करें। एकल बाइट में V2 का छोटा वर्ग नाम।

[सी #], ३६१ ३५५ बाइट्स

using System;class P{static void Main(){Func<string,int>F=f=>"14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196".IndexOf(f)+1;Action<int>w=Console.WriteLine;w(F("1"));w(F("65"));w(F("93993"));w(F("3"));}}

प्रारूपित संस्करण:

using System;

class P
{
    static void Main()
    {
        Func<string,int>F=f=>"14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196".IndexOf(f)+1;
        Action<int>w=Console.WriteLine;
        w(F("1"));
        w(F("65"));
        w(F("93993"));
        w(F("3"));
    }
}

Ideone!

NB.I ने पहले संस्करण को मिस किया। यह 361 बाइट्स था, न कि 363 बाइट्स।

[सी #], टियो संस्करण २१ by बाइट्स

f=>"14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196".IndexOf(f)+1

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

— हान
स्रोत
आपको अपने कोड में परीक्षण के मामलों को शामिल करने की आवश्यकता नहीं है, और आप एक पूर्ण कार्यक्रम के बजाय एक लैम्ब्डा (अनाम) फ़ंक्शन का उपयोग कर सकते हैं
— Zac Faragher
Hyarus ने using System;f=>"14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196".IndexOf(f)+1;एक संपादन के रूप में सुझाव दिया ।
— अंडा
मैं यहां नया हूं और मुझे लगा कि मुझे टेस्ट केस सहित पूरा कार्यक्रम शामिल करना चाहिए। ऐसा लगता है कि लोग विचारधारा के बजाय प्रदर्शन के लिए tio.run का उपयोग कर रहे हैं। मुझे लगता है कि tio.run कोड को भागों में विभाजित करता है।
— हान
2

हास्केल , 208 120 बाइट्स

a=1333
x=tail$show$foldr(\p x->p`div`2*x`div`p+2*10^200)a[3,5..a]
x!n|take(length n)x==n=0|1<2=1+tail x!n
f n=1+x!show n

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

जोनाथन एलन को उनके सुझावों के लिए बहुत धन्यवाद !

पुराना संस्करण (208 बाइट्स)

(+1).((tail$g(1,0,1,1,3,3))!)
g(q,r,t,k,n,l)=([n:g(10*q,10*(r-n*t),t,k,div(10*(3*q+r))t-10*n,l)|4*q+r-t<n*t]++[g(q*k,(2*q+r)*l,t*l,k+1,div(q*(7*k+2)+r*l)(t*l),l+2)])!!0
x!n|take(length n)x==n=0|1<2=1+tail x!n

मुझे वास्तव में नहीं पता कि ऊपर का कोड कैसे काम करता है; मैंने इसे इस पेपर से लिया है और मैंने जो भी लागू किया वह लुकअप हिस्सा था। g(1,0,1,1,3,3)पाई के अंक लौटाता है और आश्चर्यजनक रूप से कुशल होता है (यह 4 जी से कम समय में tio.run पर 10 000 अंकों की गणना करता है)।

इनपुट एक सूची है जिसमें संख्या के अंकों को शामिल किया जाना है।

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

— क्रिस्टियन लुपस्कू
स्रोत
मेरा अनुमान है कि लाइबनिट्स फॉर्मूला कहीं कम होगा।
— जोनाथन एलन
@JonathanAllan धन्यवाद! मुझे इसे एक मौका और देना होगा। मैं पूरी तरह से इस साइट से प्यार करता हूँ! मैंने आपसे बहुत कुछ सीखा है , दोस्तों! :)
— क्रिस्टियन लुपस्कू
@JonathanAllan मैंने लगभग pi का उपयोग करने की कोशिश की l=4*sum[((-1)**x/(2*x+1))|x<-[0..1e6]], लेकिन इसे चलाने के लिए 5s लगते हैं और 7 वां अंक पहले से ही गलत है। इसलिए यह 200 अंकों की गणना करने के लिए संभव नहीं है। यह वैसे भी एक दिलचस्प अभ्यास था, इसलिए धन्यवाद!
— क्रिस्टियन लुपस्कू
1
आप यूलर ट्रांसफ़ॉर्म (मेरे जेली उत्तर या प्राइमो के पायथन उत्तर देखें) का उपयोग करना चाहते हैं
— जोनाथन एलन
1
आपके द्वारा लिंक किए गए कागज के संदर्भ में, आप इस पद के लिए इच्छुक हो सकते हैं , जिसमें मैं "जानबूझकर आक्षेप" के बिना इस पेपर में पाए गए कोड को फिर से लागू कर सकता हूं। यह परिणाम के रूप में काफी सरल (छोटा) है। g1_refअनुभाग में देखें विधि तेजी से अनबाउंड जेनरेटर । कोड अजगर है।
— Primo
2

हास्केल, 230 बाइट्स

पाई के अनंत अंकों में कहीं भी संख्या को खोजने के लिए आलस्य का उपयोग करते हुए, न केवल पहले 200 अंकों में। ओह, हाँ, और यह आपको (अनंत रूप से कई?) संख्या के उदाहरण (ओं) को लौटाता है, न कि पहले वाले को।

p=g(1,0,1,1,3,3)where g(q,r,t,k,n,l)=if 4*q+r-t<n*t then n:g(10*q,10*(r-n*t),t,k,div(10*(3*q+r))t-10*n,l) else g(q*k,(2*q+r)*l,t*l,k+1,div(q*(7*k+2)+r*l)(t*l),l+2)
z n=[(i,take n$drop i p)|i<-[1..]]
f l=[n|(n,m)<-z$length l,m==l]

चुनौती से उदाहरण

>  take 10 $ f [1]
[1,3,37,40,49,68,94,95,103,110]
>  take 10 $ f [6,5]
[7,108,212,239,378,410,514,672,870,1013]
>  take 1 $ f [9,3,9,9,3]
[42]
>  take 10 $ f [3]
[9,15,17,24,25,27,43,46,64,86]

क्रेडिट

'p' pi अंकों की अनंत धारा है, जिसे https://rosettacode.org/wiki/Pi#Hodell से लिया गया है

> take 20 p
[3,1,4,1,5,9,2,6,5,3,5,8,9,7,9,3,2,3,8,4]
— tombop
स्रोत
मुझे लगता है कि आप पहले से ही यह जानते हैं, लेकिन आपको केवल अपने अनुक्रम में पहले नंबर का उत्पादन करने की आवश्यकता है ...
— टाइमटेक
बस सोचा था कि मैं अनंत-नेस को गले
— लगाऊंगा
2

स्माइलबास्क, 179 164 बाइट्स

INPUT I$FOR I=0TO 103Q$=Q$+STR$(ASC("\A#YO &.+& O2TGE']KiRa1,;N(>VYb>P0*uCb0V3 RB/]T._2:H5;(Q0oJ2)&4n7;@.^Y6]&"[I]))NEXT?INSTR(Q$,I$)+1

पाई के अंक हार्डकोड किए गए हैं और पात्रों के एएससीआई मूल्यों में पैक किए गए हैं। 14 -> CHR$(14), 15 -> CHR$(15), 92 -> \, 65 -> A, 35 -> #।

स्ट्रिंग में अनपेक्षित वर्ण हैं, इसलिए यहां हेक्साडेसिमल में लिखे गए बाइट्स हैं: 0E 0F 5C 41 23 59 4F 20 26 2E 1A 2B 26 20 4F 32 1C 54 13 47 45 27 5D 4B 69 52 00 61 31 2C 3B 17 00 4E 10 28 3E 56 14 59 62 3E 50 03 30 19 03 2A 75 00 43 62 15 30 00 56 33 20 52 1E 42 2F 00 5D 54 2E 00 5F 32 3A 16 1F 48 35 3B 28 51 1C 30 6F 4A 32 1C 29 00 1B 00 13 26 34 6E 37 3B 40 2E 16 5E 59 36 5D 00 26 13 06

दशमलव में, आप पाई के अंक देख सकते हैं: 14 15 92 65 35 89 79 32 38 46 26 43 38 32 79 50 28 84 19 71 69 39 93 75 105 82 0 97 49 44 59 23 0 78 16 40 62 86 20 89 98 62 80 3 48 25 3 42 117 0 67 98 21 48 0 86 51 32 82 30 66 47 0 93 84 46 0 95 50 58 22 31 72 53 59 40 81 28 48 111 74 50 28 41 0 27 0 19 38 52 110 55 59 64 46 22 94 89 54 93 0 38 19 6

— 12Me21
स्रोत
यदि आप पूरा कोड पोस्ट करते हैं, तो इससे आपके उत्तर को सत्यापित करना आसान हो जाएगा।
— प्रिमो
1
मैं इसे पोस्ट नहीं कर सकता क्योंकि अमान्य वर्ण हैं जिन्हें हटा दिया गया है / प्रदर्शित नहीं किया गया है। मुझे लगता है कि मैं हालांकि एससीआई कोड पोस्ट कर सकता हूं।
— 12M2121
आप उदाहरण के लिए xxd का उपयोग करके एक हेक्सडंप पोस्ट कर सकते हैं।
— नथानिएल
2

रूबी , 37 35 बाइट्स

p"#{BigMath::PI 200}"[3..-3]=~/#$_/

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

कुछ खास नहीं, सिर्फ बिल्ट-इन लाइब्रेरी दिखा रहे हैं। आउटपुट 0-अनुक्रमित है। पाई स्ट्रिंग को स्वरूपित किया गया है 0.31415...e1, इसलिए हमें पहले 3 वर्णों को अलग करना होगा। e1अंत में भाग वास्तव में कोई नुकसान नहीं करता है, लेकिन यह बहुत दूर छीन लिया है, जैसा कि हम वैसे भी एक सीमा अंत (या टुकड़ा लंबाई) मूल्य प्रदान करने की जरूरत है।

— किरिल एल।
स्रोत
छोटा और पठनीय!
— pjs
2

चारकोल , 27 15 बाइट्स

Ｉ⊖∨⌕Ｉ▷N⟦≕Piφ⟧θχ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। लगभग 1000 अंकों तक काम करता है। स्पष्टीकरण:

        ≕Pi     Get variable `Pi`
           φ    Predefined variable 1000
     ▷N⟦    ⟧   Evaluate variable to specified precision
    Ｉ           Cast to string
             θ  First input
   ⌕            Find
              χ Predefined variable 10
   ∨             Logical OR
  ⊖              Decrement
 Ｉ               Cast to string
                 Implicitly print
— नील
स्रोत
तय, 13 बाइट्स । ध्यान दें: यह वास्तव में धोखा महसूस करता है: P
— ASCII-only
वास्तव में तय, 13 बाइट्स । निहित इनपुट का उपयोग करता है। (अभिप्रेत व्यवहार नहीं है लेकिन यह किसी अन्य तरीके से अधिक उपयोगी है)। क्या आप भरण बग के उदाहरण से भी जुड़ सकते हैं?
— केवल
@ ASCII- केवल विचित्रता भरें - कर्सर वहाँ क्यों समाप्त होता है?
— नील
: | ओह, मुझे नहीं पता कि मुझे उस asap को ठीक करना चाहिए
— ASCII-only
— केवल
2

जाप , 186 177 बाइट्स

`nqnrvosrpruvtvpopuqsosqppÕÝvr¶uuqnvtnsvpvvptrnmruomvtqvqqrvopmÉæqÛàÑ$vvÔàmpqupqm¡vuqum«rnpopmssqtmvpuqqsmvrrmruoopÌÊprvqÛ$uqunnqr¶uqn¶tmnvpÔnmrrrvsqqsoovquvrqvpmpunvs`®c -#mÃbU

चूँकि Japt, Javascript के 15-अंकीय Pi अवरोध और शोको को साझा करता है, Japt द्वारा उपयोग की जाने वाली एन्कोडिंग, संख्याओं को एनकोड नहीं करती है, संपीड़न के लिए कुछ शीनिगन्स की आवश्यकता होती है।

संक्षेप में समझाया गया है, शुरुआत एन्कोडेड रूप में नीचे का तार है:

"nqnrvosrpruvtvpopuqsosqppupotvrmouuqnvtnsvpvvptrnmruomvtqvqqrvopmtunsqmsousomuvvusoumpquorpqonntmstvuonqumusrnpouopmssqtmvpuqqsmvrrmruoopntorprvqmunouqunnntqrmouqnmotmnvpuronnmrrrvsqqsoovquvrqvpmpunvs"

जो एक स्ट्रिंग है जहां प्रत्येक अक्षर है 'm' + corresponding digit of pi। मैंने पूरी वर्णमाला का परीक्षण किया और वह पत्र कुछ बाइट्स द्वारा सर्वश्रेष्ठ संपीड़न देता है।

Backticks स्ट्रिंग को डीकोड करने के लिए Japt को बताता है। इसके बाकी हिस्से बहुत सीधे हैं: 

®c -#mÃbU
®          // Given the above string, map each letter
 c         // and return its charcode
   -#m     // minus the charcode of 'm', 109.
      Ã    // When that's done,
        bU // find the index of the implicit input U.

आउटपुट 0-आधारित मिलान के सूचकांक। ओलिवर की
बदौलत एक और दो बाइट शेव की ।

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

— लीख
स्रोत
1
चतुर विचार! आप £X®} Ã
— ओलिवर
@ ओलिवर उन लोगों के लिए बहुत बहुत धन्यवाद, मैं अभी भी जाप सीख रहा हूं इसलिए सभी मदद बहुत सराहना की है।
— लीख
1
आप अब तक बहुत अच्छा कर रहे हैं! मैं यह देखने के लिए उत्सुक था कि क्या 109 की तुलना में बेहतर ऑफसेट था। मैंने एक ब्रूटफॉरसर बनाया , और यह पता चला कि 109 इष्टतम है। अच्छी तरह से किया :)
— ओलिवर
@ इसके लिए धन्यवाद, मैंने बस पूरी az रेंज को मैन्युअल रूप से आज़माया क्योंकि यह बहुत ज्यादा काम नहीं था। : पी
— नाइट
1

AWK -M, 131 119 117 बाइट्स

-Mमनमाने ढंग से सटीक गणना के लिए ध्वज का उपयोग करता है । p=k=0बहु-पंक्ति इनपुट की अनुमति देने के लिए TIO लिंक में (5 बाइट्स) जोड़ा गया

{CONVFMT="%.999f";PREC=1e3;for(p=k=0;k<1e3;)p+=(4/(8*k+1)-2/(8*k+4)-1/(8*k+5)-1/(8*k+6))/16^k++;$0=$1==3?9:index(p,$1)-2}1

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

स्पष्टीकरण:

{CONVFMT="%.999f";  # Allows 999 decimal digits to be used when numbers are convert to strings
PREC=1e3;           # Digits of precision to use for calculations
for(;k<1e3;)p+=(4/(8*k+1)-2/(8*k+4)-1/(8*k+5)-1/(8*k+6))/16^k++; # The most concise numerical calculation I could find. It doesn't converge  extremely rapidly, but it seems to work OK
$0=$1==3?9:index(p,$1)-2}  # Replace input line with either 9 or index-2
                           # since indices will either be 1 (meaning 3 was input) or >= 3
1                   # Print the "new" input line
— रॉबर्ट बेन्सन
स्रोत
मेरा पहला प्रयास sprintfदशमलव प्राप्त करने के लिए किया जाता था। का उपयोग CONVFMTनिश्चित रूप से क्लीनर है।
— रॉबर्ट बेन्सन
2
ध्वज का उपयोग करने की आवश्यकता नहीं है: मेटा सर्वसम्मति इस पर विचार करने के लिए AWK से अलग भाषा है , "AWK with -Mflag"
— Giuseppe
जानकार अच्छा लगा। मुझे लगता है कि मुझे खाली समय के अपने भार के साथ मेटा पर अधिक समय बिताना चाहिए। :)
— रॉबर्ट बेन्सन
1

जेली , 24 बाइट्स

ȷ*
ȷR×¢:Ḥ‘$ƲU×:¢+¢ʋ/ḤṾḊw

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

विशेष रूप से 1/4 pi == tan -1 (1/2) + tan -1 (1/3) जैसे माचिन जैसे सूत्र का उपयोग करें ।

सूत्र pi / 2 == 1 + 1/3 × (1 + 2/5 × (1 + 3/7 × (1 + 4/9 × (...))) का उपयोग करें

— user202729
स्रोत
क्या ØPM से अंक प्राप्त करने का कोई तरीका है ?
— डायलन
@dylnan कुछ हद तक , लेकिन M जेली नहीं है।
— user202729
मुझे पता है कि वे अलग हैं। विश्वास नहीं कर सकता कि मैंने सोचा नहीं था floor। अगर मैं M में उत्तर के रूप में पोस्ट करने के लिए उपयोग करता हूं तो मन?
— डायलान 10
— dylnan
1

पायथन 2 239 238 229 214 बाइट्स

-9 बाइट्स @primo के कारण

from bigfloat import*;a=s=n=10**10**5;b=k=0
while a:k+=1;a*=k*(k*(108-72*k)-46)+5;a/=k**3*(640320**3/24);s+=a;b+=k*a
with precision(10**7):print`(426880*sqrt(10005*n)*n)/(13591409*s+545140134*b)`.find(input())-16

उपयोग Chudnovsky-रामानुजन एल्गोरिथ्म पहले पता लगाने के लिए 1 लाख अंक π के 50000 अंक (परिवर्तन 10**10**5करने के लिए 10**10**6और अधिक के लिए, लेकिन इसे चलाने के लिए उम्र लेता है) वांछित स्ट्रिंग के लिए और फिर उन्हें खोज करता है।

— DividedByZero
स्रोत
मैंने परिणाम की पुष्टि करने की कोशिश की लेकिन यह समाप्त नहीं होता है ( n=10**10**5लगभग 10s लगता है)।
— प्रिमो
@primo मैंने कभी नहीं कहा कि यह तेज था! 10**10**6मेरी मशीन पर लगभग 7 मिनट लगते हैं .. निष्पक्ष होने के लिए, 10**10**5पहले 50000 अंक देता है, इसलिए मुझे लगता है कि यह उतना बुरा नहीं है :)
— DividedByZero 5'18 '13
@primo मैंने मनमानी परिशुद्धता पुस्तकालय को बिगफ्लोट में बदल दिया है, यह अब बहुत तेज चलता है।
— डिवाइडबायेरो
यह अब बहुत तेज है, मैं स्विच करने का सुझाव देने जा रहा था gmpy2, लेकिन bigfloatएक दर्जन या इतने बाइट्स बचाता है। यदि आप पुनरावृति के प्रारंभ में चले जाते हैं तो असाइनमेंट का kविलय किया जा सकता है । के रूप में अधिक सफलतापूर्वक लिखा जा सकता है । यदि आप पायथन 2 की घोषणा करते हैं, तो पूर्णांक विभाजनों को प्रतिस्थापित किया जा सकता है , और इसके लिए कोष्ठक भी आवश्यक नहीं हैं । इसमें स्पेस भी निकाला जा सकता है । केवल 50000 अंकों के लिए मान्य है, btw। k=b=0k+=1-(6*k-5)*(2*k-1)*(6*k-1)k*(k*(108-72*k)-46)+5///printimport*
— प्रिमो
nमें sqrt(10005*n)समस्या लगती है; यह दशमलव बिंदु को 50000 वें स्थान पर ले जा रहा है। यदि आप रुचि रखते हैं, तो यहां मेरा खुद का Chudnovsky कार्यान्वयन है: इसे ऑनलाइन आज़माएं!
— प्रिमो
1

विजुअल बेसिक - 114 बाइट्स

ठीक है, पहले सबमिशन। मेरे साथ सामान्य रहो!

    Dim s,p As String
    s=Console.Readline()
    p=Math.PI
    Console.Write((p.IndexOf(s,2)-1))

प्रतिक्रिया का स्वागत!

मैंने पीआई के पहले 256 भागों तक ही सीमित नहीं रखा है क्योंकि प्रश्न कहता है "आपको" नहीं करना है "," आपको नहीं "" आशा है कि मैं यह कर रहा हूँ "

— user9338709
स्रोत
मुझे वर्चुअल बेसिक के बारे में ज्यादा जानकारी नहीं है, लेकिन मुझे लगता है कि आप सभी रिक्त स्थान को हटाकर कुछ बाइट्स बचा सकते हैं। आपको अपने कोड को एक फ़ंक्शन में संग्रहीत करने और "कंसोल.लॉग" के बजाय मान वापस करने में सक्षम होना चाहिए (मुझे लगता है कि आप इस तरह से कुछ बाइट्स प्राप्त करेंगे)। ओह, और आपको मूल्य इनपुट करना होगा और इसे हार्डकोड नहीं करना होगा।
— यादृच्छिक लड़का
धन्यवाद। रिक्त स्थान को हटा दिया और इनपुट के पक्ष में हार्डकोड किए गए मान को हटा दिया। गिनती ११४ तक बढ़ जाती है! क्या मूल्य वापस करने का कार्य बाइट की गिनती में शामिल नहीं होगा? मुझे लगता है कि अगर ऐसा होता तो यह और लंबा हो जाता।
— user9338709
साइट पर आपका स्वागत है! ऐसा लगता है कि यह काम करता है ( इसे ऑनलाइन प्रयास करें! ), लेकिन यह एक स्निपेट प्रतीत होता है और प्रस्तुतियाँ या तो एक पूर्ण कार्यक्रम, या एक फ़ंक्शन होना चाहिए।
— डोम हेस्टिंग्स
ऐसा कुछ काम कर सकता है, लेकिन चीजों को करने के बेहतर तरीके हैं! टेम्पलेट के लिए उस पृष्ठ के शीर्ष पर लिंक मेनू की जाँच करें जिसमें बहुत सारी प्रस्तुतियाँ उपयोग होती हैं!
— डोम हेस्टिंग्स
वास्तव में, ऐसा लग रहा है कि स्थिरांक में 200 अंक नहीं हैं :( इसे ऑनलाइन आज़माएं! - इसे 197 पर लौटना चाहिए।
— डोम हेस्टिंग्स
0

PHP, 27 बाइट्स

बहुत सीरियस उत्तर नहीं, इसके लिए php.ini सेटिंग्स में pi () डिफॉल्ट के रूप में 14 अंकों में परिवर्तन की आवश्यकता होती है, 200 नहीं, लेकिन एक बार के लिए PHP समाधान काफी सुरुचिपूर्ण है:

<?=strpos(pi(),$_GET[n])-1;
— Martijn
स्रोत
मुझे नहीं लगता कि यह वास्तव में काम करेगा। precisionphp.ini केवल बदलती जाती है में टैग प्रदर्शन परिशुद्धता, और वास्तव में परिभाषित स्थिरांक की शुद्धता में वृद्धि नहीं करता। साक्षी
— प्रिमो
0

पर्ल 5 के साथ -MMath::BigFloat+bpiऔर -n, 20 बाइट्स

bpi($>)=~/.$_/;say@-

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

मुझे यकीन नहीं है कि $>स्टैंड का उपयोग कहां है, क्योंकि यह EFFECTIVE_USER_IDपोर्टेबल नहीं है, लेकिन टीआईओ पर यह 1000 है और हमारी आवश्यकता को संतुष्ट करता है, -1 बाइट बनाम 200।

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