32

आज्ञा देना nऔर bसकारात्मक पूर्णांक से बड़ा हो 1।

nकी अगली शक्ति से दूरी का उत्पादन करें b।

के लिए n=5और b=3, के अगले शक्ति 3से 5है 9( 3^2 = 9), इसलिए उत्पादन होता है 9 - 5 = 4।

के लिए n=8और b=2, के अगले शक्ति 2से 8है 16( 2^4 = 16), इसलिए उत्पादन होता है 16 - 8 = 8। ध्यान दें कि इस उदाहरण में nएक शक्ति है 2।

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

यह कोड-गोल्फ है । बाइट्स जीत में सबसे छोटा जवाब। मानक खामियां लागू होती हैं।

code-golf arithmetic

— लीक नन
स्रोत

16

जेली , 4 3 बाइट्स

ạæċ

nबाईं bओर दाईं ओर ले जा रहा एक डियाडिक लिंक और परिणाम वापस।

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

कैसे?

ạæċ - Link: number n, number b | n,b ∈ ℕ
 æċ - ceiling n to the next power of b
ạ   - absolute difference between n and that

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

4

पार किया गया 4 अभी भी नियमित 4 है;

— यूरिल

2

@ युरील बट  ;)

— हाइपरनेट्रिनो

अपने शुरू में सोचा था कि "यह है ओह æċ!" इसके बजाय "उल्लू यह बहुत कठिन है ..."

— एरिक आउटगोल्फर

ओह, यह इतिहास में मौजूद नहीं हो सकता है, लेकिन मैंने 4 बटर से बदलाव किया। यह थाæċ_⁸

— जोनाथन एलन

@JonathanAllan चूंकि यह इतिहास में नहीं था इसलिए इसका कोई मतलब नहीं था और इसलिए मैंने इसे संपादित किया।

— आउटगॉल्फ

8

x86-64 असेंबली ( विंडोज x64 कॉलिंग कन्वेंशन ), 14 13 बाइट्स

एक अयोग्य (लेकिन svelte!) पुनरावृत्ति दृष्टिकोण (प्रेरणा के लिए @Neil के लिए क्रेडिट के साथ):

               HowFarAway PROC
6A 01             push   1
58                pop    rax         ; temp = 1
               Loop:
0F AF C2          imul   eax, edx    ; temp *= b
39 C8             cmp    eax, ecx
72 F9             jb     Loop        ; keep looping (jump) if temp < n
29 C8             sub    eax, ecx    ; temp -= n
C3                ret                ; return temp
               HowFarAway ENDP

उपरोक्त फ़ंक्शन दो पूर्णांक पैरामीटर लेता है, n( ECXरजिस्टर में पारित ) और b( EDXरजिस्टर में पारित ), और एक पूर्णांक परिणाम ( EAXरजिस्टर में) देता है। C से इसे कॉल करने के लिए, आप निम्न प्रोटोटाइप का उपयोग करेंगे:

unsigned HowFarAway(unsigned n, unsigned b);

यह 32-बिट पूर्णांक की सीमा तक सीमित है। पूर्ण लंबी रजिस्टरों का उपयोग करके 64-बिट पूर्णांकों का समर्थन करने के लिए इसे आसानी से संशोधित किया जा सकता है, लेकिन उन निर्देशों को एनकोड करने के लिए अधिक बाइट्स खर्च होंगे। :-)

— कोडी ग्रे
स्रोत

तो, आप 4 से कम बाइट्स में 1 को eax सेट नहीं कर सकते हैं?

— नील

हम्म ... नहीं में से किसी सामान्य तरीके कि एक समझदार प्रोग्रामर का प्रयोग करेंगे, लेकिन आप कर सकते थे push 1+ pop raxमें केवल 3 बाइट्स। लेकिन ... फिर आपको गुणा को छोड़ना नहीं पड़ेगा, ताकि आप अभी भी एक उचित बचत कर सकें क्योंकि आप छोड़ सकते हैं jmp।

— कोडी ग्रे

आह, मुझे पता था कि वहाँ एक रास्ता है एक बाइट बंद गोल्फ!

