पी के लिए एक यादृच्छिक संख्या मानचित्र

27

एक दशमलव का दोहरा सटीक प्रतिनिधित्व केवल 15 दशमलव स्थानों की सटीकता की गारंटी दे सकता है, इस प्रकार पीआई का अनुमान लगाया गया है:

3.141592653589793

आप देख सकते हैं कि अंक 3पदों में है 1, 10, 16, अंक 1पदों 2, 4आदि में है ।

चुनौती

आपका कार्य एक प्रोग्राम या फ़ंक्शन बनाना है जो 0 और 1 के बीच एक यादृच्छिक डबल नंबर बनाता है, और पीआई के मूल्य पर उस संख्या के मूल्यों को मैप करता है। आप अलग-अलग अंकों को यादृच्छिक संख्याओं में उस स्थिति में रखकर करते हैं जो कि अंक में पाई में है। यदि अंक पाई में नहीं मिला है, तो आप इसे छोड़ देंगे, और पीआई में हर अंक जो यादृच्छिक संख्या में नहीं है, एक प्रतिनिधित्व द्वारा दर्शाया जाएगा x। प्रत्येक मान केवल एक बार उपयोग किया जा सकता है, बाईं ओर से शुरू होता है।

कुछ उदाहरण शायद इसे और अधिक स्पष्ट करेंगे। निम्नलिखित उदाहरणों में, पहली संख्या पाई है, दूसरी यादृच्छिक संख्या है, और अंतिम वांछित आउटपुट है।

3.141592653589793
0.111111111111111
x.1x1xxxxxxxxxxxx

3.141592653589793
0.531000000000000
3.1xx5xxxxxxxxxxx

3.141592653589793
0.123456789123456
3.141592653x8x7xx

3.141592653589793
0.967552381459391
3.14159265358979x

नियम:

  • फ़ंक्शन को कोई इनपुट नहीं लेना चाहिए (बुलेट पॉइंट 3 में एक संभावित अपवाद समझाया गया है)
  • आउटपुट में केवल आउटपुट स्ट्रिंग शामिल होगी, एक वैकल्पिक न्यूलाइन के साथ (एक एकल अनुगामी स्थान भी स्वीकार किया जाता है)
  • यदि आपके प्रोग्राम में बिल्ट-इन Pi-value नहीं है, और / या RNG है तो आप Pi को हार्डकोड कर सकते हैं, और रैंडम नंबर को इनपुट के रूप में ले सकते हैं। आप यादृच्छिक संख्या को हार्डकोड नहीं कर सकते या इनपुट के रूप में पाई नहीं ले सकते।
  • पाई के लिए दोनों हार्डकोडेड मूल्य, और 15 यादृच्छिक अंक (आप छोड़ सकते हैं 0.क्योंकि आपको पता है कि यह 0 और 1 के बीच होगा), बाइट गिनती में शामिल किया जाएगा।
  • यदि आपकी भाषा में आवश्यक सटीकता नहीं है, तो आप निम्न प्रतिबंधों के तहत कम सटीकता का उपयोग कर सकते हैं
    • पाई के अंक आपके पास मौजूद सटीकता तक सटीक होना चाहिए
    • यदि आप सही होने की गारंटी देते हैं, तो आप अधिक मूल्यों का उत्पादन नहीं कर सकते हैं, अर्थात आप 15 अंकों का उत्पादन नहीं कर सकते हैं यदि सटीक केवल 8 सटीक दशमलव की अनुमति देता है।
    • पाई का हार्डकोड मूल्य 16 बाइट्स के रूप में गिना जाएगा (आपको दशमलव बिंदु की आवश्यकता नहीं है), भले ही आपका कार्यक्रम केवल 8 अंकों का समर्थन करता हो।
    • यादृच्छिक संख्या के लिए इनपुट मान 15 बाइट्स के रूप में गिना जाएगा (आपको इसकी आवश्यकता नहीं है 0.। ऐसा इसलिए है क्योंकि कम परिशुद्धता वाली भाषाओं में अनुचित लाभ नहीं होना चाहिए।
    • कार्यक्रम को 5 दशमलव सटीकता (कम से कम) का समर्थन करना चाहिए।
    • संपादित करें: उत्तर को मान्य करने के लिए: यादृच्छिक संख्या को किसी भी तरह प्रिंट किया जाना चाहिए, लेकिन इस ऑपरेशन को बाइट की गिनती में शामिल नहीं करना है। उदाहरण के लिए, यदि print rस्क्रिप्ट के अंत में एक सम्मिलित करना संभव है, तो वह भाग स्कोर में वृद्धि नहीं करेगा।
    • यदि आप किसी अन्य आवश्यक ऑपरेशन का हिस्सा हैं तो आप बाइट को घटा नहीं सकते। यानी अगर कोड है print pi, r, तो आप केवल घटा सकते हैं , r।
    • यदि आपको कोड में कई जगह पार्ट्स डालने हैं, तो कृपया दोनों संस्करणों को शामिल करें (एक जो यादृच्छिक संख्या को प्रिंट करता है और एक वह है जो इस तरह की टिप्पणी के साथ नहीं है: _pऔर _oNoयादृच्छिक संख्या को प्रिंट करने के लिए आवश्यक है। _pxxx और _oNoकरता है) yyy। _pऔर _oNoबाइट की गिनती में शामिल नहीं किया जाएगा।

बाइट्स में सबसे छोटा कोड जीत जाता है।

लीडरबोर्ड

इस पोस्ट के निचले हिस्से में स्टैक स्निपेट उत्तर से सूची बनाता है) क) प्रति भाषा में सबसे छोटे समाधान की सूची के रूप में और बी) एक समग्र लीडरबोर्ड के रूप में।

