24

सकारात्मक पूर्णांक का डिजिटल रूट (बार-बार डिजिटल योग) एक अंकों की गणना करने के लिए पिछले पुनरावृत्ति से परिणाम का उपयोग करके प्रत्येक पुनरावृत्ति पर योग अंकों की पुनरावृत्ति प्रक्रिया द्वारा प्राप्त (एकल अंक) मूल्य है। एक-अंकों की संख्या तक पहुंचने तक प्रक्रिया जारी रहती है।

उदाहरण के लिए, 65536 का डिजिटल रूट 7 है , क्योंकि 6 + 5 + 5 + 3 + 6 = 25 और 2 + 5 = 7 ।

सभी डिजिटल जड़ों को छांटना ज्यादा मायने नहीं रखता है, क्योंकि यह सिर्फ असीम रूप से कई 1 एस के साथ शुरू होगा ।

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

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

अंत में हम इन सूचियों को एक एकल अनुक्रम में बदल देंगे। यह क्रम सभी एकल अंकों की संख्या के साथ शुरू होगा, फिर सभी दोहरे अंकों की संख्या (उनके डिजिटल रूट द्वारा क्रमबद्ध), फिर सभी ट्रिपल अंकों की संख्या और इसी तरह।

चुनौती:

इनपुट के रूप में एक सकारात्मक पूर्णांक n लें , और ऊपर वर्णित अनुक्रम में n 'वें नंबर को आउटपुट करें । आप चुन सकते हैं, तो सूची है 0 की -indexed 1 -indexed।

अनुक्रम इस प्रकार है:

1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 19, 28, 37, 46, 55, 64, 73, 82, 91, 11, 20, 29 ... 
72, 81, 90, 99, 100, 109, 118, ... 
981, 990, 999, 1000, 1009, 1018, 1027, ...

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

परीक्षण के मामले 1-अनुक्रमित हैं।

   n   f(n)  
   9      9
  10     10
  11     19
  40     13
  41     22
  42     31
  43     40
  44     49
  45     58
 600    105
 601    114
 602    123
 603    132
 604    141
 605    150
4050   1453
4051   1462
4052   1471
4053   1480
4054   1489
4055   1498

कॉपी करने में आसान:

n =    9, 10, 11, 40, 41, 42, 43, 44, 45, 600, 601, 602, 603, 604, 605, 4050, 4051, 4052, 4053, 4054, 4055, 
f(n) = 9, 10, 19, 13, 22, 31, 40, 49, 58, 105, 114, 123, 132, 141, 150, 1453, 1462, 1471, 1480, 1489, 1498

स्पष्टीकरण:

आप सभी n प्रथम तत्वों का उत्पादन नहीं कर सकते हैं। आप केवल n का उत्पादन करेंगे ।
कोड को सैद्धांतिक रूप से 10 ^ 9 तक सभी पूर्णांकों के लिए काम करना चाहिए , लेकिन यह ठीक है अगर यह 999 से अधिक के इनपुट के लिए TIO (या समय प्रतिबंधों के साथ अन्य दुभाषियों) पर निकलता है ।
स्पष्टीकरण को प्रोत्साहित किया जाता है।

यह कोड-गोल्फ है , इसलिए प्रत्येक भाषा में सबसे छोटा कोड जीतता है! जिस भाषा में आप गोल्फ करना चाहते हैं, उसमें अन्य समाधानों से हतोत्साहित न हों, भले ही वे आपके द्वारा प्रबंधित किए जाने की तुलना में कम हों!

— स्टीवी ग्रिफिन
स्रोत

2

मज़ा ध्यान दें: इस है नहीं OEIS में अभी तक

— apnorton

16

पायथन 2 , _{78 60 52 46} 45 बाइट्स

-6 बाइट्स जीबी के लिए धन्यवाद ।
-1 बाइट जैकब की बदौलत ।

n=input()
b=10**~-len(`n`)
print~-b+n/b+n%b*9

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