— नील

आप लिनक्स पर SysV कॉलिंग कन्वेंशन के साथ TIO डेमो के साथ भी ऐसा कर सकते हैं ।

— डिजिटल ट्रामा

निःसंदेह तुमसे हो सकता है। आप इसे किसी भी कॉलिंग कन्वेंशन के साथ कर सकते हैं जो रजिस्टरों में कम से कम पहले दो पूर्णांक मापदंडों को पास करता है। सिस्टम V, विन x64, Win32 __fastcall, आदि रजिस्टर बस बदलते हैं, और मुझे एक चुनना था। सिक्का "विंडोज" आया।

— कोडी ग्रे

6

सी (जीसीसी) , 39 35 बाइट्स

एरिक के लिए नया अपरिभाषित व्यवहार

f(n,b,i){for(i=b;b<=n;b*=i);n=b-n;}

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

— cleblanc
स्रोत

f(n,b,i){for(i=b;b<n;b*=i);n=b-n;}5 बाइट्स बचाता है, और जीसीसी द्वारा समर्थित है

— एरिक आउटगोल्फर

@EriktheOutgolfer क्यों नहीं b-=n?

— लीक नून

@LeakyNun क्योंकि यह पहला तर्क है जिसे आपको रिटर्न मान को सहेजने की आवश्यकता है।

— निकोल आउटफर गोल्फ

उम्म, आपने कोड अपडेट नहीं किया।

— आउटगॉल्फ

आप कर सकते हैं b-=nयदि आप के आदेश स्वैप bऔर n?

— जकार्इ

6

Dyalog एपीएल, 10 बाइट्स

2 बाइट्स @ZacharyT की बदौलत बच गए

⊢-⍨⊣*1+∘⌊⍟

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

nसही तर्क के bरूप में और बाएं तर्क के रूप में लेता है।

गणना करता है ।b^{⌊log_bn + 1⌋} - n

— Uriel
स्रोत

अच्छा, मैं बस इस सटीक समाधान को पोस्ट करने वाला था

— क्रिति लिथोस

@KritiiLithos मेरे पास फर्श की चाल के साथ कठिन समय था। आपको लगता है कि यह एक ट्रेन में बनाया जा सकता है?

— उरेल

हाँ, यह कर सकते हैं ⊣-⍨⊢*1+∘⌊⍟⍨:।

— जकार्इ

@ZacharyT अच्छा है!

— उरेल

मैं ⊢-⍨⊣*1+∘⌊⍟10 बाइट्स के लिए हूं, लेकिन बदली हुई दलीलों के साथ इसलिए कि nसही तर्क है और bबाएं तर्क है। मैं ZacharyT की चाल का उपयोग 1+∘⌊करने के लिए इसे दूर इस नीचे मिलता है।

— क्रिति लिथोस

6

आर , 38 34 बाइट्स

pryr::f({a=b^(0:n)-n;min(a[a>0])})

अनाम फ़ंक्शन। बी में सभी चीजों की शक्ति के सभी मानों को स्टोर करता है [0, n], प्रत्येक से n घटाता है, पॉजिटिव वैल्यू पर सब्मिट करता है, और मिन वापस करता है।

TIO का एक गैर-प्राइअर संस्करण है, जिसे कहा जाता है f(n,b); इस संस्करण को कहा जाना चाहिए f(b,n)।

जर्को डबेलडैम के लिए 4 बाइट्स को धन्यवाद दिया, जिन्होंने फिर मुझे अपमानित किया।

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

— बीएलटी
स्रोत

अच्छा, जिस तरह से मैं मन में था की तुलना में कम है।

— JAD

pryr::f({a=b^(0:n)-n;min(a[a>0])})कुछ बाइट्स कम है।

— JAD

धन्यवाद। pryr::fजब मैं फ़ंक्शन में एक नया चर परिभाषित करता हूं, तो मुझे खराब किस्मत मिली है ; ऐसा लगता है कि यह यहाँ काम करता है।

— बीएलटी

2

