Нехай 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цього прикладу.

Тести:

  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 Call Convention ), 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 байт

Нова невизначена поведінка завдяки Еріку

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

Спробуйте в Інтернеті!

Діалог APL, 10 байт

2 байти збережено завдяки @ZacharyT

⊢-⍨⊣*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 від кожного, підмножини на позитивні значення і повертає хв.

TIO має версію non-pryr, яку називають як f(n,b); цю версію потрібно назвати як f(b,n).

Збережено 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і програма продовжується.

Дивіться його в Інтернеті!

Спробуйте в Інтернеті!

Хаскелл , 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 байти

На основі відповіді C на адресу GovindParmar .

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 байт

Дуже схожий на підхід Ріка, але розміщений з його дозволу (а деякі допомагають зберегти байт).

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>

Математика, 24 байти

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

дякую Мартіне

I / O

[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

Octave, 32 bytes

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

Try it online!

Octave, 26 bytes

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

Verify all test cases!

Ruby, 38 bytes

Two different approaches:

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

Try it online!

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

Try it online!

Haskell, 31 bytes

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

Try it online!

Perl 6,  31 30  29 bytes

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

Test it (31)

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

Test it (30)

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

Test it (29)

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

Test it (29)

PARI/GP, 26 24 bytes

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

Japt, 9 bytes

_q}a@nVpX

Test it online!

Explanation

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

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

A recursive function which, starting with v=1, repeatedly multiplies by b until it strictly exceeds a and then returns the difference.

Try it online!

Note: The result will never be zero so a>=v and f(a,b,v*b)or v-a may be replaced with (a<v)*(v-a)or f(a,b,v*b) without causing recursion errors.

Python 3, 37 bytes?

Using an idea of rici's...

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

which uses floating point arithmetic (hence results may stray from their true distance),
try that here.

Brachylog, 7 bytes

^ʰ↙X>₁-

Try it online!

Takes input as a list [b, n].

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

PHP>=7.1, 46 bytes

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

PHP Sandbox Online

Lua, 74 73 Byte

A straight forward solution, I'm using 10 bytes to ensure that the arguments are treated as numbers, and not strings. Outputs to STDIN.

Edit: forgot to remove the space in w=1 n=n+0, saves one 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)

Explained

Try it online!

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 bytes

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

Takes parameter b first, then n.

Explanation

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

• @Rod's loop simplification saved 7 bytes!

Full program without recursion or bit twiddling:

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

Try it online!

Input format: n, b.

Python 3, 50 48 bytes

^{Thanks to EriktheOutgolfer for saving 2 bytes!}

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

Try it online!

Python doesn't have any fancy log or ceiling builtins, so I just went with the obvious approach with a little bit of golfing flair.

Common Lisp, 73 bytes

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

Try it online!