उलटी गिनती

इस कोड-गोल्फ चुनौती के लिए आपका लक्ष्य गणना और इस बीच की संख्या को रीसायकल करना है । मुझे समझाने दो।

पहले आपका आवेदन एक नंबर पढ़ता है, या तो प्रोग्राम तर्क के रूप में या स्टड का उपयोग करके। अगला आपको बस इस तरह से गिनना होगा: 10 9 8 7 6( अवरोही क्रम में)

लेकिन रुकिए, और भी है!

पुनर्चक्रण

ऐसी परिस्थितियाँ हैं जहाँ हम हर नंबर को प्रिंट कर सकते हैं, लेकिन हर नंबर को सूचीबद्ध नहीं करते हैं, हम रीसाइक्लिंग कर सकते हैं! मुझे एक त्वरित उदाहरण दें:

Input: 110

Output:   11091081071061051041031021010099... etc
Recycled:  10                        1

हमने अभी भी सभी संख्याओं को सूचीबद्ध किया है, 110, 109, 108, लेकिन हमने एक 0 और 1 को पुनर्नवीनीकरण किया है ।

एक और उदाहरण:

Input: 9900

Output:   9900989989897989698959894... etc
Recycled:        9 98

कोड-गोल्फ चुनौती

एक संख्या पढ़ें (तर्क या स्टड)
सभी संभावित नंबरों को पुन: चक्रित करने के लिए अवरोही क्रम में उलटी गिनती (स्टडआउट या फ़ाइल में) करें
रुकें जब आप 1 या उस क्षण तक पहुँच जाते हैं जिसे आपने 0 से 9 में पुनर्नवीनीकरण किया है (जो भी पहले होता है)

सरल उदाहरण (1 तक पहुंच गया):

Input: 15
Output: 15141312110987654321

(Notice the 110 instead of 1110)

अधिक उन्नत उदाहरण (सभी पुनर्नवीनीकरण):

Input: 110
Output:   110910810710610510410310210100998979695949392919089887868584838281807978776757473727170696867665646362616059585756554535251504948474645443424140393837363534332313029282726252423221
Recycled:  10                            9                    8                    7                    6                    5                    4                    3                    2