हम्म, यह हमेशा जाँच के लायक है :) मुझे क्या गुस्सा आता है अगर आपके पास ऐसा कुछ है sapply(x, sum)या जो कुछ भी है, जो इसे sumतर्कों में जोड़ता है।

— JAD

4

क्यूबिक्स , 24 20 बाइट्स

-4 बाइट्स मिकीटी के लिए धन्यवाद

Pwp.I|-.;)^0@O?|uq;<

जैसे इनपुट में पढ़ता है n,b

एक 2x2x2 घन पर फिट बैठता है:

    P w
    p .
I | - . ; ) ^ 0
@ O ? | u q ; <
    . .
    . .

स्पष्टीकरण:

I|I0 : इनपुट पढ़ें, 0 (काउंटर) को स्टैक पर धकेलें

^w आईपी को लूप के लिए सही जगह पर रखता है:

Pp-: कंप्यूट b^(counter), nस्टैक के शीर्ष पर जाएं, गणना करेंb^(counter) - n
? : यदि नकारात्मक हो तो बाएं मुड़ें, यदि 0 सीधे, तो सकारात्मक
- पॉजिटिव: O@स्टैक (दूरी) और बाहर निकलने का आउटपुट टॉप।
- ऋणात्मक:: |?आगे बढ़ें मानो स्टैक के शीर्ष शून्य थे
<;qu;): आईपी को सही दिशा में इंगित करें, स्टैक के शीर्ष (नकारात्मक / शून्य संख्या) nको पॉप करें, स्टैक के निचले भाग में जाएं, यू-टर्न, स्टैक के शीर्ष पर पॉप करें ( b^(counter)) और काउंटर को बढ़ाएं।
आईपी पर है ^wऔर कार्यक्रम जारी है।

इसे ऑनलाइन देखें!

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

— ग्यूसेप
स्रोत

1

अपनी उसी प्रक्रिया का उपयोग करते हुए, बस एक अलग रास्ताPwp.I|-.;)^0@O?|uq;<

— मिकटी

@ मिक्की जीनियस! मुझे लगता है कि हर बार जब मैं एक क्यूबिक्स का जवाब प्रस्तुत करता हूं, तो आप साथ आते हैं और चार-पांच बाइट्स निकालते हैं ...

— Giuseppe

3

हास्केल , 20 बाइट्स

n%b=until(>n)(*b)1-n

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

until दिन बचाता है

— XNOR
स्रोत

ऑउग, मुझे पता था कि उसके लिए एक बिलिन होना चाहिए था। अच्छा लगा।

— वरफंडेल

2

05AB1E , 9 8 बाइट्स

sLmʒ‹}α¬

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

व्याख्या

s         # swap order of the inputs
 L        # range [1 ... n]
  m       # raise b to each power
   ʒ‹}    # filter, keep only the elements greater than n
      α   # calculate absolute difference with n for each
       ¬  # get the first (smallest)

— Emigna
स्रोत

1

आपने मुझे एक मिनट तक हराया। ठीक यही मैंने लिखा है, लेकिन मैंने ćइसके बजाय इस्तेमाल किया ¬।

— रिले

@ रिले: फिल्टर के साथ भी काम करता है, लेकिन दुर्भाग्य से किसी भी बाइट को नहीं बचाता है।

— इमीना

1

@Eignign दुर्भाग्य से किसी भी बाइट को नहीं बचाता है * बाइट (ओं) को बचाता है

— एग्री द आउटगॉल्फ

@EriktheOutgolfer: हाँ, ठीक है। यह एक अतिरिक्त परिवर्तन था जो कि बाईट को बचाने वाले अजीब तरह के अंतर्निहित इनपुट कार्यों का उपयोग करता था :)

— Emigna

1

@ आरोसोकोम्पुटिंग: हाँ। यह वास्तव में उन्हें "गलत" क्रम में रखने के लिए एक बाइट बचाता है क्योंकि मैं nफ़िल्टर तुलना और पूर्ण अंतर गणना दोनों में निहित रूप से पुन: उपयोग कर सकता हूं ।

— एमिग्ना

2

जावा (ओपनजेडके 8) , 42 बाइट्स