अंत में एक बंद रूप में पहुंच गया, 1-अनुक्रमित।

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

0 अनुक्रमित।

d=10;k=1
exec'\nk+=9\nif k>d+7:k=d;d*=10\nif k>=d:k-=d/10*9-1'*input()
print k

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

— OVS
स्रोत

2

मैं एक ऐसे समाधान को देखने की उम्मीद कर रहा था जो पूरे अनुक्रम को नहीं बनाए। अच्छी तरह से किया :-)

— स्टीवी ग्रिफिन

आपने बंद फ़ॉर्म का समाधान कैसे निकाला? (संपादित करें: ऐसा लगता है कि विकिपीडिया पर एक स्पष्टीकरण है )

— सेवको

@ सेवोको 78-बायटर मेरा मूल समाधान था ( यहाँ कुछ असम्बद्ध संस्करण )। यह पहले से ही किसी भी घन जड़ों की गणना के बिना काम करता है, बल्कि क्रम से क्रम संख्या उत्पन्न करके, नियमों के अनुसार जो मैंने अनुक्रम में देखा था। इस पुनरावृत्त गणनाओं के आधार पर, कोई भी गिन सकता है कि प्रत्येक अभिव्यक्ति को कितनी बार निष्पादित किया जाता है।

— ओवंस

@ सवेको वोल्फ्रामआल्फा I की मदद से एक बंद रूप का निर्माण करने में सक्षम था। पहले तो बंद फॉर्म का उपयोग करने वाला कार्यक्रम बहुत लंबा था (~ 95 बाइट्स) लेकिन कुछ गोल्फिंग और वोल्फग्रामएल्फा के साथ यह अपने वर्तमान स्वरूप में आ गया।

— ओवंस

4

पायथन 3 , 80 बाइट्स

