मिनिमल पावर रूट

Question

संख्या n की न्यूनतम शक्ति पुनरावृत्ति निम्नानुसार परिभाषित की गई है:$n$

$$\text{MPI}(n):=n^{\text{min}(\text{digits}(n))}$$

अर्थात्, में सबसे कम अंक तक उठाया गया । उदाहरण के लिए, और ।$n$$n$$\text{MPI}(32)=32^2=1024$$\text{MPI}(1234)=1234^1=1234$

किसी संख्या की न्यूनतम पावर रूट को एक निश्चित बिंदु पाए जाने तक बार-बार लागू होने वाले से प्राप्त संख्या के रूप में परिभाषित किया गया है। यहां 1 और 25 के बीच संख्याओं की न्यूनतम बिजली जड़ों की एक तालिका है:$n$$\text{MPI}$

   n              MPR(n)
--------------------------
   1                   1
   2                   1
   3              531441
   4                   1
   5                3125
   6 4738381338321616896
   7                   1
   8            16777216
   9                   1
  10                   1
  11                  11
  12                  12
  13                  13
  14                  14
  15                  15
  16                  16
  17                  17
  18                  18
  19                  19
  20                   1
  21                  21
  22                   1
  23              279841
  24                   1
  25                   1

चुनौती: उन संख्याओं को उत्पन्न करें जिनकी न्यूनतम शक्ति 1 या उसके बराबर नहीं है।

इस क्रम में पहले 50 नंबर इस प्रकार हैं:

3, 5, 6, 8, 23, 26, 27, 29, 35, 36, 39, 42, 47, 53, 59, 64, 72, 76, 78, 82, 83, 84, 92, 222, 223, 227, 228, 229, 233, 237, 239, 254, 263, 267, 268, 269, 273, 276, 277, 278, 279, 285, 286, 287, 289, 299, 296, 335, 338, 339, 342, 342

नियम

• आप nइस क्रम की पहली संख्या (0- या 1-अनुक्रमित) उत्पन्न कर सकते हैं, nवें शब्द को उत्पन्न कर सकते हैं , एक जनरेटर बना सकते हैं जो इन शर्तों की गणना करता है, आउटपुट असीम रूप से उनमें से कई, आदि।
• आप इनपुट ले सकते हैं और किसी भी बेस में आउटपुट दे सकते हैं, लेकिन MPR के लिए गणना बेस 10 में होनी चाहिए। जैसे, आप इनपुट ले सकते हैं ###(unary में) और आउटपुट ### ##### ######(unary में)
• आपको नंबर देने चाहिए । आप (जैसे) आउटपुट नहीं कर सकते "3", "5", "6", क्योंकि वे तार हैं। 3, 5, 6और 3 5 6दोनों मान्य हैं, लेकिन। आउटपुट 2 3, "23"या twenty-threeसभी को संख्या का अमान्य प्रतिनिधित्व माना जाता है 23। (फिर, आप इन नंबरों का प्रतिनिधित्व करने के लिए किसी भी आधार का उपयोग कर सकते हैं।)
• यह एक कोड-गोल्फ है , इसलिए सबसे छोटा कोड (बाइट्स में) जीतता है।

Comments

बस जिज्ञासु, आप यह कैसे साबित कर सकते हैं कि एक निश्चित बिंदु अंततः सभी n के लिए पाया जाता है?

— nwellnhof

@nwellnhof (रफ प्रूफ।) मान लीजिए कि का कोई निश्चित बिंदु नहीं है , अर्थात, MPR ( x ) मौजूद नहीं है। चलो एक्स मैं हो मैं के मई के यात्रा एमपीआई से अधिक समारोह एक्स । यह क्रम सख्ती से बढ़ रही है, के बाद से एक ख > एक ख ग सभी के लिए एक , ख , ग ≥ 2 । कड़ाई से बढ़ने के कारण x i में 0 या 1 में कोई अंक नहीं होने की संभावना 0 की ओर जाती है जैसे x मैं ∞ की ओर जाता है ।$x$$\text{MPR}(x)$$x_i$$i$$\text{MPI}$$x$$a^b>a^{b^c}$$a,b,c\ge2$$x_i$$x_i$$\infty$

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