यह सुनिश्चित करने के लिए कि आपका उत्तर दिखाई देता है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

## Language Name, N bytes

Nआपके प्रस्तुत करने का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

## Ruby, <s>104</s> <s>101</s> 96 bytes

यदि आप अपने हेडर में कई संख्याओं को शामिल करना चाहते हैं (जैसे कि आपका स्कोर दो फ़ाइलों का योग है या आप दुभाषिया ध्वज दंड को अलग से सूचीबद्ध करना चाहते हैं), तो सुनिश्चित करें कि हेडर में वास्तविक अंक अंतिम संख्या है:

## Perl, 43 + 2 (-p flag) = 45 bytes

आप भाषा के नाम को एक लिंक भी बना सकते हैं जो बाद में स्निपेट में दिखाई देगा:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes

कोड स्निपेट दिखाएं

code-golf  string  random  pi 
— स्टीवी ग्रिफिन
स्रोत
2
यदि आप एक अंतर्निहित यादृच्छिक संख्या का उपयोग कर रहे हैं, तो क्या इसमें 15 अंक होने चाहिए या क्या यह अधिक हो सकता है? क्या यादृच्छिक संख्या के उत्पादन के लिए कोई आवश्यकताएं हैं? यदि ऐसा नहीं है तो जवाबों को मान्य करना थोड़ा कठिन है।
— user81655
आह, यह एक अच्छी बात है! यादृच्छिक संख्या में 15 से अधिक अंक हो सकते हैं। मैं एक संपादन समझाता हूँ कि यादृच्छिक संख्या के साथ क्या करना है। टिप्पणी करने के लिए धन्यवाद!
— स्टीवी ग्रिफिन
क्या यादृच्छिक " 0 और 1 के बीच " का अर्थ है 0 < random < 1या 0 <= random <= 1?
— क्रिस डेगानेन
@StewieGriffin मैं भ्रमित हूँ। क्या इसका मतलब है कि हम पीआई के 15 अंकों और 16/17 अंकों के यादृच्छिक संख्या का उपयोग कर सकते हैं?
— जकुबे
@Jakube, ईमानदार होना: मैंने प्रश्न को थोड़ा गलत पढ़ा, इस प्रकार उत्तर दिया कि इसके और अंक हो सकते हैं, इसलिए आपके प्रश्न का उत्तर हाँ है। अब उस उत्तर पर वापस जाने में बहुत देर हो गई है क्योंकि अधिकांश उत्तरों ने यादृच्छिक अंकों की संख्या को कम नहीं किया है। कृपया इसे 17 तक सीमित रखें।
— स्टीवी ग्रिफिन

