Hãy nvà bđược nguyên dương lớn hơn 1.

Xuất khoảng cách từ nđến sức mạnh tiếp theo của b.

Cho n=5và b=3, công suất tiếp theo của 3from 5là 9( 3^2 = 9), vì vậy đầu ra là 9 - 5 = 4.

Cho n=8và b=2, công suất tiếp theo của 2from 8là 16( 2^4 = 16), vì vậy đầu ra là 16 - 8 = 8. Lưu ý rằng đó nlà một sức mạnh 2trong ví dụ này.

Testcase:

  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

Đây là mã golf . Câu trả lời ngắn nhất trong byte thắng. Tiêu chuẩn áp dụng.

Thạch ,  4  3 byte

ạæċ

Một liên kết dyadic lấy nbên trái và bbên phải và trả về kết quả.

Hãy thử trực tuyến!

Làm sao?

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

Hội x86-64 ( Hội nghị gọi Windows x64 ), 14 13 byte

Một cách tiếp cận lặp lại không hiệu quả (nhưng mảnh dẻ!) (Có tín dụng cho @Neil để lấy cảm hứng):

               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

Hàm trên có hai tham số nguyên, n(được truyền trong thanh ECXghi) và b(được truyền trong thanh EDXghi) và trả về một kết quả số nguyên duy nhất (trong thanh EAXghi). Để gọi nó từ C, bạn sẽ sử dụng nguyên mẫu sau:

unsigned HowFarAway(unsigned n, unsigned b);

Điều này được giới hạn trong phạm vi của số nguyên 32 bit. Nó có thể dễ dàng sửa đổi để hỗ trợ các số nguyên 64 bit bằng cách sử dụng các thanh ghi dài đầy đủ, nhưng sẽ tốn nhiều byte hơn để mã hóa các hướng dẫn đó. :-)

C (gcc) , 39 35 byte

Hành vi mới không xác định nhờ Erik

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

Hãy thử trực tuyến!

APL Dyalog, 10 byte

2 byte được lưu nhờ @ZacharyT

⊢-⍨⊣*1+∘⌊⍟

Hãy thử trực tuyến!

Đưa ra nnhư là đối số phải và bnhư là đối số trái.

Tính toán .b⌊logbn + 1⌋ - n

R , 38 34 byte

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

Chức năng ẩn danh. Lưu trữ tất cả các giá trị của b vào sức mạnh của mọi thứ trong phạm vi [0, n], trừ n từ mỗi, tập hợp con trên các giá trị dương và trả về giá trị cực tiểu.

TIO có phiên bản không pryr, được gọi là f(n,b); phiên bản này cần được gọi là f(b,n).

Lưu được 4 byte nhờ Jarko Dubbeldam, người sau đó vượt xa tôi.

Hãy thử trực tuyến!

Hình khối , 24 20 byte

-4 byte nhờ MickyT

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

Đọc trong đầu vào như n,b

Phù hợp với khối lập phương 2x2x2:

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

Giải trình:

I|I0 : đọc đầu vào, đẩy 0 (bộ đếm) vào ngăn xếp

^w đặt IP đến đúng vị trí của vòng lặp:

• Pp-: tính toán b^(counter), di chuyển nlên đầu ngăn xếp, tính toánb^(counter) - n
• ? : rẽ trái nếu âm, thẳng nếu 0, phải nếu dương
  • Tích cực :: O@đầu ra của ngăn xếp (khoảng cách) và thoát.
  • Tiêu cực :: |?tiến hành như thể đỉnh của ngăn xếp bằng không
• <;qu;): trỏ IP theo đúng hướng, bật đỉnh của ngăn xếp (số âm / số không), di chuyển nxuống dưới cùng của ngăn xếp, quay đầu, bật đỉnh của ngăn xếp ( b^(counter)) và tăng bộ đếm
• IP đang ở ^wvà chương trình tiếp tục.

Xem nó trực tuyến!

Hãy thử trực tuyến!

Haskell , 20 byte

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

Hãy thử trực tuyến!

until tiết kiệm trong ngày

05AB1E , 9 8 byte