@ गोविंदपरमार के सी जवाब पर आधारित ।

n->b->{for(int o=b;n>=b;b*=o);return b-n;}

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

— बैशफुल बेलुगा
स्रोत

2

MATL , 10 9 बाइट्स

yy:YAn^w-

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

व्याख्या

इनपुट पर विचार करें 694और 3एक उदाहरण के रूप में।

y    % Implicitly take two inputs. Duplicate from below
     % STACK: 694, 3, 694
y    % Duplicate from below
     % STACK: 694, 3, 694, 3
:    % Range
     % STACK: 694, 3, 694, [1 2 3]
YA   % Base conversion (of 694 with "digits" given by [1 2 3]
     % STACK: 694, 3, [3 3 2 3 1 2]
n    % Number of elements
     % STACK: 694, 3, 6
^    % Power
     % 694, 729
w    % Swap
     % STACK: 729, 694
-    % Subtract. Implicitly display
^    % 35

— लुइस मेंडो
स्रोत

2

जावास्क्रिप्ट (ईएस 6), 29 बाइट्स

रिक के दृष्टिकोण के समान है, लेकिन उसकी अनुमति के साथ पोस्ट किया गया (और कुछ बाइट को बचाने में मदद करता है)।

n=>b=>g=(x=b)=>x>n?x-n:g(x*b)

कोशिश करो

f=
n=>b=>g=(x=b)=>x>n?x-n:g(x*b)
oninput=_=>o.value=f(+i.value)(+j.value)()
o.value=f(i.value=324)(j.value=5)()

*{font-family:sans-serif;}
input{margin:0 5px 0 0;width:50px;}

<label for=i>n: </label><input id=i type=number><label for=j>b: </label><input id=j type=number><label for=o>= </label><input id=o>

स्निपेट का विस्तार करें

— झबरा
स्रोत

2

गणितज्ञ, 24 बाइट्स

#2^⌊1/#~Log~#2⌋#2-#&

धन्यवाद मार्टिन

आई / ओ

[३४३, 7]

2058

— J42161217
स्रोत

आप उपयोग कर सकते हैं 1/Log@##या #2~Log~#। या इससे भी बेहतर इनपुट और उपयोग के क्रम को स्वैप करें Log@##।

— मार्टिन एंडर

और फिर #^Floor[...]#से छोटा है #^(Floor[...]+1)। और वहाँ यूनिकोड ऑपरेटरों के लिए Floorभी है।

— मार्टिन एंडर

हाँ, हाँ बिलकुल। मैं इन सब पर काम कर रहा हूँ। आप जल्दी!

— J42161217

मत भूलना Log@##! वास्तव में, यदि आप तर्क क्रम को स्वैप करते हैं, तो #^⌊Log@##⌋#-#2&-5 बाइट्स के लिए संभव होना चाहिए (मुझे लगता है)!

— कैलक्यूलेटरफल

2

सी, 42 40 बाइट्स

टिप के लिए टिप्पणी करने वाले @Steadybox को धन्यवाद

o;p(n,b){for(o=b;n>=b;)b*=o;return b-n;}

— गोविंद परमार
स्रोत

2

दो बाइट्स सहेजने के forबजाय का उपयोग करना while:o;p(n,b){for(o=b;n>=b;)b*=o;return b-n;}

— स्टेडीबॉक्स

के n/bबजाय सुझावn>=b

— छत

2

आर, 30 बाइट्स

pryr::f(b^floor(log(n,b)+1)-n)

फ़ंक्शन का मूल्यांकन करता है

function (b, n) 
b^floor(log(n, b) + 1) - n

जो पहली शक्ति को अधिक से अधिक या बराबर लेता है n, और फिर घटता हैn उस मूल्य से है।

बदल दिया ceiling(power)करने के लिए floor(power+1)सुनिश्चित करना है कि अगर nकी एक शक्ति है b, हम अगले शक्ति ले लो।

— JAD
स्रोत

1

जावास्क्रिप्ट (ईएस 6), 31 बाइट्स

f=(n,b,i=b)=>b>n?b-n:f(n,b*i,i)

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

कोड स्निपेट दिखाएं

f=(n,b,i=b)=>b>n?b-n:f(n,b*i,i)

console.log(f(212, 2)) // 44
console.log(f(563, 5)) // 62
console.log(f(491, 5)) // 134
console.log(f(424, 3)) // 305
console.log(f(469, 8)) // 43
console.log(f(343, 7)) // 2058
console.log(f(592, 7)) // 1809
console.log(f(289, 5)) // 336
console.log(f(694, 3)) // 35
console.log(f(324, 5)) // 301

स्निपेट का विस्तार करें

— रिक हिचकॉक
स्रोत

आप एक बाइट को करीने से बचा सकते हैं (इससे कोई फर्क नहीं पड़ता कि मैंने दोनों nऔर bया सिर्फ करीने की कोशिश की n), क्योंकि यह आपको nपुनरावर्ती पास होने से बचाता है ।

— नील

धन्यवाद @ नील, लेकिन मुझे यह पता लगाने में परेशानी हो रही है कि ऐसा कैसे किया जाए (?)

— रिक हिचकॉक

मैं जिन दो संस्करणों के साथ आया था वे थे n=>g=(b,p=b)=>p>n?p-n:g(b,p*b)और n=>b=>(g=p=>p>n?p-n:g(p*b))(b)।

— नील

f=(n,i)=>g=(b=i)=>b>n?b-n:g(b*i)30 बाइट्स के लिए काम करेंगे ? इसे ऐसे ही कहा जाना चाहिए f(324,5)():। संपादित करें: आह, @ नील ने मुझे हराया।

— झबरा

@ नील, धन्यवाद, मुझे करीने के साथ अधिक अभ्यास की आवश्यकता है।

— रिक हिचकॉक

1

ऑक्टेव , 32 बाइट्स

@(n,b)b^(fix(log(n)/log(b))+1)-n

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

— लुइस मेंडो
स्रोत

1

ऑक्टेव, 26 बाइट्स

@(n,b)b^sum(b.^(0:n)<=n)-n

सभी परीक्षण मामलों की पुष्टि करें!

— rahnema1
स्रोत

1

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

दो अलग-अलग दृष्टिकोण:

->(n,b){p b**(Math.log(n,b).to_i+1)-n}

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

->(n,b){p b**(0..n).find{|x|b**x>n}-n}

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

— Nnnes
स्रोत

1

हास्केल , 31 बाइट्स

f n b=[b^x-n|x<-[1..],b^x>n]!!0

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

— vroomfondel
स्रोत

1

पर्ल 6 , 31 30 29 बाइट्स

->\n,\b{(b,b* *...*>n).tail -n}

यह परीक्षण (31)

->\n,\b{b**(log(n,b).Int+1)-n}

यह परीक्षण (30)

{$^b**(log($^a,$b).Int+1)-$a}

यह परीक्षण (29)

{($^b,$b* *...*>$^a).tail-$a}

यह परीक्षण (29)

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

1

PARI / GP , 26 24 बाइट्स

f(n,b)=b^logint(b*n,b)-n

— चार्ल्स
स्रोत

1

जाप , 9 बाइट्स

_q}a@nVpX