जवाबों:

5

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

 u&p?}HGH\x.-GH`.n0<`O017

इसे ऑनलाइन आज़माएं: यादृच्छिक संख्या दिखाते हुए प्रदर्शन या परीक्षण

स्पष्टीकरण:

 u&p?}HGH\x.-GH`.n0<`O017  
                .n0         the constant pi
               `            convert it into a string
                     O0     random number in the range [0.0, 1.0)
                    `       convert to string
                   <   17   only use the first 17 chars (zero, point and 15 digits)
 u                          for each char H in the pi-string:
    ?}HGH\x                    if H in G (the random number string) then H else "x"
   p                           print this char without newline
  &                            and
           .-GH                remove the digit H once from G
<space>                     suppress the output (u returns the unused digits in G)
— Jakube
स्रोत
14

LabVIEW, 53 LabVIEW आदिम

मैं स्ट्रिंग्स से मेल खाता हूं और संख्या को "खाली" x.xxx स्ट्रिंग में डाल देता हूं और संख्या को पाई से हटा देता हूं ताकि यह फिर से दिखाई न दे।

यादृच्छिक संख्या और यहाँ एकल वर्ण थोड़े दिखाई देते हैं, क्या यह सही है या मुझे रिकॉर्डिंग को फिर से करना है?

— Eumel
स्रोत
यह बहुत स्पष्ट रूप से काम कर रहा है, भले ही कुछ चर देखने में थोड़ा कठिन हो, इसलिए आपको कुछ भी फिर से करने की ज़रूरत नहीं है ... अच्छा जवाब! =)
— स्टेवि ग्रिफिन
6

गणितज्ञ, 105 या 147 वर्ण

यदि यादृच्छिक संख्या " 0 और 1 के बीच " का अर्थ है 0 <= random <= 1, तो 0 और 1 शामिल हैं।

StringReplace[ToString@InputForm@N@Pi,
Thread[ToString/@Complement[Range@9,RandomInteger[{0,9},15]]->"x"]]

(105 अक्षर)

अन्यथा, मतलब के लिए यादृच्छिक संख्या " 0 और 1 के बीच " ले रहा है 0 < random < 1।

15 यादृच्छिक पूर्णांक प्राप्त करने के लिए लूप करें, सभी शून्य नहीं। 0 से 9 रेंज के पूरक का चयन करें, यानी 0 से 9 तक की संख्या यादृच्छिक सूची में नहीं। उन पूर्णांकों को स्ट्रिंग में बदलें और मिलान वर्णों को एक पीआई स्ट्रिंग में बदलें।

(147 अक्षर)

While[True,r=RandomInteger[{0,9},15];
If[Union@r!={0},Break[]]];
StringReplace[ToString@InputForm@N@Pi,
Thread[ToString/@Complement[Range@9,r]->"x"]]

3.1x15x265358x7x3

रैंडम अंक: -

FromDigits[r]

820307536180783
— क्रिस डेगनन
स्रोत
— मार्टिन एंडर
किया हुआ। लाइन ब्रेक केवल पठनीयता के लिए शामिल थे।
— क्रिस डेगन
2
अभी भी मेरे लिए 149 बाइट्स (लाइनब्रेक्स, बिना 146) के साथ आता है। वहाँ एक गोल्फ और एक ungolfed संस्करण दोनों को जोड़ने के साथ कुछ भी गलत नहीं है। कुछ गोल्फ युक्तियाँ: Trueहै 1>0, RandomIntegerइन्फ़िक्स संकेतन का उपयोग कर सकते हैं {0,9}~RandomInteger~15। आप शायद कुछ बाइट्स को rकुछ मूल्य देकर बचा सकते हैं और वास्तव में उपयोग करने की Whileबजाय स्थिति का उपयोग करके Break.फिर Forएक और बाइट बचा सकते हैं While। हालाँकि मैं यह नहीं देखता कि आपको लूप की आवश्यकता क्यों है अगर आप इसके बजाय रेंडम संख्या को रेंज में मानते हैं [0,1)।
— मार्टिन एंडर
@ मार्टिनबटनर मुझे पसंद है 1>0:-)
— क्रिस डेग्नन
मैं आमतौर पर यादृच्छिक संख्या "0 और 1 के बीच" का अर्थ 0 <यादृच्छिक <1. होगा
— क्रिस डेगानेन
5