हुह। Oeis में यह क्रम नहीं है।

— Draco18s

@ ConorO'Brien यह दर्शाता है कि आपकी परिकल्पना प्रशंसनीय है, लेकिन यह इसे साबित नहीं करता है।

— कास्परड

@kasperd इस प्रकार इससे पहले "किसी न किसी सबूत"।

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

Answer 1

05AB1E , 8 बाइट्स

Nth नंबर 1 -indexed जनरेट करता है

µNÐΔWm}‹

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

व्याख्या

µ          # run until counter equals input
 NÐ        # push 3 copies of the current iteration index (1-based)
   Δ  }    # run this code until the result no longer changes     
    Wm     # raise the number to the power of its minimum digit
       ‹   # check if greater than the index

वैकल्पिक रूप से एक ही बाइट गिनती में एक अनंत सूची के रूप में:

∞ʒDΔWm}‹

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

Comments

रुको, यह सब है? .. कि इतना simpeler लगता है जितना मैंने सोचा था कि यह होगा ..>> मैं अपना उत्तर हटा दूंगा, क्योंकि यह दो बार से अधिक लंबा है ..

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

@ केविनक्रूजसेन: मैं खुद थोड़ा हैरान हूं। सोचा कि टास्क देखते समय 12 या इतने बाइट्स लगेंगे।

— एमिग्ना

मैंने चुनौती देने के बाद µऔर Δअधिकार के साथ ट्विड किया और इसे ठीक वही उत्तर मिला, लेकिन मैं सोच रहा था कि यह काम क्यों नहीं किया ... मैंने इसके Dबजाय इसका इस्तेमाल किया Ðक्योंकि मुझे लगा कि एक प्रति निश्चित-बिंदु फ़ंक्शन द्वारा उपयोग की जाएगी और दूसरे की तुलना में छोटे-फंक्शन से, लेकिन मैंने इस बात पर ध्यान नहीं दिया कि मुझे एक और कॉपी की जरूरत है। धन्यवाद, Emigna, मेरे Enimga को हल करने के लिए।

— श्री एक्सकोडर

Answer 2

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

{grep {($_,{$_**.comb.min}...*==*).tail>$_},1..*}

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

एक अनंत क्रम देता है। मुझे लगता है कि निम्नलिखित 45 बाइट संस्करण काम करता है, भी, लेकिन मैं यह साबित नहीं कर सकता कि निश्चित बिंदु हमेशा एन पुनरावृत्तियों के बाद पाया जाता है।

{grep {($_,{$_**.comb.min}...*)[$_]>$_},3..*}

Answer 3

जे , _{४१ ३} ९ _{३ 39} बाइट्स

(>:[echo^:(<(^0".@{/:~@":)^:_))^:_]1x

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

यह एक पूर्ण कार्यक्रम है जो अनंत अनुक्रम को मुद्रित करता है। एक बहुत ही दुर्लभ अवसर जहां एक पूर्ण कार्यक्रम जे में एक क्रिया धड़कता है।

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

(>:[echo^:(<mpi_fix))^:_]1x    Using the mpi_fix below; it finds the MPI fixpoint
          (<mpi_fix)           Is mpi_fix greater than the input?
    echo^:                     If so, apply echo; do nothing otherwise
                               echo returns an empty array
 >:[                           Discard the above and return input+1
(                   )^:_       Repeat the above infinitely (increment has no fixpoint)
                        ]1x    starting from arbitrary-precision number 1

---

जे , ₄₁ 39 बाइट्स