इसे ऑनलाइन टेस्ट करें!

व्याख्या

_  q}a@  nVpX
Z{Zq}aX{UnVpX}  // Ungolfed
                // Implicit: U, V = input integers
     aX{     }  // For each integer X in [0...1e9), take
          VpX   //   V to the power of X
        Un      //   minus U,
Z{  }           // and return the first one Z where
  Zq            //   Math.sqrt(Z) is truthy.
                //   Math.sqrt returns NaN for negative inputs, and 0 is falsy, so this is
                //   truthy iff Z is positive. Therefore, this returns the first positive
                //   value of V**X - U.
                // Implicit: output result of last expression

— ETHproductions
स्रोत

1

... रुकिए। क्या?

— शैगी

@ शैगी मैंने एक स्पष्टीकरण जोड़ा है, उम्मीद है कि यह मदद करता है।

— ETHproductions

1

पायथन , 42 41 बाइट्स

f=lambda a,b,v=1:(a<v)*(v-a)or f(a,b,v*b)

एक पुनरावर्ती कार्य, जो शुरू होता है v=1, बार-बार गुणा करता है bजब तक कि यह सख्ती से अधिक नहीं हो जाता है aऔर फिर अंतर को वापस करता है।

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

नोट: परिणाम कभी भी शून्य नहीं होगा इसलिए पुनरावृत्ति त्रुटियों के बिना a>=v and f(a,b,v*b)or v-aप्रतिस्थापित किया जा सकता है (a<v)*(v-a)or f(a,b,v*b)।

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

