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

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

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


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

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

अब उन सूचियों में से प्रत्येक के लिए, हम इसे क्रमबद्ध करेंगे ताकि सभी पूर्णांक डिजिटल जड़ों वाले 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 (या समय की पाबंदी वाले अन्य दुभाषियों) पर यह ठीक है/strong>।
  • स्पष्टीकरण प्रोत्साहित किया जाता है।

It's , so the shortest code in each language wins! Don't be discouraged by other solutions in the language you want to golf in, even if they are shorter than what you can manage!

24
मजेदार टिप्पणी: यह अभी तक OEIS में नहीं है
जोड़ा लेखक KennyPeanuts, स्रोत

17 उत्तर

Python 2, 78 60 52 46 45 bytes

-6 बाइट्स G B । पर धन्यवाद।
Jakob के लिए -1 बाइट धन्यवाद।

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

यह ऑनलाइन कोशिश करो!

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


Python 2, 78 bytes

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

यह ऑनलाइन कोशिश करो! </एक>

16
जोड़ा
मैं एक ऐसे समाधान को देखने की उम्मीद कर रहा था जो पूरे अनुक्रम को नहीं बनाता था। बहुत बढ़िया :-)
जोड़ा लेखक David Brown, स्रोत
@sevko 78 byter था अपने मूल समाधान (कुछ ungolfed संस्करण यहाँ )। यह पहले से ही किसी भी घन जड़ों की गणना के बिना काम करता है, लेकिन क्रम से क्रम संख्या उत्पन्न करके, अनुक्रम में मैंने देखे गए नियमों के आधार पर। इस पुनरावृत्त गणना के आधार पर कोई भी गिन सकता है कि प्रत्येक अभिव्यक्ति को कितनी बार निष्पादित किया जाता है।
जोड़ा लेखक Dan Byström, स्रोत
@sevko के साथ WolframAlpha की मदद मैं एक बंद फॉर्म का निर्माण करने में सक्षम था। पहले तो बंद फॉर्म का उपयोग करने वाला कार्यक्रम बहुत लंबा था (~ 95 बाइट्स) लेकिन कुछ गोल्फिंग और WolframAlpha यह अपने वर्तमान स्वरूप में आ गया।
जोड़ा लेखक Dan Byström, स्रोत
आपने बंद फ़ॉर्म का समाधान कैसे निकाला? (संपादित करें: ऐसा लगता है कि एक स्पष्टीकरण है नॉरफ़ायर
जोड़ा लेखक sevko, स्रोत

Python 3, 80 bytes

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 (अच्छी तरह से में प्रबंधन कर सकते है, input() को Python 3 (+5 बाइट्स) में int रूपांतरण की आवश्यकता है, exec एक फ़ंक्शन है, न कि स्टेटमेंट (+2 बाइट्स) और / डिफ़ॉल्ट रूप से पूर्णांक विभाजन करता है यदि इसके तर्क Py 2 (+1 बाइट) में पूर्णांक हैं, तो यह निश्चित रूप से छोटा है अंडाशय के उत्तर को पोर्ट करने की तुलना में ।

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

सेटअप

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

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

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

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

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

  • greater than or equal to the highest power of 10 less than or equal to i
  • less than k, the smallest power of 10 greater than i

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

डिजिटल रूट द्वारा प्रत्येक chunk को सॉर्ट करना

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

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


Python 2, 72 bytes

चेज़ ब्राउन प्रस्तुत करना से प्रेरित।

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

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

4
जोड़ा

Jelly,  15 14 10  9 bytes

D,Ḣ$‘Ḍḅ9’

Try it online!

कैसे?

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

The formula exposed by ovs is: 9*(n%b) + (n/b) + b - 1 where b=10floor(log(n,10))

अब यदि c n के दशमलव अंकों की गिनती है, तो b-1 c-1 दशमलव में nines है ।
यह दशमलव में c-1 वाले के नौ गुना के बराबर है (उदा। 111 * 9 = 999 )।

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

b * 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ƊƲÞị@

Try it online!

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

4
जोड़ा

Python 2, 73 71 70 bytes

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

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

2 बाइट्स से लेकर मि। XCoder ; तथा 1 बाइट thx से H.PWiz पर।

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

4
जोड़ा
खैर, i% 9 i% 9 + 1 के बजाय पर्याप्त होना चाहिए ... इस तरह से आपने मेरे 72 byter को हराया: DD:
जोड़ा लेखक Mr. Xcoder, स्रोत
@ Mr.Xcoder: हा! आप सही हे...
जोड़ा लेखक Chas Brown, स्रोत
len (`~ i`) काम करना चाहिए
जोड़ा लेखक H.PWiz, स्रोत

Haskell, 94 88 bytes

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

Try it online! 0-indexed.

स्पष्टीकरण:

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

  • x is one less than the current number of digits and is drawn from the infinite list [0,1,2,3, ...]
  • i iterates over the range from 1 to 9 and is used for sorting by the digital roots
  • n iterates over all numbers with x+1 digits
  • until(<10)(sum.map(read.pure).show) computes the digital root (see here for an explanation)
  • n is added to the list if its digital root equals i.
3
जोड़ा

05AB1E, 19 11 bytes

पोर्ट ऑफ मेरा पायथन जवाब

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

g<��������

����nline!

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
2
जोड़ा
आपने मुझे इसके लिए हराया, एक ऐसे उत्तर पर काम कर रहा था जो आपके पायथन उत्तर का एक बंदरगाह था। ;) ®O < । यहां स्पष्टीकरण मैं इसके बारे में पोस्ट करने वाला था
जोड़ा लेखक Dale Hagglund, स्रोत
@KevinCruijssen बहुत बहुत धन्यवाद। रजिस्टर काफी उपयोगी प्रतीत होता है। मैं divmod का उपयोग करके इसे दो और बाइट्स नीचे लाने में सक्षम था।
जोड़ा लेखक Dan Byström, स्रोत

Retina, 65 bytes

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

Try it online! 1-indexed. Explanation:

.
9
.+
*
L$`
$`

10 की अगली शक्ति (अनन्य) तक 0 से <�कोड> _ </कोड> की पंक्तियों की एक सूची बनाएं

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

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

_+
$.&

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

N$`
$.&

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

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

<�कोड> n </कोड> वें तत्व निकालें।

2
जोड़ा

Pyth,  36 31 25 24 23  22 bytes

1 अनुक्रमित।

@o%tN9rFK^LThBlt`Q-QhK

Test suite!

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

@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
जोड़ा

Perl 6,  68  58 bytes

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

Test it 0-based

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

Test it 1-based

विस्तारित:

{  # 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
}
1
जोड़ा

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

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

Boring port of @ovs' Python 2 answer, so make sure to upvote him!
-1 byte thanks to @Jakob

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

1
जोड़ा

Pyth, 23 bytes

@o%tN9rF_mJ^TsdtBl`Q-QJ

Try it here.

-3 thanks to Mr. Xcoder

1 अनुक्रमित।

1
जोड़ा

K4, 38 bytes

समाधान:

-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:
1
जोड़ा
यह स्पष्ट रूप से कहा गया है कि: "कोड को सभी पूर्णांकों के लिए सैद्धांतिक रूप से 10 ^ 9 " तक काम करना चाहिए। ऐसा प्रतीत होता है कि यह नहीं है ...?
जोड़ा लेखक David Brown, स्रोत
Urgh। फिर मैं बोनस उत्तरों में से एक का उपयोग करूंगा क्योंकि मैं 10e6 तक की गणना करने की कोशिश कर रहा मेमोरी से बाहर चला जाऊंगा अकेले 10e9। बाद में ठीक कर देंगे।
जोड़ा लेखक streetster, स्रोत

Ruby, 43 38 bytes

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

Try it online!

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

1
जोड़ा

जे, 24 बाइट्स

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

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

वाक्यांश '] /:' क्रम (आरोही '/:') मूल सरणी ']' अंकों के ''/'द्वारा अभिव्यक्ति

". &> ":

converts a number to a character vector with '":', then applies its inverse '".' - character to number - applied to each '&>' item. So, 65536 -> '65536' -> 6 5 5 3 6.

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

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

0
जोड़ा
मैंने माना कि सूचियाँ बाहरी रूप से इनपुट हैं। मैं यह नहीं देखता कि सूची बनाना समस्या का हिस्सा कहां है।
जोड़ा लेखक charles Xavior, स्रोत
आप इनपुट सूची कैसे बना रहे हैं? मैं कश्मीर में एक समाधान लिख रहा हूं, लेकिन आधा उत्तर सूची उत्पन्न कर रहा है ...
जोड़ा लेखक streetster, स्रोत
" इनपुट के रूप में एक सकारात्मक पूर्णांक n लें , और ऊपर वर्णित अनुक्रम में n'th संख्या को आउटपुट करें।" आपको अनुक्रम बनाना होगा (या अनुक्रम उत्पन्न करने के लिए चारों ओर पाने का एक तरीका खोजना होगा - अन्य उत्तर देखें)।
जोड़ा लेखक streetster, स्रोत

Jelly, 19 bytes

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

ट्राफिया/a>

-1 के लिए धन्यवाद Xcoder

1 अनुक्रमित।

0
जोड़ा

Perl 5 -pF, 27 bytes

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

Try it online!

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

0
जोड़ा

Elixir, 239 bytes

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
जोड़ा