设n和b为大于的正整数1。

输出n到的下一个幂的距离b。

对于n=5和b=3，3from 的下一个幂5是9（3^2 = 9），所以输出是9 - 5 = 4。

对于n=8和b=2，2from 的下一个幂8是16（2^4 = 16），所以输出是16 - 8 = 8。请注意，在此示例n中2，这是的幂。

测试用例：

  n b output
212 2 44
563 5 62
491 5 134
424 3 305
469 8 43
343 7 2058
592 7 1809
289 5 336
694 3 35
324 5 301
  2 5 3

这是代码高尔夫球。以字节为单位的最短答案将获胜。有标准漏洞。

果冻， 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

x86-64程序集（Windows x64调用约定），14 13字节

一种低效（但很精巧！）的迭代方法（感谢@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位整数，但是对那些指令进行编码将花费更多的字节。:-)

C（gcc），39 35字节

借助Erik，新的未定义行为

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

在线尝试！

Dyalog APL，10个字节

@ZacharyT节省了2个字节

⊢-⍨⊣*1+∘⌊⍟

在线尝试！

注意到n作为右边的参数，并b为左参数。

计算。b⌊logbn + 1⌋ - n

R，38 34字节

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

匿名函数。将b的所有值存储为[0，n]范围内所有值的幂，然后从每个n的子集中减去n，再返回最小值。

TIO具有非代理版本，称为f(n,b)；此版本需要称为f(b,n)。

感谢Jarko Dubbeldam，节省了4个字节，然后让我超越了我。

在线尝试！

Cubix，24 20字节

-4个字节，感谢MickyT

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

读入像 n,b

适用于2x2x2立方体：

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

说明：

I|I0 ：读取输入，将0（计数器）压入堆栈

^w 将IP放入循环的正确位置：

• Pp-：计算b^(counter)，移至n堆栈顶部，计算b^(counter) - n
• ? ：如果为负，则向左转，如果为0，则为直线，如果为正，则向右
  • 正数：：O@输出栈顶（距离）并退出。
  • 负数：：|?就像栈顶为零一样进行
• <;qu;)：将IP指向正确的方向，弹出堆栈顶部（负数/零数字），移至n堆栈底部，掉头，弹出堆栈顶部（b^(counter)），然后增加计数器
• IP在^w，程序继续。

在线观看！

在线尝试！

Haskell，20个字节

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

在线尝试！

until 节省了一天

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)

Java（OpenJDK 8），42字节

基于@GovindParmar的C答案。

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

在线尝试！

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

JavaScript（ES6），29个字节

与Rick的方法非常相似，但在得到他的许可后发布（并且有些帮助保存了一个字节）。

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>

Mathematica，24个字节

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

谢谢马丁

输入输出

[343，7]

2058

C，42 40字节

感谢评论者@Steadybox的提示

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

R，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，我们将使用下一个幂。

JavaScript（ES6），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

八度，32字节

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

在线尝试！

八度，26字节

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

验证所有测试用例！

Ruby，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}

在线尝试！

Haskell，31个字节

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

在线尝试！

Perl 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）

PARI / GP，26 24字节

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

Japt，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

Python， 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)而不会引起递归错误。

Python 3，37个字节？

使用rici的想法...

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

使用浮点算法（因此结果可能偏离其真实距离），请
在此处尝试。

Brachylog，7个字节

^ʰ↙X>₁-

在线尝试！

将输入作为列表[b, n]。

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

PHP> = 7.1，46个字节

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

PHP沙盒在线

Lua，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

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

Python 2中，48 41个字节

• @Rod的循环简化节省了7个字节！

完整的程序，无需递归或纠结：

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

在线尝试！

输入格式：n, b。

Python 3中，50 48个字节

^{感谢EriktheOutgolfer节省了2个字节！}

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

在线尝试！

Python没有任何花哨的日志或上限内置函数，因此我只是采用了明显的方法，并带有一点打高尔夫球的风格。

Common Lisp，73个字节

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

在线尝试！