रिसी के विचार का उपयोग करना ...

f=lambda n,b:(n<b)*(b-n)or b*f(n/b,b)

जो फ़्लोटिंग पॉइंट अंकगणित का उपयोग करता है (इसलिए परिणाम उनकी वास्तविक दूरी से भटक सकते हैं),
यहाँ कोशिश करें ।

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

tio.run/… थोड़ा छोटा है, लेकिन "% .0f" प्रारूप के साथ परिणाम का उत्पादन करना शायद धोखा है।

— रिसी

@rici नाइस, मुझे लगता है कि फ्लोटिंग पॉइंट अंकगणित का उपयोग करना ठीक हो सकता है। मैं इसे एक विकल्प के रूप में जोड़ूंगा (एक और बाइट फॉर्म को स्विच करने से बचाया जा सकता है क्योंकि यह b-nकभी भी शून्य नहीं है क्योंकि n<bयह सच है)।

— जोनाथन एलन

1

ब्रेकीलॉग , 7 बाइट्स

^ʰ↙X>₁-

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

सूची के रूप में इनपुट लेता है [b, n]।

    >₁     n is strictly less than
^ ↙X       some power of
 ʰ         b,
      -    and their difference is
           the output.

— असंबंधित स्ट्रिंग
स्रोत

0

PHP> = 7.1, 46 बाइट्स

for([,$n,$b]=$argv;0>=$d=$b**$i++-$n;);echo$d;

PHP सैंडबॉक्स ऑनलाइन

— जार्ग हुल्सरमन
स्रोत

0

लुआ, 74 73 बाइट

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

संपादित करें: अंतरिक्ष को हटाने के लिए भूल गया w=1 n=n+0, एक बाइट बचाता है

n,b=...b=b+0p=b w=1n=n+0while p<=n do p=math.pow(b,w)w=w+1 end print(p-n)

व्याख्या की

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

n,b=...           -- unpack the argument into the variable n and b
b=b+0             -- set b's type to number
n=n+0             -- set n's type to number
p=b               -- set a variable to track the current value of the powered b
w=1               -- set the nth power
while p<=n        -- iterate untill the current power is greater or equals to n
do
  p=math.pow(b,w) -- raise b to the power w
  w=w+1           -- increment w
end
print(p-n)        -- outputs p minus the following power of b

— Katenkyo
स्रोत

मैं लुआ को अच्छी तरह से नहीं जानता, लेकिन क्या बीच की जगह 1और endजरूरत है?

— जकार्इ

@ZacharyT लुआ में, हेक्साडेसिमल संख्याओं को इनलाइन किया जा सकता है यदि वे एक संख्या के साथ शुरू करते हैं, तो 1endसंख्या के रूप में व्याख्या की जानी शुरू हो जाएगी, 1eफिर एक त्रुटि को फेंक दें क्योंकि 1enवैध हेक्साडेसिमल मान नहीं है। यह केवल तभी होता है जब संख्या का अनुसरण करने वाला अक्षर [abcdef]अन्य अक्षरों के रूप में व्याख्या किया जा सकता है क्योंकि हेक्साडेसिमल मान -> w=1whileएक त्रुटि नहीं फेंकता है।

— कटेन्को

PPCG में आपका स्वागत है!

— लीक नून

0

QBIC , 23 बाइट्स