जावास्क्रिप्ट (ईएस 6), 89 87 बाइट्स

_=>(r=[...Math.random()+""],Math.PI+"").replace(/./g,d=>(r[i=r.indexOf(d)]=_,~i?d:"x"))

व्याख्या

संपादित करें: रैंडम स्ट्रिंग को अब पोस्टर द्वारा स्पष्ट नहीं किया गया है।

पाई के प्रत्येक अंक के माध्यम से लूप्स और अंक को यादृच्छिक संख्या से हटाता है यदि यह पाया गया था, तो अंक को पाई के साथ बदल देता है x।

_=>(
    r=[...Math.random()+""],      // r = array of 15 digit random number chars
    Math.PI+"").replace(/./g,d=>( // for each digit d of pi, includes "." which is always
                                  //     in the random number
      r[i=r.indexOf(d)]=_,        // i = position of d within r, remove digit from r
                                  // "_" is the unused function argument (equals undefined)
      ~i?d:"x"                    // if found, leave the digit, else replace with x
    ))

परीक्षा

परीक्षण यादृच्छिक संख्या को भी आउटपुट करता है।

कोड स्निपेट दिखाएं

— user81655
स्रोत
यादृच्छिक नहीं हो सकता () 15 शून्य उत्पन्न करता है जिसमें 0.000 ... या 1.000 के अनुरूप होगा ...? यानी 0 और 1. के बीच नहीं
— क्रिस डेग्नन 12
@ChrisDegnen Math.random()कई रेंज का उत्पादन करता है [0,1)इसलिए यह 0कभी भी हो सकता है 1। ओपी ने विशेष रूप से यह नहीं बताया कि क्या रेंज समावेशी या विशेष थी इसलिए मैंने यह मान लिया कि जो भी उचित था वह ठीक है। यह वह सीमा भी है जिसका अन्य उत्तर उपयोग करते हैं। हालाँकि आपने मुझे अवगत कराया है कि यदि यह ठीक है तो यह 0विफल हो जाएगा क्योंकि .पी में मिलान नहीं किया जाएगा और बन जाएगा x। यह 2 में से 1 ^ 53 होने की संभावना है लेकिन मैंने इसे वैसे भी तय करने का फैसला किया।
— user81655
:-) उसके लिए क्षमा चाहता हूँ।
— क्रिस डेगन
एक यादृच्छिक डबल के लिए ठीक 0 या 1 मारने की संभावना नगण्य है, इसलिए इस चुनौती के उद्देश्य के लिए एक सीमा [0,1]ठीक है (ऐसा है (0,1))।
— स्टीवी ग्रिफिन
अच्छा लगा। मैं एक छोटे संस्करण का प्रस्ताव करता हूं।
— एमएसटी
3

CJam, 48 46 42 38 36 बाइट्स