f=lambda i,k=1:k>i and sorted(range(k//10,k),key=lambda n:n%-9)[i-k]or f(i,k*10)

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

1 अनुक्रमित। यह सबसे अच्छा है जिसे मैं पायथन 3 में प्रबंधित कर सकता हूं (ठीक है, 78-बायटर को छोड़कर , जो नीचे मेरे पायथन 2 समाधान का एक बंदरगाह है; मुझे लगता है कि यह बहुत कूलर है, हालांकि)। पायथन 2 पूर्ण कार्यक्रमों को इस विशेष चुनौती के लिए अधिकृत किया जाता है, क्योंकि पाइथन 3 (+5 बाइट्स) में input()रूपांतरण की आवश्यकता होती है int, execयह एक फ़ंक्शन है, बजाय एक बयान (+2 बाइट्स) और /डिफ़ॉल्ट रूप से पूर्णांक विभाजन करता है यदि इसके तर्क पूर्णांक में होते हैं। Py 2 (+1 बाइट), इसलिए यह निश्चित रूप से ovs के उत्तर को पोर्ट करने से कम है ।

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

सेट अप

f=lambda i,k=1:k>i and ... or f(i,k*10)

यह एक पुनरावर्ती फ़ंक्शन f को परिभाषित करता है जो एक पूर्णांक तर्क i और दूसरा एक, k लेता है , जो 1 को चूकता है । जबकि k , i , फ़ंक्शन f रिटर्न f (i, 10k) , k को हर बार 10 से गुणा करता है जब तक कि मैं इससे अधिक नहीं हो जाता ।

लक्ष्य सीमा और सही अनुक्रमण

...range(k//10,k)...[i-k]

ऑपरेशन के इस सेट के बाद, हम i , प्रारंभिक इनपुट और वैरिएबल k के साथ बचे हैं , जो i से 10 सबसे छोटी शक्ति का प्रतिनिधित्व करता है । इस तरह, हम (पूर्णांक) श्रेणी [तल (k / 10), k) को उत्पन्न करने में सक्षम हैं , जिसमें मूल रूप से सभी पूर्णांक शामिल हैं:

से अधिक या की सर्वोच्च शक्ति के बराबर 10 से कम या बराबर मैं
k से कम , i से 10 सबसे छोटी शक्ति

चूँकि हम x = तल (k / 10) से छोटे पूर्णांकों की अवहेलना करते हैं , इसलिए हमें अनुक्रमण को शिफ्ट करना होगा ताकि हम लापता संख्याओं का लेखा-जोखा रखें। स्पष्ट तरीका यह है कि उनकी गिनती, x , i से घटाया जाए, ताकि हम सूची में सूचीबद्ध हो (छँटाई के बाद, जो नीचे वर्णित है), इसलिए ix है । हालाँकि, सूची में 9k / 10 , आइटम शामिल हैं, और कुछ सकारात्मक y के लिए सूचकांक -y में सूची में पायथन में अंत से y ^वें तत्व की पैदावार होती है , यह बस ik के साथ अनुक्रमण के बराबर है , इसलिए 4 बाइट्स बचा रहा है।

प्रत्येक छंटाई हिस्सा डिजिटल जड़ से

sorted(...,key=lambda n:n%-9)

डिजिटल रूट फ़ंक्शन के लिए सूत्र 1 + ((n-1) mod 9) है ( इस विकिपीडिया लेख के Congruence सूत्र अनुभाग देखें )। जैसा कि 1 इस तरह से उनमें से प्रत्येक में जोड़ा जाएगा, यह छँटाई करते समय बहुत अधिक होता है, इसलिए हमें 9 (n-1) mod 9 के साथ छोड़ दिया जाता है । जिस तरह %से RHS पर नकारात्मक नंबर दिए जाने पर पायथन का ऑपरेटर काम करता है, वह बहुत सुविधाजनक है, क्योंकि हम अभी तक ather बाइट को बचाने के लिए n pymod -9 का उपयोग कर सकते हैं ।

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

चास ब्राउन की अधीनता से प्रेरित ।

lambda i:sorted(range(1,10**len(`i`)),key=lambda n:(len(`n`),n%-9))[i-1]

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

— मिस्टर एक्सकोडर
स्रोत

4

पायथन 2 , 73 71 70 बाइट्स

lambda n:sorted(range(10**len(`n`)),key=lambda i:(len(`~i`),i%9))[n]+1

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

मिस्टर XCoder को 2 बाइट्स xx ; और 1 बाइट thx से H.PWiz ।

यह 0-अनुक्रमित है।

— चास ब्राउन
स्रोत

ठीक है, i%9इसके बजाय पर्याप्त होना चाहिए i%9+1... इस तरह से आपने मेरे 72

— बीटर

@ Mr.Xcoder: हा! यू आर राइट ...

— चास ब्राउन

len(`~i`)काम करना चाहिए

— H.PWiz

4

जेली , 15 14 10 9 बाइट्स

D,Ḣ$‘Ḍḅ9’

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

कैसे?

उनके Python उत्तर में ovs द्वारा बनाए गए बंद-रूप समाधान के एक गोल्फ संस्करण का उपयोग करता है ...

Ovs द्वारा उजागर सूत्र है: 9 * (n% b) + (n / b) + b - 1 जहां b = 10 ^{मंजिल (लॉग (n, 10))}

अब अगर ग दशमलव अंक की गणना है की n तो बी 1 है सी -1 दशमलव में नौ।
यह दशमलव (जैसे ) में सी -1 वाले लोगों के मूल्य के नौ गुना के बराबर है 111*9=999।

इसके अलावा n / b के अग्रणी अंकों है n और n% ख है एक दशमलव संख्या के रूप में अंक के बाकी।

बेस * x + y जैसे सूत्र [x,y]को आधार b से रूपांतरण के रूप में लागू किया जा सकता है
(यानी b ^ 1 * x + b ^ 0 * y = b * x + y )

जैसे कि हम एक संख्या, n (उदाहरण के लिए 7045) ले सकते हैं , इसे अग्रणी और अनुगामी अंकों में विभाजित कर सकते हैं, अंत में अग्रणी अंक रखते हुए ( [[0,4,5],7]), पहले आइटम के सभी अंकों में से एक को जोड़ने के लिए जोड़ सकते हैं b-1 ( [[1,5,6],7]) इन्हें दशमलव सूचियों से पूर्णांक ( [156,7]) में परिवर्तित करते हैं, और आधार नौ ( 1411) से परिवर्तित करते हैं ।

नीचे दिए गए कार्यान्वयन में हम दोनों आइटमों के सभी अंकों में से एक को जोड़ते हैं जब b-1 ( [[0,4,5],8]) के लिए खानपान , दशमलव सूचियों से पूर्णांक ( [156,8]) में परिवर्तित, आधार नौ ( 1412) से परिवर्तित करें और फिर जोड़े गए इस प्रक्रिया को घटाएं ( 1411)।

D,Ḣ$‘Ḍḅ9’ - Link: positive integer, n    e.g. 4091
D         - to base ten                       [4, 0, 9, 1]
   $      - last two links as a monad:
  Ḣ       -   head (modifies the list too)    4
 ,        -   pair (the modified list) with   [[0, 9, 1], 4]
    ‘     - increment (vectorises)            [[1, 10, 2], 5]
     Ḍ    - from base ten (vectorises)        [202, 5] (since 1*10^2+10*10^1+2*10^0 = 100+100+2 = 202)  
      ḅ9  - convert from base 9               1823 (since 202*9^1 + 5*9^0 = 202*9 + 6*9 = 1818 + 5 = 1823)
        ’ - decrement                         1822

पिछला, 14 बाइट:

æċ⁵DL,’%9ƊƲÞị@

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

यह एक इनपुट के ऊपर 10 की अगली शक्ति तक इन प्राकृतिक संख्याओं [digitalRoot, digitCount]को छाँटकर सूची बनाता है, तब तक इनपुट किए गए इंडेक्स पर मान पाता है।

— जोनाथन एलन
स्रोत

3

हास्केल , 94 88 बाइट्स

([n|x<-[0..],i<-[1..9],n<-[10^x..10^(x+1)-1],until(<10)(sum.map(read.pure).show)n==i]!!)

इसे ऑनलाइन आज़माएं! 0 अनुक्रमित।

स्पष्टीकरण:

सूची समझ अनुक्रम को अनंत सूची के रूप में उत्पन्न करती है, जिसमें हम !!निम्न सूची बनाते हैं :

x अंकों की वर्तमान संख्या से कम है और अनंत सूची से निकाला गया है [0,1,2,3, ...]
iडिजिटल जड़ों द्वारा सॉर्ट 1करने के लिए 9और से रेंज पर iterates
nx+1अंकों के साथ सभी संख्याओं पर पुनरावृत्ति
until(<10)(sum.map(read.pure).show)डिजिटल रूट की गणना करता है ( स्पष्टीकरण के लिए यहां देखें )
nसूची में जोड़ा जाता है यदि इसका डिजिटल रूट बराबर है i।

— Laikoni
स्रोत

2

रेटिना , 65 बाइट्स

.
9
.+
*
L$`
$`
O$`_(_{9})*(_*)
$2
_+
$.&
N$`
$.&
"$+L`^|\d+"^~G`

इसे ऑनलाइन आज़माएं! 1 अनुक्रमित। स्पष्टीकरण:

.
9
.+
*
L$`
$`

_10 की अगली शक्ति (अनन्य) तक 0 से s की पंक्तियों की एक सूची बनाएँ ।

O$`_(_{9})*(_*)
$2

डिजिटल रूट के क्रम में उन सभी को क्रमबद्ध करें।

_+
$.&

यूनिरी से दशमलव में परिवर्तित करें।

N$`
$.&

लंबाई के क्रम में उन्हें क्रमबद्ध करें।

"$+L`^|\d+"^~G`

nवें तत्व को निकालें ।

— नील
स्रोत

2

पायथ , 36 31 25 24 23 22 बाइट्स

1 अनुक्रमित।

@o%tN9rFK^LThBlt`Q-QhK

परीक्षण सूट!

यह कैसे काम करता है (पुराना)

@smo%tN9dcU^TKhs.lQT^LTSK – Full program. Q = input.
             Khs.lQT      – Take floor(log10(Q))+1 and store it in K.
          U^T             – Generate [0 ... T^K).
         c                – Cut at locations...
                    ^LTSK – Of the powers of 10 less than K.
  m     d                 – Map over those.
   o  N                   – Sort them by...
    %t 9                  – Themselves decremented, modulo 9.
@s                        – Flatten the result and retrieve the Q'th entry.

— मिस्टर एक्सकोडर
स्रोत

2

05AB1E , 19 11 बाइट्स

मेरे पायथन जवाब का पोर्ट ।

-6 बाइट्स (!) केविन क्रूज़सेन के लिए धन्यवाद ।

g<°©‰`9*®O<

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

Code           Explanation            Stack
               implicit input         [n]
g              length                 [len(n)]
 <             decrement              [len(n)-1]
  °            10 ** a                [10**(len(n) - 1)]
   ©           store value            [10**(len(n) - 1)]
    ‰          divmod                 [[n // 10**(len(n) - 1), n % 10**(len(n) - 1)]]
     `         push items to stack    [n // 10**(len(n) - 1), n % 10**(len(n) - 1)]
      9*       multiply by 9          [n // 10**(len(n) - 1), n % 10**(len(n) - 1) * 9]
        ®      retrieve value         [n // 10**(len(n) - 1), n % 10**(len(n) - 1) * 9, 10**(len(n) - 1)]
         O     sum the stack          [n // 10**(len(n) - 1) + n % 10**(len(n) - 1) * 9 + 10**(len(n) - 1)]
          <    decrement              [n // 10**(len(n) - 1) + n % 10**(len(n) - 1) * 9 + 10**(len(n) - 1) - 1]
               implicit output

— OVS
स्रोत

आपने मुझे इसके लिए हराया, एक ऐसे उत्तर पर काम कर रहा था जो आपके पायथन उत्तर का एक बंदरगाह था। ;) 13 बाइट्सg<°©÷¹®%9*®O< :। यहाँ स्पष्टीकरण मैं इसके बारे में पोस्ट करने वाला था ।

— केविन क्रूज़सेन

1

@KevinCruijssen बहुत बहुत धन्यवाद। रजिस्टर काफी उपयोगी प्रतीत होता है। मैं divmod का उपयोग करके इसे दो और बाइट्स नीचे लाने में सक्षम था।

— OVS

1

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

@o%tN9rF_mJ^TsdtBl`Q-QJ

इसे यहाँ आज़माएँ।

-3 श्री एक्सकोडर का धन्यवाद

1 अनुक्रमित।

— आउटगोल्फर को एरिक करें
स्रोत

1

पर्ल 6 , 68 58 बाइट्स

{({|(10**$++..^10**++$).sort({({.comb.sum}…*==*).tail})}…*)[$_]}

इसका परीक्षण 0-आधारित करें

{sort({.chars,({.comb.sum}…*==*).tail},^10**.chars)[$_]}

इसका परीक्षण 1-आधारित करें

विस्तारित:

{  # bare block lambda with implicit parameter $_

  sort(
    {
      .chars,         # sort by the length first

      (  # generate sequence to find digital sum

        { .comb.sum } # one round of digital sum
        … * == *      # stop when the digital sum matches itself (1..9)

      ).tail          # get the last value
    },

    ^                 # Range up to (and excluding)
      10 ** .chars    # the next power of 10

  )[ $_ ] # index into the sequence
}

— ब्रैड गिल्बर्ट b2gills
स्रोत

1

रूबी , 43 38 बाइट्स

->x{9*(x%b=10**~-x.to_s.size)+x/b+b-1}

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

मूल रूप से अंडाशय द्वारा उत्कृष्ट पायथन उत्तर का एक बंदरगाह, फिर कुछ और सरल किया गया।

— जीबी
स्रोत

1

जावा 8, 68 बाइट्स

n->{int b=(int)Math.pow(10,(n+"").length()-1);return~-b+n/b+n%b*9;}

@Ovs 'पायथन 2 उत्तर का बोरिंग पोर्ट , इसलिए उसे उभारना सुनिश्चित करें!
-1 बाइट के लिए धन्यवाद @ जकोब

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

— केविन क्रूज़सेन
स्रोत

1

K4 , 38 बाइट्स

समाधान:

-1+9/:10/:'(0;c-1)_1_(1+c:#x)#x:1+10\:

उदाहरण:

q)k)-1+9/:10/:'(0;c-1)_1_(1+c:#x)#x:1+10\:40
13
q)k)-1+9/:10/:'(0;c-1)_1_(1+c:#x)#x:1+10\:601
114
q)k)-1+9/:10/:'(0;c-1)_1_(1+c:#x)#x:1+10\:4051
1462

