घातीय अंक वृद्धि और उससे आगे तक!

Question

चुनौती

यह देखते हुए एक आधार $1 < b < 10$ और एक सूचकांक $t \ge 1$ , उत्पादन अवधि $x_t$ , इस प्रकार के रूप में परिभाषित:

• $x_1 = 11_{10}$
• $x_{i+1}$ को$x_i$ को बेस$b$ परिवर्तित करकेऔर उसके बाद बेस 10 में अपने अंकों को फिर से लिखना है$10$
• आउटपुट बेस 10 में होना चाहिए$10$

आधार 5 के लिए टहलने, शब्द 5 होगा:

• $x_1 = 11_{10}$ ।
• $11_{10} = 21_{5}$ तो$x_2 = 21_{10}$ ।
• $21_{10} = 41_{5}$ तो$x_3 = 41_{10}$ ।
• $41_{10} = 131_{5}$ तो$x_4 = 131_{10}$ ।
• $131_{10} = 1011_{5}$ तो$x_5 = 1011_{10}$ ।
• हम स्ट्रिंग "1011"या पूर्णांक आउटपुट करते हैं 1011।

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

नोट: ये एक अनुक्रमित हैं

base 2, term 5 --> 1100100111110011010011100010101000011000101001000100011011011010001111011100010000001000010011100011
base 9, term 70 --> 1202167480887
base 8, term 30 --> 4752456545
base 4, term 13 --> 2123103032103331200023103133211223233322200311320011300320320100312133201303003031113021311200322222332322220300332231220022313031200030333132302313012110123012123010113230200132021023101313232010013102221103203031121232122020233303303303211132313213012222331020133

टिप्पणियाँ

• मानक खामियों की अनुमति नहीं है
• किसी भी डिफ़ॉल्ट I / O विधि की अनुमति है
• आप अलग-अलग अनुक्रमित (जैसे 0-अनुक्रमित, 1-अनुक्रमित, 2-अनुक्रमित, आदि) का उपयोग टी के लिए कर सकते $t$
• आप पहले $t$ शब्दों का उत्पादन कर सकते हैं।
• जैसा कि यह कोड-गोल्फ है , उस भाषा के लिए सबसे छोटा कोड जीतता है

Comments

क्या हमें बड़ी संख्या या केवल 2 ^ 31 - 1 तक की संख्याओं का समर्थन करना है?

— अज्ञानता का अवतार

@EmbodimentofIgnorance आपकी भाषा की अधिकतम (मानक खामियों को याद रखें, हालाँकि!)

— मिल्कीवेयय

क्या कोई चुनौती है जिसमें आधार> 10 शामिल हैं? (उस मामले में आप बार-बार व्याख्या 11करेंगे जैसे कि यह आधार में था bऔर इसे वापस आधार 10 में बदल दिया, आदि)

— नील

@ नील में मैंने १० से अधिक आधारों को शामिल नहीं किया है (उदाहरण के लिए) 4aआधार -१० में एक मान्य संख्या नहीं होगी

— मिल्कीवेय

आप नहीं मिलेंगे 4a, क्योंकि आप आधार को 10 अंकों के आधार के रूप में व्याख्या कर रहे हैं bऔर हर बार आधार 10 में परिवर्तित करेंगे (यानी इस प्रश्न का दूसरा तरीका)।

— नील

Answer 1

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

इस संस्करण पर 5 बाइट्स और बिगइंट संस्करण पर 2 बाइट्स बचाने के लिए @ निएल का धन्यवाद

इनपुट के रूप में लेता है (t)(base), जहां $t$ 1-अनुक्रमित है।

n=>g=(b,x=11)=>--n?g(b,+x.toString(b)):x

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

---

जावास्क्रिप्ट (Node.js) , 48 बाइट्स (BigInt संस्करण)

इनपुट के रूप में लेता है (t)(base), जहां $t$ 1-अनुक्रमित है। एक BigInt लौटाता है।