P`'xf+1dmr`{1$f#:!1a/0=:)W+H<.%}/1f=

इसका परीक्षण यहां करें।

और यहां वह संस्करण है जो π और यादृच्छिक संख्या दोनों को प्रिंट करता है:

P_p`'xf+1dmr`_oNo{1$f#:!1a/0=:)W+H<.%}/1f=

इसका परीक्षण यहां करें।

मैं 15 दशमलव स्थानों पर यादृच्छिक संख्या को कम नहीं करता, जैसा कि ओपी ने एक टिप्पणी में स्पष्ट किया है।

व्याख्या

विचार प्रत्येक चरित्र को उस चरित्र की एक जोड़ी में a के स्ट्रिंग प्रतिनिधित्व में बदल देता है और x। यादृच्छिक संख्या में प्रत्येक वर्ण के लिए, हम पहली जोड़ी को स्वैप करते हैं जो उस वर्ण से शुरू होती है। अंत में हम प्रत्येक जोड़ी के दूसरे चरित्र का उत्पादन करते हैं।

P`      e# Get string representation of π.
'xf+    e# Append "x" to each character.
1dmr`   e# Get string representation of random number in [0,1).
{       e# For each character in that string...
  1$    e#   Copy the list of pairs.
  f#    e#   For each pair, find the index of the current character. If the character is
        e#   not in the pair, we get -1 (truthy). If it is the first character of the pair,
        e#   we get 0 (falsy). If it is the second character, we get 1 (truthy).
  :!    e#   Logical NOT for each of the results. We get a 1 for every pair we could
        e#   potentially swap.
  1a/   e#   Split around those 1s.
  0=    e#   Keep only the first chunk.
  :)    e#   Turn all the 0s into that chunk into 1s.
  W+    e#   Append a -1.
  H<    e#   Truncate to 17 elements (the number of pairs).
  .%    e#   Apply % pairwise. This reverses the element at the position of the -1.
}/
1f=     e# Select the second character from each pair.
— मार्टिन एंडर
स्रोत
2

लुआ, 231 230 बाइट्स

m,s=math,""p,r=m.pi..s,s..m.random()p=p:sub(1,#p-1)p:gsub(".",function(c)s=s..(47>c:byte()and c or"x")end)r:gsub("[^%.]",function(c)l=p:find(c)if l then p,s=p:sub(1,l-1).."x"..p:sub(l+1),s:sub(1,l-1)..c..s:sub(l+1)end end)print(s)

स्पष्टीकरण

function f()
  m,s=math,""
  p,r=m.pi..s,s..m.random()
  p=p:sub(1,#p-1)                       -- remove the last digit of math.pi

  p:gsub(".",function(c)
    s=s..(47>c:byte()and c or"x")      -- Construct a string full of "x" with a single dot
  end)

  r:gsub("[^%.]",function(c)            -- Iterate over each character but the dot in the random number
    l=p:find(c)                         -- if c isn't in pi, l=nil 
    if l                                -- which is one of the two falsy value in lua
    then
      p,s=p:sub(1,l-1).."x"..p:sub(l+1),-- If c is in pi, we replace it in p by an x
          s:sub(1,l-1)..c..s:sub(l+1)   -- and in s by its value
    end
  end)
  return s
end

अफसोस की बात है कि लू मुझे यहाँ बिल्कुल मदद नहीं करती है। math.pi ने पीआई के अंतिम अंक को वापस कर दिया:

print(math.pi)
>> 3.1415926535898

मुझे इस संख्या को कम करना है:

stringPI=""..math.pi
print(stringPI:sub(1,#stringPI-1))
>> 3.141592653589

इस चुनौती को करने के लिए दूसरा बड़ा चूक था लू का अभाव string.replace ()। जैसा कि मैं इस क्रिया का उपयोग दो बार कर s:sub(1,l-1)..c..s:sub(l+1)रहा हूं, मैं एक अनाम फ़ंक्शन करना चाहता था, यह सोचकर कि यह छोटा होगा। ऐसा नहीं है, इसलिए मैंने इसे दो बार लिखा है।

कारण है कि मुझे डॉट के बारे में सावधान रहना है, यह है कि कैसे लुआ अपनी स्थिति को लौटाता है। रीजैक्स में, डॉट का मतलब "किसी भी वर्ण" से होता है, इसलिए जब मैं .अपने पाश में वर्ण का मूल्यांकन करता हूं तो यह पहले वर्ण से मेल खाता है:

c="."  -- The value of the dot in the loop
found = stringPI:find(c)
print(stringPI)
print("location of \".\": "..found)
print("char at "..found..": "..stringPI:sub(found,found))

>> 3.141592653589
>> location of ".": 1   --Keep in mind that lua arrays are 1-based :)
>> char at 1: 3

आप लुआ को ऑनलाइन टेस्ट कर सकते हैं । जैसा कि मैं PRNG को सीड नहीं कर रहा हूं, यहां एक कोड है जो आपको अभी भी मूल्यों को देखते हुए कई परीक्षण चलाने की अनुमति देता है।

function f()m,s=math,""p,r=m.pi..s,s..m.random()print("Random number: "..r)p=p:sub(1,#p-1)p:gsub(".",function(c)s=s..(c:byte()<47 and c or"x")end)r:gsub("[^%.]",function(c)l=p:find(c)if l then p,s=p:sub(1,l-1).."x"..p:sub(l+1),s:sub(1,l-1)..c..s:sub(l+1)end end)return s end

for i=1,10
do
    print(f())
end
— Katenkyo
स्रोत
2

पायथन 2.7, 117 110 बाइट्स

import math,random
n=list(`random.random()`)
print''.join(n.pop(n.index(d))if d in n else'x'for d in`math.pi`)

नवीनतम QPython Android ऐप पर परीक्षण किया गया, लेकिन कहीं भी काम करना चाहिए।

संपादित करें 1: str(pi)backticks में बदल गया।

परीक्षण के लिए:

import math,random
n=list(`random.random()`)
print `math.pi`
print ''.join(n)
print''.join(n.pop(n.index(d))if d in n else'x'for d in`math.pi`)
— uryga
स्रोत
अच्छा जवाब! "Apostrophes SO का उपयोग कोड को चिह्नित करने के लिए" बैकटिक्स या ग्रोव प्रतीक हैं, जिस तरह से :-)
— बिल्ली
1

पायथन, 147 बाइट्स

import math as m,random as r
L=lambda t:[_ for _ in str(t)]
p=L(m.pi)
R=L(r.random())
A=""
print R #subtracted from byte count
for n in p:
    try:R.remove(n);A+=n
    except:A+='x'
print A

काफी हद तक आत्म-व्याख्यात्मक: लैंबडा फ़ंक्शन फ्लोट को सूची में परिवर्तित करता है; फिर हम यादृच्छिक सूची से प्रत्येक अंक को हटाने के प्रयास में पाई-सूची के माध्यम से लूप करते हैं। अगर हम कर सकते हैं, अच्छा, इसे उत्तर में जोड़ें; यदि नहीं, तो इसके बजाय एक 'x' जोड़ें।

— किरन हंट
स्रोत
str(t)केवल आपको सटीकता के 11 अंक देता है t, repr(t)आपको सभी t15 अंक देता है।
— नूडल
1

पर्ल, 70 बाइट्स

$_=4*atan2(1,1);s/\d/x$&/g;for$i(rand=~/\d/g){s/x$i/$i/}s/x./x/g;print

टिप्पणियों के साथ:

$_=4*atan2(1,1);        # Perl doesn't have a Pi constant
s/\d/x$&/g;             # prepend a x to all digits in Pi
for $i (rand=~/\d/g)    # iterate the digits in the random number
{ s/x$i/$i/ }           # replace first occurrence of x-nr pair 
s/x./x/g;               # strip all remaining numbers
print                   # print!

यह संस्करण pi, यादृच्छिक संख्या और परिणाम प्रिंट करेगा:

$_=$p=4*atan2(1,1);
s/\d/x$&/g;
$r=rand;
for $i ($r=~/\d/g)
{ s/x$i/$i/ }
s/x./x/g;
print "$p\n$r\n$_\n"

उदाहरण आउटपुट:

3.14159265358979
0.877757977767946
x.x4x59x6xxx897x

मुझे आशा है कि यह ठीक है:

  • पीआई में 3 सहित कुल 15 अंक हैं, इसलिए यह सटीकता से अधिक नहीं है।
  • अंतिम अंक ( 9) सटीक है।
— केनी
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.