(We've recycled all 0-9)

code-golf number

— रॉय वैन रिजन
स्रोत

1

T-SQL - 291 277 267 217 199 191 166 158 153 145 142 128 117

एक नए तरीके से संपर्क करने के बाद, मैं 145 (एक युगल मामूली चोटियों के बाद 142) तक पहुंचने में कामयाब रहा, बहुत जर्जर नहीं। इसका मतलब है कि मैं रजत या कांस्य के लिए प्रतिस्पर्धा करने में सक्षम हो सकता हूं। ^^

DECLARE @ INT=100;WITH N AS(SELECT 1A UNION ALL SELECT A+1FROM N WHERE A<@)SELECT LEFT(A,LEN(A)-1+A%11)FROM N ORDER BY-A

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

DECLARE @ INT=100;

WITH N AS
(
    SELECT 1A
    UNION ALL
    SELECT A+1
    FROM N
    WHERE A<@
)

SELECT LEFT(A,LEN(A)-1+A%11)
FROM N
ORDER BY-A

— PenutReaper
स्रोत

1

हाहा टी-एसक्यूएल, अच्छा!

— रॉय वैन रिजन

7

पायथन 143 147

def t(n):
 p=o='';r=0 # p is previous string, o is output string, r is recycled bitmap
 while n and r<1023: # 1023 is first 10 bits set, meaning all digits have been recycled
    s=`n`;i=-1 # s is the current string representation of n
       # i is from end; negative offsets count backwards in strings
    while p.endswith(s[:i])-1:i-=1 # find common ending with prev; s[:0] is '',
       # which all strings end with
    for j in s[:i]:r|=1<<int(j) # mark off recycled bits
    o+=s[i:];p=s;n-=1 # concatenate output, prepare for next number
 print o # done

पहला स्तर इंडेंट स्पेस है, दूसरा लेवल टैब चार है।

— मर्जी
स्रोत

2

कुछ मानक चार बचाता है: p=o=''फ़ंक्शन के लिए वैकल्पिक परम के रूप में चीजों को रखो ; आप उपयोग कर सकते हैं *के लिए andमें n and r<1023या शायद r<1023*n; while x-1:के रूप में एक अंतरिक्ष दाढ़ी कर सकते हैं while~-x। इसके अलावा, यह एक बिट-मास्क के बजाय अंकों का एक सेट का उपयोग करने के लिए छोटा हो सकता है जो अंकों का उपयोग किया गया है।

— 21

5

हास्केल, 154 149 147 145 128 120 119 117 बाइट्स

import Data.List
(r%x)n|n>0&&r<":"=[(r\\t)%(x++(show n\\t))$n-1|t<-tails x,isPrefixOf t$show n]!!0|0<1=x
h=['0'..]%""

रीसाइक्लिंग-चेकिंग में जोड़ने से बहुत सारे पात्रों की लागत होती है ... आह

याद करके थोड़ा सा गढ़ना कि क्या अंक अभी तक पुनर्नवीनीकरण नहीं किए गए थे और सूची खाली होने पर रोक दिया गया था। फिर स्पष्ट पुनरावृत्ति और कुछ और चालों को आगे बढ़ाते हुए थोड़ा और गोल्फ बनाया।

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

*Main> h 110
"110910810710610510410310210100998979695949392919089887868584838281807978776757473727170696867665646362616059585756554535251504948474645443424140393837363534332313029282726252423221"

— गर्वित हेकलर
स्रोत

5

अजगर 2: 119 117

इसे सामुदायिक विकि के रूप में चिह्नित करना क्योंकि यह विल के उत्तर का सिर्फ एक अधिक गोल्फ संस्करण है ।

n=input()
d=s,={''}
exec"t=`n`;i=len(t)\nwhile(s*i)[-i:]!=t[:i]:i-=1\ns+=t[i:];d|=set(t[:i]);n-=len(d)<11;"*n
print s

— फ्लॉर्नकेक
स्रोत

बहुत खुबस! कैसे d=s,={''}काम करता है ?

— विल

2

@ d=s,={''}के बराबर है d={''}; s,={''}। s,={''}अनुक्रम अनपैकिंग का उपयोग करता है, जैसे कि आमतौर पर कथनों में अधिक प्रयोग किया जाता है a, b = (b, a), लेकिन आप इसका उपयोग एकल-तत्व अनुक्रम से एकमात्र तत्व निकालने के लिए भी कर सकते हैं।

— बजे

1

@flornquake ओह, मेरी गलती। मुझे लगता है कि आप अभी भी कर सकते हैं len(d)%11*n, हालांकि ऐसा लगता है कि यह एक निष्पादन लूप का उपयोग करके आपके साथ लूट है।

— xnor

1

@Will इस चालाक चाल के लिए पृष्ठभूमि के रूप में कुशल है, यह विडंबना यह है कि set()एक एकल तत्व सेट की तुलना में एक खाली सेट बनाने के लिए लंबा है {x}। इसलिए, फ्लॉर्नकेक एक भराव सदस्य के साथ इसकी शुरुआत करता है, और यह जांचता है कि इसमें ग्यारह तत्व हैं या नहीं। चूंकि खाली स्ट्रिंग को प्रारंभिक करने की आवश्यकता है s, इसलिए इसे भरने के लिए सदस्य के रूप में सेवा करने के लिए बनाया गया है, इन इनिशियलाइज़ेशन को मिलाकर चार्ट को सहेजना है।

— xnor

1

@ हाँ, len(d)%11*nअच्छा रहा होगा। :)

— flornquake

4

रूबी, 145 139 130 बाइट्स

n=gets.to_i
d=*?0..?9
s=''
n.times{|i|j=(t=(n-i).to_s).size;j-=1 while s[-j,j]!=u=t[0,j];d-=u.chars;s=t;$><<t[j..-1];exit if[]==d}

विल के समान दृष्टिकोण, सिवाय इसके कि मैं थोड़ा सा मुखौटा का उपयोग नहीं कर रहा हूं, लेकिन इसके बजाय अप्रयुक्त अंकों का एक सेट-सरणी। इनपुट STDIN के माध्यम से है।