स्पष्टीकरण:

पोर्ट ऑफ जोनाथन एलन के समाधान के रूप में मैं 1 से 1e9 तक डिजिटल जड़ों के निर्माण की स्मृति से बाहर चलाता हूं।

-1+9/:10/:'(0;c-1)_1_(1+c:#x)#x:1+10\: / the solution
                                  10\: / convert to base 10
                                1+     / add 1
                              x:       / save as x
                             #         / take from x
                     (      )          / do together
                          #x           / count x
                        c:             / save as c
                      1+               / add 1
                   1_                  / drop the first
                  _                    / cut at these indices
           ( ;   )                     / 2-item list
              c-1                      / length - 1
            0                          / .. zero
      10/:'                            / convert each from base 10
   9/:                                 / convert from base 9
-1+                                    / subtract 1

बोनस:

अण्डों के घोल का अनुवाद सरल लेकिन लंबा है:

-1+b+/1 9*(_%;.q.mod).\:x,b:10 xexp#1_$x:

— streetster
स्रोत

यह स्पष्ट रूप से कहा गया है कि: "कोड को सैद्धांतिक रूप से 10 ^ 9 तक सभी पूर्णांकों के लिए काम करना चाहिए " । ऐसा प्रतीत होता है कि यह नहीं है ...?