>:^:(>:(^0".@{/:~@":)^:_)^:_@>:@]^:[&0x

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

एक संज्ञा क्रिया। 1-आधारित इंडेक्स को देखते हुए, उस इंडेक्स पर नंबर लौटाता है। पाद लेख जांचता है कि पहले 20 शब्द सही हैं।

"फिक्स पॉइंट" शब्द को पढ़ते हुए, मैंने तुरंत सोचा "ओह, हाँ, ^:_बहुत अच्छा काम करेगा।" फिर मैं गुस्से और उदास चेहरे के इस घृणा के साथ समाप्त हुआ। और यह एक ट्रेन भी नहीं है, यह एक क्रिया है ।

Ungolfed & यह कैसे काम करता है

nth_term =: >:^:(>:(^0".@{/:~@":)^:_)^:_@>:@]^:[&0x

mpi =: ^0".@{/:~@":    Find the MPI
             /:~@":    Sort the string representation
        0   {          Take first item
         ".@           Convert back to number
       ^               Raise the input to the power of above

mpi_fix =: mpi^:_      Find the MPI fixpoint

next_term =: >:^:(>:mpi_fix)^:_@>:    Given a number, find the next term
                               @>:    Increment once, and then...
                  >:mpi_fix           Is mpi_fix not greater than input?
             >:^:           ^:_       Increment while the above is true

nth_term =: next_term@]^:[&0x    Given one-based index, find the nth term
            next_term@]          Apply next_term monadically
                       ^:[       n times
                          &0x    to the starting value of zero

मनमानी-सटीक पूर्णांक 0xकी आवश्यकता है कि फिक्सपॉइंट की सही गणना करें, जैसे संख्या 6।

Comments

महान! यह एक बहुत कुछ है ^:, मेरा सिर उनमें से दूसरे पर दर्द करना शुरू कर देता है :)

— गैलेन इवानोव

(>:[(<(^{.@/:~&.":)^:_)echo])^:_]1x

— FrownyFrog

33 बाइट्स: _&(_&(]]+]>:(^{.@/:~&.":)^:_)>:)*एक विस्तारित पूर्णांक के रूप में इनपुट लेना

— मील की दूरी

Answer 4

अजगर , 10 बाइट्स

.f>u^GshS`

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

$n$GZZQ.fQu^GshS`GZ

न्यूनतम पावर रूट कोड uवर्तमान संख्या Gको बढ़ाने के लिए एक निश्चित बिंदु को खोजने के लिए काम करता है यह न्यूनतम अंक की शक्ति है, जो कि पहले अंक ( h) के रूप में एक ही है जो lexicographically ( S) सॉर्ट किया गया है , फिर एक पूर्णांक ( s) में परिवर्तित हो गया है ।

Answer 5

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

*DṂƊƬḊCȦµ#

एसटीडीआईएन से एक पूर्णांक लिंक एक पूर्णांक Iबनाता है, जो पहली Iप्रविष्टियों को प्राप्त करता है।

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

( *DṂƊƬṪ%@µ#10 के लिए भी काम करता है)

कैसे?

एक मौद्रिक कार्य के सत्य परिणाम आने n=0तक गिना जाता है inputऔर उन पैदावार की पैदावार होती है n।

फ़ंक्शन के साथ शुरू होने वाला एक और मौद्रिक फ़ंक्शन बार-बार लागू होता है और तब तक x=nमूल्यों को इकट्ठा करता है xजब तक कि परिणाम अद्वितीय नहीं होते हैं। (जैसे: 19पैदावार [19]; 23पैदावार [23,529,279841]; 24पैदावार [24, 576, 63403380965376, 1]; आदि ...) और फिर परिणाम को छोड़ता है (सबसे अधिक मूल्य को हटाता है), सभी मानों को पूरक 1-xकरता है ( ) और सूची में शून्य होने पर या अगर यह खाली है तो Ȧउपज का उपयोग करता है 0।

अंतरतम फ़ंक्शन वर्तमान xको सभी अंकों तक बढ़ाता है xऔर फिर न्यूनतम रखता है (ऐसा करना न्यूनतम अंक पहले खोजने पर एक बाइट सेव है)।

*DṂƊƬḊCȦµ# - Link (call the input number I)
         # - count up from 0 and yield the first I for which this yields a truthy value:
        µ  -   a monadic chain:
    Ƭ      -     collect until results are not unique:
   Ɗ       -       last three links as a monad:
 D         -         convert to a list of decimal digits
*          -         exponentiate
  Ṃ        -         minimum
     Ḋ     -     dequeue
      C    -     compliment
       Ȧ   -     any-and-all?

Comments

ƬḊCȦवहाँ पर चतुर उपयोग । :-)

— आउटगोल्फर

Ṫ>उठाता है 0:(

— जोनाथन एलन

Answer 6

गणितज्ञ, ५ ९ ५१ बाइट्स

^{-8 बाइट्स मीशा लावरोव को धन्यवाद ।}

Select[Range@#,#<(#//.x_:>x^Min@IntegerDigits@x)&]&

शुद्ध कार्य। एक संख्या को इनपुट के रूप में लेता है, और आउटपुट के रूप में उस संख्या तक की शर्तों की सूची देता है। यहां कुछ भी जटिल नहीं है।

Comments

FixedPointआमतौर पर कोड गोल्फ में उतना अच्छा नहीं होता जितना //.छोटा (कम ReplaceRepeated) होता है। यहाँ, हम कुछ बाइट्स बचा सकते हैं Select[Range@#,1<(#//.x_:>x^Min@IntegerDigits@x)!=#&]&।

— मिशा लावरोव

इसके अलावा, यदि MPI (x) न तो 1 है और न ही x है, तो यह हमेशा x से बड़ा होता है, इसलिए एक छोटा समाधान भी है Select[Range@#,#<(#//.x_:>x^Min@IntegerDigits@x)&]&।

— मिशा लावरोव

Answer 7

पायथन 3 , ₉₀ 88 बाइट्स

-2 बाइट्स @mypetlion द्वारा

def F(x):m=x**int(min(str(x)));return[int,F][m>x](m)
x=1
while 1:x<F(x)and print(x);x+=1

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

printके रूप में एक अभिव्यक्ति ifपायथन 2 में बयान का उपयोग करने पर दो बाइट्स बचाता है । FMPI निर्धारण की गणना करता है; बाकी STDOUT को अनंत अनुक्रम देता है।

Comments

2 बाइट बचाने के return m>x and F(m)or mलिए बदलें return[int,F][m>x](m)।

— १

78 बाइट्स

— लिन

Answer 8

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

filter((<)<*>until((==)=<<g)g)[1..]
g a=a^read[minimum$show a]

एक अनंत सूची देता है।

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

Answer 9

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

x=1;loop{b=x+=1;1while b<b**=b.digits.min;b>x&&p(x)}

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

प्रिंट अनंत क्रम

Comments

51 बाइट्स ( $.इसके बजाय उपयोग x, इनिशियलाइज़ेशन को बचाता है)

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

Answer 10

जावा 10, 178 173 बाइट्स

v->{for(int x=1,m;;){var b=new java.math.BigInteger(++x+"");for(m=9;m>1;)b=b.pow(m=(b+"").chars().min().orElse(0)-48);if(b.compareTo(b.valueOf(x))>0)System.out.println(x);}}

पोर्ट @GB रूबी का जवाब है , इसलिए भी अनिश्चित काल के लिए प्रिंट करता है।

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

स्पष्टीकरण:

v->{             // Method with empty unused parameter and no return-type
  for(int x=1,   //  Start an integer `x` at 1
      m;         //  Temp integer for the smallest digit, starting uninitialized
      ;){        //  Loop indefinitely
    var b=new java.math.BigInteger(++x 
                 //   Increase `x` by 1 first
          +"");  //   And create a BigInteger `b` for the new `x`
    for(m=9;     //   Reset `m` to 9
        m>1;)    //   Loop as long as the smallest digit is not 0 nor 1
      b=b.pow(m=(b+"").chars().min().orElse(0)-48
                 //    Set `m` to the smallest digit in `b`
              ); //    Set `b` to `b` to the power of digit `m`
    if(b.compareTo(b.valueOf(x))>0)
                 //   If `b` is larger than `x`:
      System.out.println(x);}}
                 //    Print `x` with a trailing newline

Answer 11

जावास्क्रिप्ट (Node.js) , 75 बाइट्स

$n$

f=(i,x=n=1n)=>(N=x**BigInt(Math.min(...x+'')))>x?f(i,N):(i-=N>n)?f(i,++n):n

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

Answer 12

जावास्क्रिप्ट (Node.js) , 98 90 89 86 बाइट्स

-3 बाइट्स थैंक्स @Conor O'Brien

function*(){for(n=0n;;x>n&&(yield n))for(x=++n;(b=Math.min(...""+x))-1;)x**=BigInt(b)}

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

$MPR(n)>n$$MPR(n)\notin \{1,n\}$

लगता है कि एक जनरेटर nसंख्या की एक संख्या को लौटाने से कम है ?

या असीम रूप से मुद्रण - 72 बाइट्स

for(n=0n;;x>n&&alert(n))for(x=++n;(b=Math.min(...""+x))-1;)x**=BigInt(b)

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

Comments

86 बाइट्स कुछ नियंत्रण प्रवाह को स्थानांतरित करके, ब्रेसिज़ को समाप्त करते हैं। (मुख्य रूप से: if(x>n)yield nकरने के लिए x>n&&(yield n)अभिव्यक्ति के रूप में)

— कोनोर ओ ब्रायन

Answer 13

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

3*DṂ$$ÐLḟ1,$Ɗ#

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

Answer 14

जावास्क्रिप्ट (क्रोम), ₇₈ 77 बाइट्स

F=x=>(m=x**BigInt(Math.min(...''+x)))>x?F(m):m
for(x=0n;++x;)x<F(x)&&alert(x)

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

मेरे अपने पायथन 3 समाधान का पोर्ट । Chrome का नवीनतम संस्करण समर्थन करता है BigInt(मेरे पीसी पर परीक्षण किया गया)। हालांकि इस कोड की कोशिश अपने ब्राउज़र पर नहीं है।

Comments

lol मेरा जवाब जानने के लिए तैयार था, लेकिन आपको लीड मिल गई। 77 बाइट्स 77 बाइट्स, मेरा नियोजित गोल्फ

— शायरु असाकोटो

Answer 15

रैकेट , 270, 257 233 बाइट्स

(define(f n)(local((define(m x)(expt x(-(first(sort(map char->integer(string->list(~v x)))<))48)))(define(g y)(if(= y(m y))y(g(m y))))(define(k x l)(if(=(length l)n)l(if(< x(g x))(k(+ x 1)(cons x l))(k(+ x 1)l)))))(reverse(k 1'()))))

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

यह मेरा पहला रैकेट सबमिशन है, इसलिए निश्चित रूप से इसे बहुत आगे बढ़ाया जा सकता है। फिर भी मैं कुछ हद तक संतुष्ट हूं, कम से कम कार्य को हल करने के लिए।

अधिक पठनीय:

(define (f n)
  (local ((define (m x)
           (expt x
                 (- (first (sort (map char->integer (string->list (~v x)))
                                 <))
                    48)))
         (define (g y)
           (if
             (= y (m y))
             y
             (g (m y))))
         (define (k x l)
           (if (= (length l) n)
               l
               (if (< x (g x))
                   (k (+ x 1) (cons x l))
                   (k (+ x 1) l))))
    (reverse (k 1 '()))))

Answer 16

Axiom, 168 बाइट्स

u(x)==(y:=x::String;x^reduce(min,[ord(y.i)-48 for i in 1..#y])::NNI)
q(a:PI):PI==(b:=a;repeat(c:=u(b);c=b=>break;b:=c);b)
z(x)==[i for i in 1..x|(m:=q(i))~=1 and m~=i]

इसका उपयोग करने का कार्य z () है; यहाँ यह उन संख्याओं को प्रिंट करता है जिनमें एक संख्या 1 है, जो स्वयं नहीं है और अपने तर्क से कम है।

(6) -> z 1000
 (6)
 [3, 5, 6, 8, 23, 26, 27, 29, 35, 36, 39, 42, 47, 53, 59, 64, 72, 76, 78, 82,
  83, 84, 92, 222, 223, 227, 228, 229, 233, 237, 239, 254, 263, 267, 268,
  269, 273, 276, 277, 278, 279, 285, 286, 287, 289, 296, 335, 338, 339, 342,
  346, 347, 348, 354, 358, 363, 365, 372, 373, 374, 376, 382, 383, 386, 392,
  394, 395, 399, 423, 424, 426, 427, 428, 432, 433, 435, 436, 442, 447, 459,
  462, 464, 466, 467, 468, 469, 476, 477, 479, 483, 487, 488, 489, 493, 494,
  523, 524, 527, 529, 533, 537, 542, 546, 553, 556, 557, 562, 563, 572, 573,
  577, 582, 583, 584, 594, 595, 598, 623, 626, 627, 629, 632, 633, 642, 646,
  647, 648, 663, 664, 669, 672, 676, 682, 683, 684, 693, 694, 695, 698, 722,
  724, 729, 736, 759, 763, 773, 775, 782, 786, 823, 829, 835, 846, 847, 856,
  873, 876, 885, 893, 894, 896, 923, 924, 928, 933, 953, 954, 962, 969, 973,
  974, 984, 993, 994, 995]
                                               Type: List PositiveInteger

Answer 17

Visual Basic .NET (.NET कोर) , 290 बाइट्स (आयात शामिल हैं)

Iterator Function A()As System.Collections.IEnumerable
Dim i=B.One,q=i,p=i
While 1=1
q=i-1
p=i
While q<>p
For j=0To 9
If p.ToString.Contains(j)Then
q=p
p=B.Pow(p,j)
Exit For
End If
Next
End While
If p>1And p<>i Then Yield i
i+=1
End While
End Function

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

निम्नलिखित आयात की आवश्यकता है:

Imports B = System.Numerics.BigInteger

यह मापदंड से मिलने वाले पूर्णांक की एक अनंत (आलसी भरी हुई) सूची को वापस करने के लिए एक इटेरेटर फ़ंक्शन का उपयोग करता है। BigIntegerकिसी भी आकार प्रतिबंध से बचने के लिए उपयोग करता है, विशेष रूप से मध्यवर्ती गणनाओं के साथ।

संयुक्त राष्ट्र के golfed:

Iterator Function A() As System.Collections.IEnumerable
    Dim i As B = 1
    While True
        Dim prevProduct As B = 0
        Dim product As B = i
        While prevProduct <> product
            For j = 0 To 9
                If product.ToString.Contains(j) Then
                    prevProduct = product
                    product = B.Pow(product, j)
                    Exit For
                End If
            Next
        End While
        If product <> 1 And product <> i Then
            Yield i
        End If
        i += 1
    End While
End Function

Answer 18

आम लिस्प , 238 बाइट्स

(defun x(m n o p q)(setf i(sort(map 'list #'digit-char-p(prin1-to-string m))#'<))(setf j(expt m(first i)))(cond((= q p)nil)((and(= n j)(not(= n 1))(not(= n o)))(cons o(x(1+ o)0(1+ o)p(1+ q))))((= n j)(x(1+ o)0(1+ o)p q))(t(x j j o p q))))

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

Answer 19

एपीएल (एनएआरएस), 96 चार्ट, 192 बाइट्स

r←f w;k;i;a
   r←⍬⋄k←1
A: i←k
B: →C×⍳i=a←i*⌊/⍎¨⍕i⋄i←a⋄→B
C: →D×⍳(a=k)∨a=1⋄r←r,k
D: k+←1⋄→A×⍳k≤w

परीक्षण (तर्क 22 के लिए आंशिक परिणाम बहुत बड़ा लगता है इसलिए <21 तर्क मुझे नहीं पता कि क्या ठीक हो सकता है)

  f 21
3 5 6 8 

Answer 20

अजगर ३ , 102 बाइट्स

x=int(input())
a=c=0
while x:
 a+=1;b=a
 while b-c:b,c=b**int(min(str(b))),b
 x-=b!=1and b!=a
print(a)

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

एक पायथन 3 समाधान की कोशिश करने का निर्णय लिया जो सीधे अनुक्रम में nth शब्द को प्रिंट करता है।

Comments

ऐसा लगता है कि आप किसी भी पायथन 3 सुविधाओं का उपयोग नहीं कर रहे हैं। पायथन 2 में क्विक गोल्फिंग 87 बाइट्स देता है।

— बब्बलर

अनंत आउटपुट 77 बाइट्स देता है।

— बुबलर

Answer 21

सी (क्लैंग) + -DL=long long -lm, 213 बाइट्स

q(char*a,char*b){return*a>*b;}L f(L a){char*c;asprintf(&c,"%lld",a);qsort(c,strlen(c),1,q);L b=pow(a,*c-48);return b>a?f(b):b;}i;g(j){for(i=0;j;i++){L x=f(i);x!=i&x!=1&x>0&&printf("%d\n",i)&&j--;}}

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

फंक्शन अनुक्रम g(j)के पहले jशब्दों को प्रिंट करता है ।

Comments

a=...एक दर्जन या तो बाइट बचाने के लिए साथ लौटें ।

और के x>1बजाय x!=1&x>0।

पहले एक को जीसीसी में बदलाव की आवश्यकता होती है, हालांकि।

Answer 22

भूसी , 16 12 10 बाइट्स

fS>ωṠ^o▼dN

6 बाइट्स को बचाया। H.PWiz को धन्यवाद।
इसे ऑनलाइन आज़माएं!

व्याख्या

fS>ωṠ^o▼dN
f        N       Filter the natural numbers where...
   ω             ... the fixed point...
    Ṡ^o▼d        ... of raising the number to its smallest digit...
 S>              ... is greater than the number.

Comments

आप बदल सकते हैं >¹के साथ यहाँ S>। यह आपको यह सब एक पंक्ति में रखने की अनुमति देता है। इसके अलावा, ऐसा प्रतीत होता है कि आपने पिछले

— टियो

Answer 23

जाप , 44 बाइट्स

_ì ñ g
_gV ¥1?Z:ZpZgV)gW
@@[1X]øXgW}fXÄ}gUÄ

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

अन्य जाप उत्तर से पर्याप्त रूप से भिन्न।

स्पष्टीकरण:

                        Empty line preserves the input

_ì ñ g                Function V finds the smallest digit in a number Z
 ì                          Get the digits of Z
   ñ                        Sort the digits
     g                      Get the first (smallest) digit


_gV ¥1?Z:ZpZgV)gW     Function W finds the MPR of a number Z
 gV ¥1?Z                    If V(Z) is 1, then it's stable; return it
        :ZpZgV)             Otherwise get MPI of Z...
               gW           And call W on it ( MPR(Z) == MPR(MPI(Z)) )

@@[1X]øXgW}fXÄ}gUÄ    Main program
@             }gUÄ      Get the nth number by repeatedly applying...    
 @        }fXÄ              Find the next smallest number X which returns false to...
       XgW                    MPR(X)
      ø                       is either...
  [1X]                        1 or X

भविष्य की गोल्फिंग संभावनाओं के संदर्भ में, मैं मैन्युअल रूप से एक नंबर पर एक फ़ंक्शन को कॉल करता हूं, जिस पर मुझे संदेह है कि इसे कम किया जा सकता है लेकिन मुझे यकीन नहीं है कि कैसे।