कोई नहीं, कृपया!

Question

मुझे अंकों से पूरी तरह से नफरत है 1। इसलिए, मुझे संख्याओं को उनके "उचित रूपों" में बदलने के लिए आपकी सहायता की आवश्यकता है।

उचित रूप में संख्याओं में कभी दो 1एस नहीं होते हैं । 101ठीक है, लेकिन 110छिपा हुआ है।

कन्वर्ट करने के लिए, बस सभी अनुचित संख्याओं को छोड़ दें और सामान्य रूप से गिनें। उदाहरण के लिए...

1 -> 1
2 -> 2
...
10 -> 10
11 -> 12
12 -> 13
...
108 -> 109
109 -> 120
110 -> 121
111 -> 122

और इसी तरह।

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

Comments

क्या इनपुट पर कोई ऊपरी सीमा है?

— lirtosiast

मुझे 109 -> 120रूपांतरण नहीं मिला ...

— kirbyfan64sos

@ kirbyfan64sos 108 नक्शे से लेकर 109 तक, 109 अगली संख्या के लिए मैप करेगा, जो 110 है। लेकिन एक पंक्ति में दो 1 s होते हैं, इसलिए यह अगले नंबर पर जाता है जब तक कि यह एक तक नहीं पहुंचता। जो कि 120 है, क्योंकि सभी 110-119 को बाहर रखा गया है।

— रेटो कोराडी

@ कोरी ओगबर्न यह बिनैरी के बारे में नहीं है। इसे इस रूप में देखें कि जब आप सूची में प्रत्येक संख्या के लिए नंबर -11 नियम के साथ दिए गए नंबर की गणना करते हैं तो संख्याओं की एक सूची कैसी होगी

— LukStorms

@leymannx बाईं ओर की संख्या श्रृंखला में संख्या का प्रतिनिधित्व करती है। तो श्रृंखला में पहला मूल्य 1 है, श्रृंखला में दूसरा मूल्य 2 है, याद्दा यद्दा (लॉबस्टर बिस्क), श्रृंखला में दसवां मूल्य 10 है, और श्रृंखला में ग्यारहवां मूल्य 12 है, क्योंकि हमने 11 को छोड़ दिया है टेलिफ़ेक्स इसे प्रभु के लिए एक घृणा पाता है। यह विचार जारी है, इसलिए श्रृंखला में 108 वां मूल्य 109 है, और श्रृंखला में 110 वां मूल्य 120 है, क्योंकि हम 110 से 119 तक सब कुछ छोड़ देते हैं । आशा है कि मैंने पर्याप्त रूप से स्पष्ट किया है।

— आह्लाद

Answer 1

बर्लेस्क , 10 बाइट्स