— स्टीवी ग्रिफिन

Urgh। फिर मैं बोनस उत्तरों में से एक का उपयोग करूंगा क्योंकि मैं 10e6 तक की गणना करने की कोशिश कर रहा मेमोरी से बाहर चला जाऊंगा अकेले 10e9। बाद में ठीक कर देंगे।

— स्ट्रीट

0

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

æḟ©ræċɗ⁵Ṗ%Þ-9⁸‘_®¤ị

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

-1 श्री एक्सकोडर का धन्यवाद ।

1 अनुक्रमित।

— आउटगोल्फर को एरिक करें
स्रोत

0

जे, 24 बाइट्स

(]/:([:+/[:".&>":)^:_"0)

इस मौन अभिव्यक्ति को यह बताने के लिए कि इसे किसी भी निम्न अभिव्यक्ति (तर्कों की तरह) के हिस्से के बजाय अपने आप पर व्यवहार किया जाना चाहिए, पराग में लिपटा हुआ है।

वाक्यांश '] /:' के क्रम (आरोही '/:') मूल सरणी ']' अंकों के '' / 'के आधार पर।

". &> ":

किसी संख्या को वर्ण वेक्टर में '': '' के साथ परिवर्तित करता है, फिर उसका व्युत्क्रम '' '' लागू करता है। - संख्या के लिए वर्ण - प्रत्येक 'और>' आइटम पर लागू होता है। तो, 65536 -> '65536' -> 6 5 5 3 6।

अभिव्यक्ति के अंत के पास '^:' पावर कोड को लागू करता है जिसे हमने अभी (बाईं तरफ) समझाया है। इस स्थिति में, कई बार निर्दिष्ट संख्या अनंत '_' होती है, जिसका अर्थ है कि परिणाम बदलते रहने तक आवेदन जारी रखना।

अंतिम '' 0 '' का अर्थ है बाईं ओर की पूरी अभिव्यक्ति को प्रत्येक स्केलर (0-आयामी) आइटम पर दाईं ओर लागू करना, जो कि उन संख्याओं का सरणी होगा, जिन्हें हम इसे लागू करना चाहते हैं।

— DevonMcC
स्रोत

आप इनपुट सूची कैसे बना रहे हैं? मैं कश्मीर में एक समाधान लिख रहा हूं, लेकिन आधा उत्तर सूची तैयार कर रहा है ...

— स्ट्रीटस्टर

मैंने माना कि सूचियाँ बाहरी रूप से इनपुट हैं। मैं यह नहीं देखता कि सूची बनाना समस्या का हिस्सा कहां है।

— DevonMcC

" इनपुट के रूप में एक सकारात्मक पूर्णांक n लें , और ऊपर वर्णित अनुक्रम में n'th संख्या को आउटपुट करें।" आपको अनुक्रम बनाना होगा (या अनुक्रम उत्पन्न करने के चारों ओर पाने का एक तरीका खोजना होगा - अन्य उत्तर देखें)।

— स्ट्रीटस्टर

0

अमृत , 239 बाइट्स

q=:math
e=Enum
r=fn x,f->cond do
x<10->x
1->f.(e.sum(Integer.digits x),f)end end
fn p->e.at(e.at(Stream.unfold({0,[0]},fn {a,c}->{c,{a+1,c++e.sort(trunc(q.pow 10,a)..trunc(q.pow 10,a+1)-1,&r.(&1,r)<=r.(&2,r))}}end),1+trunc q.log10 p),p)end

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

स्पष्टीकरण आने वाली (धीरे)! मुझे नहीं लगता कि यह इससे ज्यादा छोटा हो सकता है, लेकिन मैं हमेशा सुझाव के लिए खुला हूं

— डेव
स्रोत

0

पर्ल 5 `-pF` , 27 बाइट्स

$_=9x$#F+$_%10**$#F*9+$F[0]

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

@ Ovs के सूत्र और @ JonathanAllen के स्पष्टीकरण का उपयोग कोड के एक अच्छे कॉम्पैक्ट टुकड़े के साथ करने के लिए करता है।

— Xcali
स्रोत

इंटेगर अपनी डिजिटल जड़ों द्वारा छांटे गए

चुनौती:

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

स्पष्टीकरण:

पायथन 2 , 78 60 52 46 45 बाइट्स

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

पायथन 3 , 80 बाइट्स

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

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

पायथन 2 , 73 71 70 बाइट्स

जेली , 15 14 10 9 बाइट्स

कैसे?

हास्केल , 94 88 बाइट्स

रेटिना , 65 बाइट्स

पायथ , 36 31 25 24 23 22 बाइट्स

यह कैसे काम करता है (पुराना)

05AB1E , 19 11 बाइट्स

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

पर्ल 6 , 68 58 बाइट्स

विस्तारित:

रूबी , 43 38 बाइट्स

जावा 8, 68 बाइट्स

K4 , 38 बाइट्स

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

जे, 24 बाइट्स

अमृत , 239 बाइट्स

पर्ल 5 -pF , 27 बाइट्स

पायथन 2 , _{78 60 52 46} 45 बाइट्स

पर्ल 5 `-pF` , 27 बाइट्स