sLmʒ‹}α¬

Hãy thử trực tuyến!

Giải trình

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 byte

Dựa trên câu trả lời C của @ GovindParmar .

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

Hãy thử trực tuyến!

MATL , 10 9 byte

yy:YAn^w-

Hãy thử trực tuyến!

Giải trình

Xem xét đầu vào 694và 3làm ví dụ.

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 byte

Rất giống với cách tiếp cận của Rick nhưng được đăng với sự cho phép của anh ấy (và một số trợ giúp tiết kiệm một byte).

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

Thử nó

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>

Toán học, 24 byte

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

cảm ơn Martin

Tôi / O

[343, 7]

2058

C, 42 40 byte

Cảm ơn bình luận viên @Steadybox cho tiền boa

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

R, 30 byte

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

Đánh giá chức năng

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

Cái nào lấy công suất đầu tiên lớn hơn hoặc bằng n, và sau đó chất nền ntừ giá trị đó.

Thay đổi ceiling(power)để floor(power+1)đảm bảo rằng nếu nlà một sức mạnh của b, chúng tôi có sức mạnh tiếp theo.

JavaScript (ES6), 31 byte

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

Các trường hợp thử nghiệm:

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

Octave , 32 byte

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

Hãy thử trực tuyến!

Octave, 26 byte

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

Xác nhận tất cả các trường hợp thử nghiệm!

Ruby , 38 byte

Hai cách tiếp cận khác nhau:

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

Hãy thử trực tuyến!

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

Hãy thử trực tuyến!

Haskell , 31 byte

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

Hãy thử trực tuyến!

Perl 6 ,  31 30  29 byte

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

Kiểm tra nó (31)

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

Kiểm tra nó (30)

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

Kiểm tra nó (29)

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

Kiểm tra nó (29)

PARI / GP , 26 24 byte

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

Japt , 9 byte

_q}a@nVpX

Kiểm tra nó trực tuyến!

Giải trình

_  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 byte

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

Một hàm đệ quy, bắt đầu bằng v=1, lặp đi lặp lại nhân bcho đến khi nó hoàn toàn vượt quá avà sau đó trả về sự khác biệt.

Hãy thử trực tuyến!

Lưu ý: Kết quả sẽ không bao giờ bằng 0 nên a>=v and f(a,b,v*b)or v-acó thể được thay thế bằng (a<v)*(v-a)or f(a,b,v*b)mà không gây ra lỗi đệ quy.

Python 3, 37 byte?

Sử dụng một ý tưởng về ...

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

trong đó sử dụng số học dấu phẩy động (do đó kết quả có thể đi lạc từ khoảng cách thực của chúng),
hãy thử điều đó tại đây .

Brachylog , 7 byte

^ʰ↙X>₁-

Hãy thử trực tuyến!

Lấy đầu vào như một danh sách [b, n].

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

PHP> = 7.1, 46 byte

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

PHP Sandbox trực tuyến

Lua, 74 73 Byte

Một giải pháp chuyển tiếp thẳng, tôi đang sử dụng 10 byte để đảm bảo rằng các đối số được coi là số chứ không phải chuỗi. Đầu ra cho STDIN.

Chỉnh sửa: quên xóa khoảng trống trong w=1 n=n+0, lưu một byte

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)

Giải thích

Hãy thử trực tuyế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 byte

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

Đưa tham số btrước, sau đón .

Giải trình

{       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 byte

• @ Đơn giản hóa vòng lặp của Rod đã lưu 7 byte!

Chương trình đầy đủ mà không cần đệ quy hoặc twiddling:

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

Hãy thử trực tuyến!

Định dạng đầu vào : n, b.

Python 3 , 50 48 byte

^{Cảm ơn EriktheOutgolfer đã lưu 2 byte!}

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

Hãy thử trực tuyến!

Python không có bất kỳ bản dựng hoặc trần nhà ưa thích nào, vì vậy tôi chỉ đi theo cách tiếp cận rõ ràng với một chút tinh tế của môn đánh gôn.

Lisp thông thường, 73 byte

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

Hãy thử trực tuyến!