whileइसके बजाय एक वैकल्पिक संस्करण है , timesलेकिन जो भी मैं कोशिश करता हूं, बाइट्स की संख्या समान है:

n=gets.to_i
d=*?0..?9
s=''
(j=(t=n.to_s).size;j-=1 while s[-j,j]!=u=t[0,j];d-=u.chars;s=t;$><<t[j..-1];exit if[]==d;n-=1)while 0<n

— मार्टिन एंडर
स्रोत

3

CJam, 80 77 65 57 54 वर्ण

~~शायद बिल्कुल भी अनुकूलित नहीं है, लेकिन~~ बहुत सारे अनुकूलन और डिबगिंग के बाद CJP में मेरे ES6 उत्तर का सीधा रूपांतरण है:

Mr{s:C_,{:H<M_,H->=!_CH@-@}g:T>+:MCT<_O@-+:O,A<Ci(*}h;

इसे यहाँ ऑनलाइन आज़माएँ । फ़ंक्शन एसटीडीआईएन के रूप में संख्या लेता है और पुनर्नवीनीकरण उलटी गिनती को आउटपुट करता है, अगर रीसाइक्लिंग पूरा हो जाता है तो बीच में रुक जाता है।

मैं इसे और आगे बढ़ाने की कोशिश करूंगा।

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

मूल विचार यह है कि प्रत्येक उलटी गिनती संख्या C के लिए, जांचें कि क्या पहला H अंक परिणामी स्ट्रिंग के अंतिम H अंकों के बराबर है, जहां H, C से 0 में अंकों की संख्या से जाता है।

Mr                                    "Put an empty string and input on stack";
  { ... }h;                           "Run while top element of stack is true, pop when done";
s:C                                   "Store string value of top stack element in C"
   _,                                 "Put the number of characters in C to stack";
     { ... }g                         "Run while top element of stack is true";
:H<                                   "Store the digit iteration in H and slice C";
   M                                  "M is the final output string in making";
    _,H-                              "Take length of M and reduce H from it";
        >                             "Take that many digits of M from end and..."
         =!_                          "Compare with first H digits of C, negate and copy";
            CH@                       "Put C and H on stack and bring the above result to top of stack";
               -                      "Reduce H if the matched result was false";
                @                     "Bring the matched result on top in order continue or break the loop"
             :T                       "Store top stack element in T after the loop";
               >+:M                   "Take everything but first T digits of C and add it to M and update M";
                   CT<_               "Take first T digits of C and copy them";
                       O@             "Put saved digits on stack, and rotate top three elements";
                         -            "Remove all occurence of first T digits of C from O";
                          +:O         "Add first T digits of C to O and update O";
                             ,A<      "Compare number of saved digits with 10";
                                Ci(   "Decrement integer value of C and put it on stack";
                                   *  "If number of saved digits greater than 9, break loop";

— अनुकूलक
स्रोत

2

जावास्क्रिप्ट ईएस 6, 149 146 अक्षर

ऐसी क्रिया, ज्यादा वर्ण, वाह।

C=n=>{s=c='';while(n>0&s.length<10){j=1;while(t=(n+'').slice(0,-j++))if(c.endsWith(t)){s+=~s.search(t)?'':t;break}c+=(n--+'').slice(1-j)}return c}

इसे नवीनतम फ़ायरफ़ॉक्स के वेब कंसोल में चलाएं।

दौड़ने के बाद, यह एक विधि बनाता है Cजिसे आप उपयोग कर सकते हैं

C(12)
12110987654321

अद्यतन : कभी-कभी, सादे पुराने returnतीर समारोह बंद होने की तुलना में कम है :)

— अनुकूलक
स्रोत

इसे

— पुन: चक्रित

ओह! क्या वह ? उनके सभी उदाहरणों का भी आउटपुट था।

— अनुकूलक

@proudhaskeller ओह, मैं पुनर्नवीनीकरण चार्ट का भी उत्पादन करता हूं। धन्यवाद, कि मुझे कुछ आकर्षण बचा लेंगे।

— पेनुट्रोप

उलटी गिनती और रीसायकल