{11 ~ [n!} एफओ

पुराने संस्करण:

ro{11~[n!}f[

ro{Sh"11"~=n!}f[

Comments

कृपया भाषा में एक लिंक जोड़ें :)

— mınxoma

किया हुआ। यह 2012 के आसपास रहा है, रोजेटाकोड और एसोवीकी पर भी एक लेख है।

— मरमैन

Answer 2

पर्ल 5 , 34 बाइट्स

एक काउंटर को लूप करना और कभी-कभी डबल-को बदलना।

map{$i++;$i=~s/11/12/}1..pop;say$i

परीक्षा

$ perl -M5.012 -e 'map{$i++;$i=~s/11/12/}1..pop;say$i' 111
$ 122

Answer 3

बैश + जीएनयू के बर्तन, 36

seq $1$1|grep -v 11|sed -n "$1{p;q}"

Comments

निश्चित रूप से 1$1पर्याप्त है, बजाय $1$1?

— नील

Answer 4

पायथ, 13 11 बाइट्स

e.f!}`hT`ZQ

2 बाइट्स @FryAmTheEggman की बदौलत सहेजे गए।

लाइव डेमो और परीक्षण के मामले।

13-बाइट संस्करण

e.f!}"11"+ZkQ

Comments

संदर्भ: पायथ , पायथ और पायथ ।

— पीटर मोर्टेंसन

@PeterMortensen तीसरा यहाँ इस्तेमाल किए गए Pyth से असंबंधित है - यह Pyth बनने से 8 साल पहले से है, दरअसल। Python प्रेरित भाषाओं के लिए Pyth एक लोकप्रिय नाम है।

— isaacg

Answer 5

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

n=>[...Array(n*2).keys()].filter(a=>!/11/.test(a))[n]

वैकल्पिक (समझ का उपयोग, एक ही लंबाई):

n=>[for(i of Array(n*2).keys())if(!/11/.test(i))i][n]

Comments

देखकर अच्छा लगा, लेकिन इस काम के लिए ओवरकिल। codegolf.stackexchange.com/a/61594/21348

— edc65

Answer 6

अजगर 2, 50

lambda n:[i for i in range(n*2)if'11'not in`i`][n]

एक अनाम फ़ंक्शन जो संख्याओं 11को क्रम में शामिल नहीं करता है , और nवें को लेता है । 0सूची में शामिल करने के साथ शून्य-इंडेक्सिंग रद्द की ऑफ-बाय-वन त्रुटि ।

सिद्धांत रूप में, यह पर्याप्त रूप से उच्च संख्या के लिए विफल होगा जहां f(n)>2*n, लेकिन यह तब तक नहीं होना चाहिए जब तक nकि कम से कम न हो 10**50।

---

51 बाइट्स:

n=input();i=0
while n:i+=1;n-='11'not in`i`
print i

बिना संख्याओं iके कोटा पूरा होने तक संख्याओं की गणना करता है।n11

एक फ़ंक्शन समान लंबाई है क्योंकि ऑफ-बाय-वन सुधारों की आवश्यकता है।

f=lambda n,i=0:n+1and f(n-('11'not in`i`),i+1)or~-i

Answer 7

अजगर 3 74

अभी भी थोड़ा गोल्फ की जरूरत है।

n=int(input())
c=0
for x in ' '*n:
 c+=1
 while'11'in str(c):c+=1
print(c)

यह अभी बहुत क्रूर बल है।

Answer 8

पर्ल 5, 47 बाइट्स

@_[$_]=++$i!~/11/?$i:redo for 1..<>;print$_[-1]

Answer 9

जावास्क्रिप्ट (ईएस 6) 41

एक अनाम फ़ंक्शन के रूप में

n=>eval('for(i=0;/11/.test(++i)||n--;)i')

नोट: सबसे सरल तरीका 44 होगा:

n=>{for(i=0;/11/.test(i)||n--;i++);return i}

नीचे दिए गए स्निपेट का परीक्षण करें।

f=n=>eval('for(i=0;/11/.test(++i)||n--;)i')

alert(f(+prompt('Enter number')))

Answer 10

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

([x|x<-[0..],notElem('1','1')$zip=<<tail$show x]!!)

प्रयोग उदाहरण: ([x|x<-[0..],notElem('1','1')$zip=<<tail$show x]!!) 110-> 121।

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

[x|x<-[0..]                                   ]    -- take all x starting with 0
           ,                                       -- where
                   ('1','1')                       -- the pair of two chars '1'
            notElem                                -- is not part of
                             zip=<<tail            -- the list of pairs of neighbor elements of
                                        show x     -- the string representation of x
                                               !!  -- take nth element, where n is the parameter

Answer 11

MUMPS, 37 बाइट्स

t(i) f j=1:1 s:j'[11 k=k+1 q:k=i
    q j

बहुत सीधा। यहाँ केवल "दिलचस्प" चीज निर्माण है j'[11- '["शामिल नहीं है" ऑपरेटर है, इसलिए "abc"'["ab"यह गलत है और"abc"'["cd" सच है। दोनों j'[11संख्याओं के संचालन के बावजूद , MUMPS अप्रमाणित रहता है। यह ख़ुशी से दोनों ऑपरेंड को स्ट्रिंग्स में ले जाएगा और अपने जीवन के साथ आगे बढ़ेगा। हुर्रे!

(संयोग से, यदि आप इस कार्यक्रम कभी नहीं समाप्त के साथ ठीक है, हम इस 35 बाइट्स छोटा कर सकते हैं: t2(i) f j=1:1 s:j'[11 k=k+1 w:k=i j)

Answer 12

PHP, 43 बाइट्स

while(preg_match('/11/',$i)){$i++;}print$i;

Answer 13

रूबी, 24 बाइट्स

गलत समझा, बाद में काम करेंगे!

$><<gets.gsub('11','12')

Comments

उन इनपुट पर काम नहीं करता है जिनमें शामिल नहीं हैं 11। उदाहरण के लिए, 12देना चाहिए 13, नहीं 12।

— DLosc

@ डल ओह, ओह, मैंने इस कार्य की गलत व्याख्या की है! मैं इसे बाद में काम करेंगे!

— पीटर लेनकेफी