{p=:^q~p>:|_xp-b|\q=q+1

bपहले पैरामीटर लेता है , फिर n।

व्याख्या

{       DO
p=:^q   SET p to input b (read as 'a' by QBIC fromt he cmd line) ** q (starts as 1)
~p>:    IF p exceeds 'n' (read as 'b' by QBIC fromt he cmd line)
|_xp-b| THEN QUIT, printing p minus b
\q=q+1  ELSE increase q, re-run

— steenbergh
स्रोत

0

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

@ रॉड के पाश सरलीकरण ने 7 बाइट बचाए!

पुनरावृत्ति या बिट ट्विडलिंग के बिना पूरा कार्यक्रम:

i=1;n,b=input()
while n>=i:i*=b
print i-n

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

इनपुट प्रारूप: n, b।

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

आप 7 बाइट्स को कम करने के लिए लूप को सरल बना सकते हैं

— रॉड

@Rod ने कभी ऐसा नहीं सोचा होगा :)। आपका बहुत बहुत धन्यवाद!

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

0

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

^{2 बाइट्स बचाने के लिए EriktheOutgolfer का धन्यवाद!}

lambda n,b:b**-~int(math.log(n,b))-n
import math

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

पायथन के पास कोई फैंसी लॉग या सीलिंग बिलिन नहीं है, इसलिए मैं बस थोड़ा गोल्फिंग फ्लेयर के साथ स्पष्ट दृष्टिकोण के साथ गया।

— notjagan
स्रोत

import math;lambda n,b:b**-~int(math.log(n,b))-nदो बाइट्स बचाता है और प्रति मेटा सहमति की अनुमति है।

— १g पर आउटगोल्फ

@EriktheOutgolfer ceilकाम नहीं करेगा।

— लीक नून

@EriktheOutgolfer मैं उपयोग नहीं कर रहा था ceilक्योंकि यह शक्तियों के लिए काम नहीं करता है b, लेकिन जैसा कि @Uriel ने बताया कि अभी भी एक बाइट को बचाने से पहले आयात किया जाता है।

— नॉटजगन

आप इसे पूरी तरह से ठीक होने के लिए पुन: स्वरूपित कर सकते हैं: इसे ऑनलाइन आज़माएं! । importलैम्ब्डा के बाद बस रखें , और f=हेडर में जोड़ें ।

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

@ Mr.Xcoder आह, आप सही हैं! मुझे नहीं पता कि मेरे साथ ऐसा क्यों नहीं हुआ।

— नॉटजगन

0

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

(defun f(n b)(setq a b)(loop(when(> b n)(return(- b n)))(setq b(* b a))))

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

— Steadybox
स्रोत

B की अगली शक्ति से n कितनी दूर है?

जेली , 4 3 बाइट्स

कैसे?

x86-64 असेंबली ( विंडोज x64 कॉलिंग कन्वेंशन ), 14 13 बाइट्स

सी (जीसीसी) , 39 35 बाइट्स

Dyalog एपीएल, 10 बाइट्स

आर , 38 34 बाइट्स

क्यूबिक्स , 24 20 बाइट्स

स्पष्टीकरण:

हास्केल , 20 बाइट्स

05AB1E , 9 8 बाइट्स

जावा (ओपनजेडके 8) , 42 बाइट्स

MATL , 10 9 बाइट्स

व्याख्या

जावास्क्रिप्ट (ईएस 6), 29 बाइट्स

कोशिश करो

गणितज्ञ, 24 बाइट्स

सी, 42 40 बाइट्स

आर, 30 बाइट्स

जावास्क्रिप्ट (ईएस 6), 31 बाइट्स

ऑक्टेव , 32 बाइट्स

ऑक्टेव, 26 बाइट्स

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

हास्केल , 31 बाइट्स

पर्ल 6 , 31 30 29 बाइट्स

PARI / GP , 26 24 बाइट्स

जाप , 9 बाइट्स

व्याख्या

पायथन , 42 41 बाइट्स

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

ब्रेकीलॉग , 7 बाइट्स

PHP> = 7.1, 46 बाइट्स

लुआ, 74 73 बाइट

व्याख्या की

QBIC , 23 बाइट्स

व्याख्या

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

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

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