n=>g=(b,x=11n)=>--n?g(b,BigInt(x.toString(b))):x

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

Comments

क्या आपको evalपहले संस्करण की आवश्यकता है? +5 बाइट्स बचाएगी ...

— नील

और BigIntदूसरे संस्करण में दो बाइट्स बचाता है, क्योंकि आपको nस्ट्रिंग में जोड़ने की आवश्यकता नहीं है ।

— नील

(b,t,x=11)=>--t?f(b,t,+x.toString(b)):xis 1 char

— short

@Qwertiy यह वास्तव में 1 बाइट लंबी है, क्योंकि हमें पूर्ववत करने की आवश्यकता होगी f=(क्योंकि फ़ंक्शन स्वयं संदर्भित है)।

— अरनौलड

@ अरनुलद, उफ़। फिर यह एक n=>b=>g=(x=11n)=>--n?g(BigInt(x.toString(b))):x:) यदि कॉल f(t)(b)()की अनुमति है।

— क्वर्टी

Answer 2

05AB1E , 5 बाइट्स

>IF¹B

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

व्याख्या

>       # increment <base>
 IF     # <term> times do:
   ¹B   # convert from base-10 to base-<base>

ध्यान दें कि 11 पर अनुक्रम को स्पष्ट रूप से शुरू करने की आवश्यकता नहीं है ।
शुरू करने base+1और एक अतिरिक्त पुनरावृत्ति करने के परिणामस्वरूप पहले पुनरावृत्ति में 11 दिए जाएंगे ।

Answer 3

जाप , 9 बाइट्स

ÆB=sV n
B

कोशिश करो

(Two inputs, U and V)
Æ            Range [0..U)
 B=          For each, set B (B is preinitialized to 11) to 
   sV          B's previous value converted to base-V
   n           and back to base-10
B            Print out B's final value

Comments

यह कभी भी पहले शब्द का उत्पादन करने में सक्षम नहीं होगा, यह होगा?

— झबरा

@ शगुन दो बाइट्स की लागत पर निर्धारित

— अज्ञानता का प्रतीक

अच्छी तरह से बचाया :) उस meself करने के बारे में सोचा नहीं होगा।

— झबरा

Answer 4

वोल्फ्राम भाषा (गणितज्ञ) , 46 बाइट्स

