Champernowne स्थिरांक में संख्या ज्ञात करें

Question

परिचय

बेस 10 में, चम्पारण्य स्थिरांक को लगातार पूर्णांक के अभ्यावेदन द्वारा परिभाषित किया जाता है। बेस 10 में: 0.1234567891011121314151617...और इसी तरह।

आप देख सकते हैं कि दशमलव 15पर प्रारंभ की पहली उपस्थिति 20th:

  Position
  0000000001111111111222222222233333333334444444444555555555566666666
  1234567890123456789012345678901234567890123456789012345678901234567
                     ^
0.1234567891011121314151617181920212223242526272829303132333435363738...
                     ^^
                     15 = position 20

दशमलव 45पर शुरू होने की पहली उपस्थिति 4th:

  Position
  0000000001111111111222222222233333333334444444444555555555566666666
  1234567890123456789012345678901234567890123456789012345678901234567
     ^               
0.1234567891011121314151617181920212223242526272829303132333435363738...
     ^^
     45 = position 4

तो, कार्य आसान है। एक गैर-नकारात्मक पूर्णांक को देखते हुए, Champernowne स्थिरांक में पूर्णांक की स्थिति को आउटपुट करता है।

नियम

• आप एक समारोह या एक कार्यक्रम प्रदान कर सकते हैं
• यह कोड-गोल्फ है , इसलिए कम से कम बाइट्स जीत के साथ सबमिशन!

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

Input: 20
Output: 30

Input: 333
Output: 56

Input: 0
Output: 11 (note that the 0 before the decimal point is ignored)

Input: 2930
Output: 48

Comments

हमें किस सर्वोच्च पद के लिए काम करने की आवश्यकता है? उदाहरण के लिए, क्या संख्या कभी 987654321123456877654234354675 होगी।

— मॉर्गन थ्रैप

@ MorganThrapp मैं शायद रेंज में पूर्णांकों का परीक्षण करूँगा 0 <= x <= 99, लेकिन यह सैद्धांतिक रूप से पूर्णांकों से अधिक के लिए काम करना चाहिए 99।

— अदनान

आज्ञाकारी OEIS

— लीक

Answer 1

अजगर, १०

hxjkS+QT`Q

पहले input + 10नंबरों को समेटता है, फिर 0 पर आधारित इंडेक्स को पाता है .. अतिरिक्त दस को केवल 0 की जरूरत होती है।

परीक्षण सूट

Comments

मुझे लगता है कि निहित इनपुट को पहले 2015-12-17 15:01:23Zया कुछ और लागू किया गया था ?

— एरिक आउटगोल्फर

@EriktheOutgolfer इसे 2016 में जोड़ा गया था: github.com/isaacg1/pyth/commit/…

— FryAmTheEggman

Answer 2

LabVIEW, 29 LabVIEW आदिम

यह अभी के लिए तार का उपयोग करता है। यह एक पैटर्न के रूप में इनपुट से मेल खाता है और ऑफसेट को आउटपुट करता है - (इनपुट लेन -1)।

Answer 3

जावास्क्रिप्ट, 57 बाइट्स

a=prompt();for(y=b=" ";y<a+11;)b+=++y;alert(b.indexOf(a))

कॉनर ओ'ब्रायन को 1 बाइट धन्यवाद दिया।

Comments

मुझे लगता है कि आप इस y=हिस्से को स्थानांतरित कर सकते हैं y=b=" "; किसी स्थान को बढ़ाना शून्य को बढ़ाने के समान है। ( a=prompt(y=b=" ");...)

— कॉनर ओ'ब्रायन

@ C @O'Bʀɪᴇɴ अच्छा लगा।

— सुपरजेडिए २२२४

Answer 4

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

a#b|and$zipWith(==)a b=1|1<2=1+a#tail b 
(#(show=<<[1..])).show

प्रयोग उदाहरण: (#(show=<<[1..])).show $ 2930-> 48।

यह कैसे काम करता है: भीतर a # bकी स्थिति का पता लगाता है : यदि वापसी का उपसर्ग है , तो एक पुनरावर्ती कॉल के साथ जोड़ें । पॉइंटफ्री फ़ंक्शन एक (अनाम) तर्क और कॉल की अपेक्षा करता है ।abab11a # tail b(#(show=<<[1..])).shownshow n # show=<<[1..]

फ़ंक्शन subIndexभी काम करेगा #, लेकिन आवश्यक import Data.List.Utilsभुगतान नहीं करता है।

Comments

मुझे नहीं लगता कि आपको.show

— गेहूं जादूगर

और कुछ दोस्ताना प्रतियोगिता। यद्यपि दो वर्ष देर से।

— गेहूं जादूगर

Answer 5

रूबी, २,

->n{[*0..n+10]*''=~/\B#{n}/}

शुरुआत में 0 शामिल है ताकि मैच 1-अनुक्रमित हो, लेकिन \Bयह आवश्यक है कि मैच स्ट्रिंग की शुरुआत में न हो।

Answer 6

जाप, 11 बाइट्स

यह मूल रूप से अजगर की पिटाई कर रहा था, लेकिन जाहिर तौर पर यह इनपुट के लिए काम नहीं करता था 0।

1+1oU+B ¬bU

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

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

1+1oU+B ¬ bU
1+1oU+B q bU  // Implicit: U = input integer
  1oU+B       // Generate the range [0, U+11).
        q bU  // Join and take the index of U.
1+            // Add one to get the correct result.
              // Implicit: output last expression

Comments

आपका "यह कैसे काम करता है" अनुभाग में qकोड में एक है और तार्किक निषेध प्रतीक नहीं है ¬?

— घातक

@Fatalize ¬एक शॉर्टकट है q (जो कि qनिम्नलिखित स्थान के साथ है)। ऐसा लगता है कि अक्सर भ्रम की स्थिति होती है, इसलिए मैंने पूर्ण संस्करण के साथ छोटे संस्करण को पंक्तिबद्ध किया है।

— ETHproductions

Answer 7

लूआ, 54 बाइट्स

s=""for i=1,1e4 do s=s..i end print(s:find(io.read()))

नोट: वर्तमान में यह कार्यक्रम स्ट्रिंग के पहले चार की पहली घटना को प्रिंट करता है, और वह बिंदु जहां यह समाप्त होता है। यदि यह अनुमति नहीं है, तो यह कुछ और बाइट खर्च करेगा। मैं एक बोनस के लिए याचिका करना चाहूंगा क्योंकि मेरा कार्यक्रम इनपुट नंबर की पहली स्थिति और अंतिम स्थिति दोनों को प्रिंट करता है।

Comments

क्या आपका मतलब संख्या की पहली घटना के लिए सूचकांकों और अंत सूचकांकों से है? क्योंकि सैद्धांतिक रूप से संख्या अनंत समय में होगी।

— R

हाँ, पहली घटना के लिए शुरू और अंत।

— निकोलाई 97

Answer 8

MATL , 22 बाइट्स

it10+:Yst' '=~)wYsXf1)

इनपुट लें ( i), वेक्टर 1 को इनपुट + 10 ( 10+:) बनाएं , वेक्टर को स्ट्रिंग ( Ys) में कनवर्ट करें , और रिक्त स्थान को हटा दें, जो दर्दनाक है, ( t' '=~))। फिर, इनपुट को स्ट्रिंग में परिवर्तित करें ( Ys), यह ढूंढें कि इनपुट स्ट्रिंग संख्याओं के स्ट्रिंग में कहां है ( Xf) और पहले स्थान को लें ( 1))। tकी और wके ढेर (डुप्लिकेट और स्वैप, क्रमशः) से छेड़छाड़ कर रहे हैं।

Answer 9

पॉवरशेल, 39 44 बाइट्स

[संपादित करें: मेरी धारणा धारण नहीं करती है, १०३ से एक सरणी का निर्माण ० ११ जगह नहीं होता है। इसके बजाय, ०-x + १० से निर्माण के रूप में ० को संभालने के लिए, अब ४४ बाइट्स]

param($i)(1..($i+10)-join'').IndexOf("$i")+1

---

तुम हमेशा मिलेगा एक्स जब नवीनतम बिंदु पर Champernowne निरंतर की एक स्ट्रिंग के निर्माण जोड़ते एक्स अंत पर है, इसलिए से 1-x एक सरणी हमेशा उस में जवाब होगा। सवाल यह हो जाता है कि "क्या इससे कोई जल्दी होती है?" । यह कोड

param($i)(1..$i-join'').IndexOf("$i")+1

e.g.

PS C:\Temp> .\Champer.ps1 20
30

संख्या की एक संख्या उत्पन्न करता है, इसे एक स्ट्रिंग में डालता है, और इसके अंदर पैरामीटर की खोज करता है। क्योंकि PowerShell एक ऑब्जेक्ट ओरिएंटेड शेल है, पैरामीटर वास्तव में एक [int]प्रकार है, इसलिए दो वर्णों को सहेजने की कोशिश .IndexOf($i)करते हुए एक पूर्णांक के लिए स्ट्रिंग की खोज की जाएगी और कुछ भी नहीं मिलेगा। इसलिए मैं स्ट्रिंग प्रक्षेप का उपयोग करता हूं "$i"।

Comments

इसे करने का चतुर तरीका। यह .IndexOf()स्पष्ट है कि स्पष्ट रूप से -joinपारेंस और उद्धरण को मजबूर करने की तुलना में उच्च परिचालन वरीयता है । : - /

— AdmBorkBork

Answer 10

MATL (रिलीज़ 1.0.1), 22 बाइट्स

iXK10+:"@Ys]N$hKYsXf1)

उदाहरण

>> matl iXK10+:"@Ys]N$hKYsXf1)
> 333
56

व्याख्या

i       % Input
XK      % Copy to clipboard K            
10+     % Add 10. This is needed in case input is 0
:       % Vector of equally spaced values, starting from 1
"       % For each
  @Ys   %   For loop variable as a string
]       % End                            
N$h     % Horizontal concatenation of all stack contents
KYs     % Paste from clipboard K (input number) and convert to string
Xf      % Find one string within another 
1)      % First value

MATL (रिलीज़ 20.8.0), 16 बाइट्स (भाषा पोस्टडेट्स चैलेंज)

कार्यक्रम के इस संस्करण के लिए @Giuseppe को क्रेडिट (थोड़ा संशोधित)

10+:"@V]&hGVXf1)

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

व्याख्या

10+     % Implicit Input. Add 10. This is needed in case input is 0 
:       % Vector of equally spaced values, starting from 1
"       % For each
  @V    %   For loop variable as a string 
]       % End
&h      % Horizontal concatenation of all stack contents
GV      % Paste from automatic clipboard G (input number) and convert to string
Xf      % Find one string within another 
1)      % First value

Comments

मुझे नहीं लगता कि यह 0 :(

— डेविड

@ डेविड अब यह करता है। ध्यान देने के लिए धन्यवाद! इसकी कीमत केवल 3 बाइट्स :-)

— लुइस मेंडो

अब उस क्लिपबोर्ड Gमें इनपुट (और निहित इनपुट) होता है, मुझे लगता है कि इस उत्तर को काफी छोटा किया जा सकता है, और वैसे भी Ysबदलने की आवश्यकता है V; मैं 10+:"@Vv]!GVXf1)16 बाइट के लिए आया था ।

— ग्यूसेप

@Giuseppe सिर के लिए धन्यवाद! अपडेट किया गया, उचित क्रेडिट के साथ (और "भाषा पोस्टडेट्स चालान" नोट के साथ; मैं इसका बहुत बड़ा प्रशंसक नहीं हूं नए नियम )

— लुइस मेंडो

मैं उस नियम का इतना बुरा नहीं मानता ( झंडे मुझे पागल कर देते हैं, हालाँकि); मैं ज्यादातर यहाँ टिप्पणी कर रहा था क्योंकि मैंने देखा कि दुभाषिया के सबसे अद्यतित संस्करण में उपयोग Ysकरने के Vलिए बदलने की आवश्यकता थी । मैं हमेशा से प्रभावित रहा हूँ कि भाषा में कितना सुधार हुआ है!

— ग्यूसेप

Answer 11

पॉवरशेल, 54 50 बाइट्स

for($c='';!($x=$c.IndexOf("$args")+1)){$c+=++$i}$x

लूप के लिए लूप स्वैप करने के विचार के लिए TessellatingHeckler का धन्यवाद ।whilefor

एक forपाश के माध्यम से निष्पादित करता है। अन्य भाषाओं की तरह, लूप में पहला स्टेटमेंट चर और असाइनमेंट का निर्माण कर सकता है, इसलिए यह $cकेवल खाली स्ट्रिंग के बराबर से शुरू होता है, ताकि ''हमारे पास चुनौती के दशमलव अनुक्रमण के साथ स्ट्रिंग लाइनिंग का शून्य-अनुक्रमण हो। हम तब एक लूप में होते हैं जो यह जांचता है कि कहीं उसके अंदर $cइनपुट पूर्णांक ( $args) तो नहीं है (क्योंकि, यदि .IndexOf()रिटर्न -1नहीं मिला है, तो स्ट्रिंग को नहीं मिला है, हम लूप जारी रखने के लिए उसमें एक 0) ( और नहीं) जोड़ते हैं $TRUE। यदि यह नहीं पाया जाता है, तो हम अपने पूर्व-वृद्ध $iकाउंटर वेरिएबल पर जोड़ते हैं , फिर स्ट्रिंग को रीचेक करते हैं। एक बार स्ट्रिंग मिल जाने पर, .IndexOf()एक सकारात्मक मान लौटाएगा, जिसमें से नहीं होगा$FALSE, लूप से बाहर निकलना। अंत में, हम इंडेक्स के साथ आउटपुट करते हैं $x।

Comments

एक क्लासिक forलूप के लिए आदर्श ... for($c='.';($x=$c.IndexOf("$args"))-lt0;$c+=++$i){}$xऔर 1 चरित्र को बचाएं। चूंकि अधिकांश IndexOf कॉल -1 लौटेंगे, इसलिए इसे एक और बूलियन में जोड़ें! कम टेस्ट के लिए इसे कास्ट करें। लेकिन आपको ऐसा करने के लिए परिजनों की आवश्यकता है। मौजूदा पार्स के अंदर $ c और +1 खाली करें, बोनस यह छोटा है। for($c='';!($x=$c.IndexOf("$args")+1);$c+=++$i){}$x51 बाइट्स। (लेकिन मैंने अपना 39 बाइट एक अपने जवाब के रूप में पोस्ट किया क्योंकि यह पूरी तरह से अलग दृष्टिकोण है: पी)।

— TessellatingHeckler

@TessellatingHeckler लूप को फिर से लिखने का अच्छा तरीका है - धन्यवाद! मैं $cएक अर्धविराम गोल्फ के लिए पाश में संघटन ले जाया गया । अब 50 पर।

— AdmBorkBork

Answer 12

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

x=>(f=n=>n?f(n-1)+n:" ")(x+11).search(x)

पुनरावर्ती फ़ंक्शन का उपयोग करता है fलूप से बचने के का । खोज विधि के रूप में ही काम करता indexOfछोड़कर यह एक पैरामीटर है, जो इस चुनौती के लिए अप्रासंगिक है के रूप में एक रेगुलर एक्सप्रेशन लेता है।

मामले के " "लिए जोड़ना n=0(शून्य जेएस में मिथ्या है) +इसके अलावा स्ट्रिंग संयोजन करने के लिए मजबूर करता है, और शून्य-आधारित अनुक्रमण के लिए सही करता है।

Answer 13

पायथन 3, 54।

print(''.join(map(str,range(1,9**7))).find(input())+1)

Answer 14

सीजेएम, 11 बाइट्स

r_i),s\#Be|

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

मैं 1-आधारित अनुक्रमण के लिए खाते Nमें स्ट्रिंग की स्थिति का पता लगा रहा हूं 01234...N। अंत में मैं 0तार्किक या 11 के साथ आवेदन करके ठीक करता हूं ।

Answer 15

गंभीरता से, 13 बाइट्स

;≈9u+R`$`MΣí

एक पूर्णांक के रूप में इनपुट लेता है। इसमें unprintables शामिल हैं, इसलिए hexdump:

0c3bf739752b526024604de4a1

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

स्पष्टीकरण:

;≈9u+R`$`MΣí
<form feed>   push str(input)
;≈9u+R        dupe, push [1,...,input+10]
      `$`MΣ   string concatenation of list
           í  get index of input

Answer 16

S, 13 चार्ट / 22 बाइट्स

1+⩥(1,ï+ḋ)⨝ÿï

Try it here (Firefox only).

Answer 17

k4, 21 बाइट्स

{*1+(,/$1+!10+x)ss$x}

हर किसी के रूप में एक ही अहंकार - समवर्ती [1..10+x] स्ट्रिंग्स के रूप में सम्‍मिलित करें, x को स्ट्रिंग के रूप में खोजें, एक-आधारित अनुक्रमण में कनवर्ट करें, पहले हिट पर लौटें।

परीक्षण मामलों की जाँच:

  &/20 4 30 56 11 48={*1+(,/$1+!10+x)ss$x}'15 45 20 333 0 2930
1b

Answer 18

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

(If[#==0,11,m=Min@SequencePosition[s=Flatten[(K=IntegerDigits)/@Range[0,#]],K@#];Length@s[[;;m-1]]])&

Answer 19

हास्केल , 82 73 55 बाइट्स

नकल से पलायन कर गया

x!b|or$zipWith(==)x b=0
x!(_:b)=1+x!b
(!(show=<<[1..]))

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

व्याख्या

पहले हम परिभाषित करते हैं !। की पहली उपस्थिति के लिए x!btruncates । यदि यह शुरू होता है तो जाँच करके ऐसा करता है ( यदि लौटता है तो यह एक स्ट्रिंग को नीचे ले जाता है अन्यथा नहीं। तब हम अपने मुख्य कार्य को परिभाषित करते हैं। हमारा मुख्य कार्य एक बिंदु-मुक्त फ़ंक्शन है जो निरंतर लेता है ( ) और इसे पहली उपस्थिति में विभाजित करता है । यह एक स्ट्रिंग के रूप में लेता है ।bxbxor$zipWith(==)x bxshow=<<[1..]xx

Answer 20

05AB1E , 6 बाइट्स (गैर-प्रतिस्पर्धात्मक)

nLJsk>

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

Answer 21

जावास्क्रिप्ट (ईएस 6), 50 39 38 बाइट्स

x=s=``
f=n=>-~s.search(n)||f(n,s+=++x)

---

कोशिश करो

x=s=``
f=n=>-~s.search(n)||f(n,s+=++x)
o.innerText=f(i.value=15);oninput=_=>o.innerText=f(+i.value)

<input id=i type=number><pre id=o></pre>

Answer 22

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

+⁵RVw

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

Answer 23

स्टैक्स , 6 बाइट्स

⌐╛∙#»▓

इसे चलाएं और डीबग करें

Answer 24

पर्ल 6 , 26 बाइट्स

{[~](0..$_).index($_)||11}

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

तत्व की अनुक्रमणिका को 0 से उस तत्व तक श्रेणी में शामिल करता है, या 11यदि संख्या शून्य है

Answer 25

पर्ल 5 , 42 + 1 (-पी) = 43 बाइट्स

(join'',0..$_+10)=~/^(0.*?)$_/;$_=length$1

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

व्याख्या

(join'',0..$_+10)   #concatenate all of the numbers from 0 to 10 over the input
=~/^(0.*?)$_/;      #skip the first 0, then find the input
$_=length$1         #the length of the string preceding the input is the answer

Answer 26

पर्ल 6 / राकूडो 29 बाइट्स

{$_~=$++until /(.+)$^a/;$0.chars}

एक इनपुट ($ ^ ए) के साथ एक फ़ंक्शन को परिभाषित करता है। इस प्रकार कॉल करें:

say {$_~=$++until /(.+)$^a/;$0.chars}(333)
> 56

जोड़कर $, एक गुमनाम चर, incrementing $++जब तक इनपुट $^aपाया जाता है, और फिर इसे से पहले वर्ण की संख्या की गणना। .+Regex में इसके पहले कम से कम 1 char की आवश्यकता उपयोगी रूप से 0-> 0 मामले को बाहर करती है

Answer 27

जे, 30 बाइट्स

{.I.(":E.[:}.' '-.~":@i.@+&11)

शायद थोड़ा और नीचे गोल्फ हो सकता है, विशेष रूप से पहले n + 10 पूर्णांकों को समेटने में।

स्पष्टीकरण:

{.I.(":E.[:}.' '-.~":@i.@+&11)
                      i.@+&11   | Integers 0 to n+10
                   ":@          | Format list to string
             ' '-.~             | Strip spaces
           }.                   | Behead (remove leading 0)
         [:                     | Cap (previous verbs executed in order, not as a fork)
     ":E.                       | Find matches to the string n (returns a boolean vector)
  I.                            | Indexes of 1s
{.                              | Take only the first

ध्यान दें कि यह 0-अनुक्रमित है। उदाहरण:

    {.I.(":E.[:}.' '-.~":@i.@+&11) 1
0
    {.I.(":E.[:}.' '-.~":@i.@+&11) 0
10
    {.I.(":E.[:}.' '-.~":@i.@+&11) 333
55

Answer 28

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

€ΣmdNd

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

€         The 1-based index in
 Σ        the list of concatenated
   d      decimal digits
  m N     of every natural number
     d    of the decimal digits of
          the input.