bNest[FromDigits[#~IntegerDigits~b]&,11,#]&

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

के साथ बुलाओ f[base][t]। 0 अनुक्रमित।

Comments

41 बाइट्स

— समाप्त डेटा

Answer 5

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

.+,(\d+)
11,$1*
"$+"{`^\d+
*
)+`(?=_.*,(_+))(\1)*(_*)
$#2*_$.3
,_+

$t$$b$

.+,(\d+)
11,$1*

$x_0=11$$b$

"$+"{`

$t$

^\d+
*

$x_i$

)+`(?=_.*,(_+))(\1)*(_*)
$#2*_$.3

$b$

,_+

$b$

Answer 6

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

def f(b,n):h=lambda x:x and x%b+10*h(x/b);return n and h(f(b,n-1))or 11

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

0 अनुक्रमित।

Answer 7

क्लोजर , 109 बाइट्स

बेवजह के स्पॉट को हटाकर 10 बाइट्स निकालने के लिए मिल्कीवेय 90 का श्रेय एक अन्य अनावश्यक स्पेस के लिए एक बाइट के लिए इग्नोरेंस को मूर्त रूप देने का श्रेय

golfed

(defn f([b t](f b t 11))([b t v](if(= t 1)v(f b(dec t)(read-string(.(new BigInteger(str v))(toString b)))))))

Ungolfed

(defn f
  ([base term] (f base term 11))
  ([base term value] (if (= term 1)
                      value
                      (f base (dec term) (read-string (. (new BigInteger (str value)) (toString base)))))))

मुझे लगता है कि मुख्य स्थान बाइट्स को बचाया जा सकता है ... के लिए अभिव्यक्ति है ... reradixing? जो भी कहा जाएगा। विशेष रूप से:

(read-string (. (new BigInteger (str value)) (toString base)))

Comments

क्या आपको उन रिक्त स्थान की आवश्यकता है? क्या आप रिक्त स्थान को समाप्त कर सकते हैं?

— MilkyWay90

उन स्थानों को हटाने के लिए भी मेरे पास नहीं थे जहाँ वे वाक्य-निर्माण की अलग-अलग चीज़ों को अलग कर रहे थे; जैसा कि मैंने सोचा था कि क्लोजर थोड़ा अधिक अनुमेय है। धन्यवाद!

— user70585

अभी भी एक अनावश्यक स्थान है(if (= t 1)

— अज्ञानता का अवतार

— वूप

93 बाइट्स

— अज्ञानता का अवतार

Answer 8

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

{(11,+*.base($^b)...*)[$^t]}

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

अनुक्रम में सूचकांक शून्य-आधारित है।

Answer 9

जेली , 8 7 बाइट्स

‘b³Ḍ$⁴¡

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

एक पूर्ण कार्यक्रम जो लेता है $b$ पहले तर्क और 1-अनुक्रमित के रूप में $t$इसके दूसरे तर्क के रूप में। प्रासंगिक शब्द (और अंतर्निहित प्रिंट) के लिए पूर्णांक देता है। के साथ शुरू करने के बारे में @Eignign द्वारा अवलोकन का उपयोग करता है$b + 1$।

व्याख्या

‘b³Ḍ$⁴¡ | Main link: first argument b, second argument t
‘       | b + 1
    $⁴¡ | Repeat the following t times
 b³     | Convert to base b
   Ḍ    | Convert back from decimal to integer

Comments

उन लोगों के लिए स्पष्टीकरण जो एक त्वरित नज़र में परमाणुओं को पहचान नहीं सकते हैं?

— MilkyWay90

Answer 10

के (ngn / k) , 13 बाइट्स

{y(10/x\)/11}

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

Answer 11

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

uijGQTEh

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

Answer 12

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 87 बाइट्स

n=>m=>{int g=11;for(var s="";m-->0;g=int.Parse(s),s="")for(;g>0;g/=n)s=g%n+s;return g;}

सहेजे गए 5 बाइट्स @KevinCruijssen की बदौलत

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

Comments

do-whileएक नियमित रूप से लूप में बदलकर 87 बाइट्स ।

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

Answer 13

ब्रेनफक , 270 बाइट्स

++<<++<,+++<-[----->-<]<,,[<-----[->++++++++++<]++>[-<+>],]<[>>>>>>[<<<[->>+<<]>>>>>]<<[[>+<-]>>[-[<++++++++++>-]>+>]<[<<]>>[-<<+>>>+<]>>[-[<-[>>+>>]>>[+[-<<+>>]>[-<]<[>]>++>>>]<<<<<-]+>[-<+<+>>]<<[->>+<<]>>>]<[-]<[[-<+>]<<]<]<[->>+<<]<-]>>>>[>>]<<[>-[-----<+>]<----.<<]

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

0 अनुक्रमित। पुनरावृत्तियों की संख्या अधिकतम 255 पर मानी जाती है।

व्याख्या

टेप को इस प्रकार रखा गया है:

num_iterations 0 0 base digit0 0 digit1 0 digit2 ...

प्रत्येक अंक को वास्तव में उस अंक 1 के रूप में संग्रहीत किया जाता है, जिसमें 0 "अधिक अंक नहीं" के लिए आरक्षित होता है। आधार रूपांतरण के दौरान, वर्तमान में काम किए जा रहे अंकों को एक सेल को दाईं ओर ले जाया जाता है, और आधार को वर्तमान कार्य क्षेत्र के बाईं ओर ले जाया जाता है।

++<<++              Initialize initial value 11
<,+++<-[----->-<]   Get single digit as base and subtract 48 to get actual number
<,,[<-----[->++++++++++<]++>[-<+>],]   Read multiple digits as number of iterations
<                   Go to cell containing number of iterations

[                   For each iteration:
  >>>>>>              Go to tens digit cell
  [<<<[->>+<<]>>>>>]  Move base to just before most significant digit
  <<                  Return to most significant digit

  [                   For each digit in number starting at the left (right on tape):
    [>+<-]            Move digit one cell to right (to tell where current digit is later)
    >>[-[<++++++++++>-]>+>]  Multiply each other digit by 10 and move left
    <[<<]>>           Return to base
    [-<<+>>>+<]       Copy base to just before digit (again) and just before next digit to right (left on tape)
    >>[               For each digit at least as significant as this digit:

      -[<-[>>+>>]>>[+[-<<+>>]  Compute "digit" divmod base
      >[-<]<[>]>++    While computing this: add quotient to next digit; initialize digit to "1" (0) first if "0" (null)
      >>>]<<<<<-]     End of divmod routine

      +>[-<+<+>>]     Leave modulo as current digit and restore base
      <<[->>+<<]      Move base to next position
      >>>
    ]

    <[-]<             Delete (now useless) copy of base
    [[-<+>]<<]<       Move digits back to original cells
  ]                   Repeat entire routine for each digit

  <[->>+<<]           Move base to original position
  <-                  Decrement iteration count
]

>>>>[>>]<<[>-[-----<+>]<----.<<]  Output by adding 47 to each cell containing a digit

Answer 14

चारकोल , 14 बाइट्स

≔11ζＦＮ≔⍘ＩζＩηζζ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। इनपुट के रूप में लेता है$t$ (0-अनुक्रमित) और $b$। स्पष्टीकरण:

≔11ζ

$x_0=11$।

ＦＮ

लूप $b$ बार।

≔⍘ＩζＩηζ

गणना $x_i$।

ζ

उत्पादन $x_t$।

Answer 15

परी / जीपी , 50 बाइट्स

(b,n)->x=11;for(i=2,n,x=fromdigits(digits(x,b)));x

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

Answer 16

सी (जीसीसी) , 59 बाइट्स

f(t,b){t=t?c(f(t-1,b),b):11;}c(n,b){n=n?c(n/b,b)*10+n%b:0;}

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

Answer 17

ग्रूवी , 45 बाइट्स

a,b,c=11->a--?f(a,b,a.toString(c as int,b)):c

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

पोर्ट ऑफ @ अरनौलड का जवाब

Answer 18

PHP , 83 75 बाइट्स

function c($b,$t,$v=11){return $t==1?$v:c($b,$t-1,base_convert($v,10,$b));}

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

यह केवल "छोटी" संख्याओं के साथ काम करेगा (उदाहरण के लिए मामलों 1 और 4 का परीक्षण नहीं)

Answer 19

जाप , 10 बाइट्स

0 अनुक्रमित। tपहले इनपुट के रूप में लेता है , bदूसरे के रूप में।

_ìV ì}gBìC

कोशिश करो

Answer 20

गैया , 8 बाइट्स

Bd
11@↑ₓ

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

0-आधारित iterationsतब लेता है base।

Bd		| helper function: convert to Base b (implicit) then convert to base 10
		| main function:
11		| push 11
  @		| push # of iterations
   ↑ₓ		| do the above function (helper function) that many times as a monad

Answer 21

माणिक , 39 बाइट्स

शून्य अनुक्रमित।

->b,n,x=11{n.times{x=x.to_s(b).to_i};x}

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

Answer 22

पर्ल 5 -Mbigint -pa , 65 बाइट्स

$\=11;map{$p=$\;$\%=0+"@F";$\=($p%"@F").$\while$p/=0+"@F"}2..<>}{

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