32
\$\begingroup\$

Let n and b be positive integers larger than 1.

Output the distance from n to the next power of b.

For n=5 and b=3, the next power of 3 from 5 is 9 (3^2 = 9), so the output is 9 - 5 = 4.

For n=8 and b=2, the next power of 2 from 8 is 16 (2^4 = 16), so the output is 16 - 8 = 8. Note that n is a power of 2 in this example.

Testcases:

  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

This is . Shortest answer in bytes wins. Standard loopholes apply.

\$\endgroup\$

38 Answers 38

16
\$\begingroup\$

Jelly,  4  3 bytes

ạæċ

A dyadic link taking n on the left and b on the right and returning the result.

Try it online!

How?

ạæċ - Link: number n, number b | n,b ∈ ℕ
 æċ - ceiling n to the next power of b
ạ   - absolute difference between n and that
\$\endgroup\$
  • 4
    \$\begingroup\$ Crossed out 4 is still regular 4 ;( \$\endgroup\$ – Uriel Jun 19 '17 at 13:53
  • 2
    \$\begingroup\$ @Uriel But   ;) \$\endgroup\$ – HyperNeutrino Jun 19 '17 at 13:56
  • \$\begingroup\$ tfw your initially initial thought is "oh it's æċ!" instead of "oww this is sooo hard..." \$\endgroup\$ – Erik the Outgolfer Jun 19 '17 at 14:04
  • \$\begingroup\$ Oh it might not exist in the history, but I did change from a 4 byter. It was æċ_⁸ \$\endgroup\$ – Jonathan Allan Jun 19 '17 at 14:06
  • \$\begingroup\$ @JonathanAllan Since it wasn't in the history it didn't make sense and that's why I edited that out. \$\endgroup\$ – Erik the Outgolfer Jun 19 '17 at 14:11
8
\$\begingroup\$

x86-64 Assembly (Windows x64 Calling Convention), 14 13 bytes

An inefficient (but svelte!) iterative approach (with credit to @Neil for inspiration):

               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

The above function takes two integer parameters, n (passed in the ECX register) and b (passed in the EDX register), and returns a single integer result (in the EAX register). To call it from C, you would use the following prototype:

unsigned HowFarAway(unsigned n, unsigned b);

This is limited to the range of a 32-bit integer. It can be easily modified to support 64-bit integers by using the full long registers, but it would cost more bytes to encode those instructions. :-)

\$\endgroup\$
  • \$\begingroup\$ So, you can't set eax to 1 in fewer than 4 bytes? \$\endgroup\$ – Neil Jun 19 '17 at 15:31
  • \$\begingroup\$ Hmm… Not in any of the normal ways that a sane programmer would use, but you could push 1+pop rax in only 3 bytes. But… then you wouldn't have to skip the multiplication, so that would still be a reasonable savings because you could drop the jmp. \$\endgroup\$ – Cody Gray Jun 19 '17 at 15:35
  • \$\begingroup\$ Ah, I knew there had to be a way to golf a byte off! \$\endgroup\$ – Neil Jun 19 '17 at 15:41
  • \$\begingroup\$ You can do the same with the SysV calling convention on Linux, with a TIO demo. \$\endgroup\$ – Digital Trauma Jun 20 '17 at 0:25
  • \$\begingroup\$ Of course you can. You can do it with any calling convention that passes at least the first two integer parameters in registers. System V, Win x64, Win32 __fastcall, etc. The registers just change, and I had to pick one. Coin came up "Windows". \$\endgroup\$ – Cody Gray Jun 20 '17 at 10:51
6
\$\begingroup\$

C (gcc), 39 35 bytes

New undefined behavior thanks to Erik

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

Try it online!

\$\endgroup\$
  • \$\begingroup\$ f(n,b,i){for(i=b;b<n;b*=i);n=b-n;} saves 5 bytes, and is supported by gcc \$\endgroup\$ – Erik the Outgolfer Jun 19 '17 at 14:16
  • \$\begingroup\$ @EriktheOutgolfer why not b-=n? \$\endgroup\$ – Leaky Nun Jun 19 '17 at 14:22
  • \$\begingroup\$ @LeakyNun Because it's the first argument you need to save the return value to. \$\endgroup\$ – Erik the Outgolfer Jun 19 '17 at 14:23
  • \$\begingroup\$ Umm, you didn't update the code. \$\endgroup\$ – Erik the Outgolfer Jun 19 '17 at 14:32
  • \$\begingroup\$ Can you do b-=n if you swap the order of b and n? \$\endgroup\$ – Zacharý Jun 19 '17 at 14:33
6
\$\begingroup\$

Dyalog APL, 10 bytes

2 bytes saved thanks to @ZacharyT

⊢-⍨⊣*1+∘⌊⍟

Try it online!

Takes n as right argument and b as left argument.

Calculates b⌊logbn + 1⌋ - n.

\$\endgroup\$
  • \$\begingroup\$ Nice, I was just about to post this exact solution \$\endgroup\$ – Cows quack Jun 19 '17 at 14:03
  • \$\begingroup\$ @KritixiLithos I had hard time with the floor trick. you think it could be made into a train? \$\endgroup\$ – Uriel Jun 19 '17 at 14:12
  • \$\begingroup\$ Yeah, it can: ⊣-⍨⊢*1+∘⌊⍟⍨. \$\endgroup\$ – Zacharý Jun 19 '17 at 14:21
  • \$\begingroup\$ @ZacharyT nice one! \$\endgroup\$ – Uriel Jun 19 '17 at 14:25
  • \$\begingroup\$ I get ⊢-⍨⊣*1+∘⌊⍟ for 10 bytes but with swapped arguments so that n is the right argument and b is the left argument. I used ZacharyT's trick of 1+∘⌊ to get it down this far. \$\endgroup\$ – Cows quack Jun 19 '17 at 14:27
6
\$\begingroup\$

R, 38 34 bytes

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

Anonymous function. Stores all values of b to the power of everything in the range [0,n], subtracts n from each, subsets on positive values, and returns the min.

TIO has a non-pryr version, called as f(n,b); this version needs to be called as f(b,n).

Saved 4 bytes thanks to Jarko Dubbeldam, who then outgolfed me.

Try it online!

\$\endgroup\$
  • \$\begingroup\$ Nice, way shorter than the recursion I had in mind. \$\endgroup\$ – JAD Jun 20 '17 at 9:43
  • \$\begingroup\$ pryr::f({a=b^(0:n)-n;min(a[a>0])}) is a few bytes shorter. \$\endgroup\$ – JAD Jun 20 '17 at 9:44
  • \$\begingroup\$ Thanks. I've had bad luck using pryr::f when I define a new variable in the function; looks like it works here. \$\endgroup\$ – BLT Jun 20 '17 at 14:41
  • 2
    \$\begingroup\$ Hmm, it's always worth checking :) What annoys me is if you have something like sapply(x, sum) or whatever, that it adds sum to the arguments. \$\endgroup\$ – JAD Jun 21 '17 at 6:28
4
\$\begingroup\$

Cubix, 24 20 bytes

-4 bytes thanks to MickyT

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

Reads in input like n,b

Fits on a 2x2x2 cube:

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

Explanation:

I|I0 : read the input, push 0 (counter) to the stack

^w puts the IP to the right place for the loop:

  • Pp- : compute b^(counter), move n to top of stack, compute b^(counter) - n
  • ? : turn left if negative, straight if 0, right if positive
    • Positive: O@ : output top of stack (distance) and exit.
    • Negative : |? : proceed as if the top of the stack were zero
  • <;qu;) : point the IP in the right direction, pop the top of the stack (negative/zero number), move n to the bottom of the stack, u-turn, pop the top of the stack (b^(counter)) and increment the counter
  • IP is at ^w and the program continues.

Watch it online!

Try it online!

\$\endgroup\$
  • 1
    \$\begingroup\$ Using your same procedure, just a different path Pwp.I|-.;)^0@O?|uq;< \$\endgroup\$ – MickyT Jun 19 '17 at 19:16
  • \$\begingroup\$ @MickyT genius! I feel like every time I submit a cubix answer, you come along and shave off four or five bytes... \$\endgroup\$ – Giuseppe Jun 19 '17 at 19:51
3
\$\begingroup\$

Haskell, 20 bytes

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

Try it online!

until saves the day

\$\endgroup\$
  • \$\begingroup\$ Augh, I knew there must have been a builtin for that. Nice. \$\endgroup\$ – vroomfondel Jun 20 '17 at 15:02
2
\$\begingroup\$

05AB1E, 9 8 bytes

sLmʒ‹}α¬

Try it online!

Explanation

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)
\$\endgroup\$
  • 1
    \$\begingroup\$ You beat me by a minute. That's exactly what I wrote, but I used ć instead of ¬. \$\endgroup\$ – Riley Jun 19 '17 at 13:54
  • \$\begingroup\$ @Riley: Also works with filter, but unfortunately doesn't save any bytes. \$\endgroup\$ – Emigna Jun 19 '17 at 13:58
  • 1
    \$\begingroup\$ @Emigna unfortunately doesn't save any bytes *saves byte(s)* \$\endgroup\$ – Erik the Outgolfer Jun 19 '17 at 14:00
  • \$\begingroup\$ @EriktheOutgolfer: Yes, well. It was an additional change utilizing the weird way implicit input works that saved a byte :) \$\endgroup\$ – Emigna Jun 19 '17 at 14:01
  • 1
    \$\begingroup\$ @carusocomputing: Yes. It actually saves a byte to have them in the "wrong" order as I can reuse n implicitly, both in the filter comparison and the absolute difference calculation. \$\endgroup\$ – Emigna Jun 19 '17 at 14:33
2
\$\begingroup\$

Java (OpenJDK 8), 42 bytes

Based on @GovindParmar's C answer.

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

Try it online!

\$\endgroup\$
2
\$\begingroup\$

MATL, 10 9 bytes

yy:YAn^w-

Try it online!

Explanation

Consider inputs 694 and 3 as an example.

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
\$\endgroup\$
2
\$\begingroup\$

JavaScript (ES6), 29 bytes

Very similar to Rick's approach but posted with his permission (and some help saving a byte).

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

Try it

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>

\$\endgroup\$
2
\$\begingroup\$

Mathematica, 24 bytes

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

thanks Martin

I/O

[343, 7]

2058

\$\endgroup\$
  • \$\begingroup\$ You can use 1/Log@## or #2~Log~#. Or even better swap the order of the inputs and use Log@##. \$\endgroup\$ – Martin Ender Jun 19 '17 at 14:06
  • \$\begingroup\$ And then #^Floor[...]# is shorter than #^(Floor[...]+1). And there's the Unicode operators for Floor as well. \$\endgroup\$ – Martin Ender Jun 19 '17 at 14:07
  • \$\begingroup\$ yes, yes of course.I'm working on all these.you are quick! \$\endgroup\$ – J42161217 Jun 19 '17 at 14:18
  • \$\begingroup\$ Don't forget Log@##! Actually, if you swap the argument order, #^⌊Log@##⌋#-#2& should be possible for -5 bytes (I think)! \$\endgroup\$ – CalculatorFeline Jun 19 '17 at 16:05
2
\$\begingroup\$

C, 42 40 bytes

Thanks to commenter @Steadybox for the tip

o;p(n,b){for(o=b;n>=b;)b*=o;return b-n;}
\$\endgroup\$
  • 2
    \$\begingroup\$ Using for instead of while saves two bytes: o;p(n,b){for(o=b;n>=b;)b*=o;return b-n;} \$\endgroup\$ – Steadybox Jun 19 '17 at 15:59
  • \$\begingroup\$ Suggest n/b instead of n>=b \$\endgroup\$ – ceilingcat May 9 at 16:27
2
\$\begingroup\$

R, 30 bytes

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

Evaluates to the function

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

Which takes the first power greater or equal than n, and then substracts n from that value.

Changed ceiling(power) to floor(power+1) to ensure that if n is a power of b, we take the next power.

\$\endgroup\$
1
\$\begingroup\$

JavaScript (ES6), 31 bytes

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

Test cases:

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

\$\endgroup\$
  • \$\begingroup\$ You can save a byte by currying (it didn't matter whether I tried currying both n and b or just n), because that saves you from having to pass n recursively. \$\endgroup\$ – Neil Jun 19 '17 at 14:17
  • \$\begingroup\$ Thanks @Neil, but I'm having trouble figuring out how to do that(?) \$\endgroup\$ – Rick Hitchcock Jun 19 '17 at 14:25
  • \$\begingroup\$ The two versions I came up with were n=>g=(b,p=b)=>p>n?p-n:g(b,p*b) and n=>b=>(g=p=>p>n?p-n:g(p*b))(b). \$\endgroup\$ – Neil Jun 19 '17 at 14:28
  • \$\begingroup\$ Would f=(n,i)=>g=(b=i)=>b>n?b-n:g(b*i) work for 30 bytes? It would need to be called like so: f(324,5)(). EDIT: Ah, @Neil beat me to it. \$\endgroup\$ – Shaggy Jun 19 '17 at 14:34
  • \$\begingroup\$ @Neil, thanks, I need more practice with currying. \$\endgroup\$ – Rick Hitchcock Jun 19 '17 at 14:42
1
\$\begingroup\$

Octave, 32 bytes

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

Try it online!

\$\endgroup\$
1
\$\begingroup\$

Octave, 26 bytes

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

Verify all test cases!

\$\endgroup\$
1
\$\begingroup\$

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!

\$\endgroup\$
1
\$\begingroup\$

Haskell, 31 bytes

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

Try it online!

\$\endgroup\$
1
\$\begingroup\$

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)

\$\endgroup\$
1
\$\begingroup\$

PARI/GP, 26 24 bytes

f(n,b)=b^logint(b*n,b)-n
\$\endgroup\$
1
\$\begingroup\$

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
\$\endgroup\$
  • 1
    \$\begingroup\$ ... Wait. What? \$\endgroup\$ – Shaggy Jun 19 '17 at 17:04
  • \$\begingroup\$ @Shaggy I've added an explanation, hopefully this helps. \$\endgroup\$ – ETHproductions Jun 19 '17 at 19:41
1
\$\begingroup\$

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.

\$\endgroup\$
  • \$\begingroup\$ tio.run/… is a bit shorter but having to output the result with format "%.0f" is probably cheating. \$\endgroup\$ – rici Jun 19 '17 at 19:40
  • \$\begingroup\$ @rici Nice, I think it may be OK to use floating point arithmetic. I'll add it as an alternative (another byte may be saved by switching forms due to b-n never being zero at the same time as n<b is true). \$\endgroup\$ – Jonathan Allan Jun 19 '17 at 19:56
1
\$\begingroup\$

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.
\$\endgroup\$
0
\$\begingroup\$

PHP>=7.1, 46 bytes

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

PHP Sandbox Online

\$\endgroup\$
0
\$\begingroup\$

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
\$\endgroup\$
  • \$\begingroup\$ I don't know Lua that well, but is the space between 1 and end needed? \$\endgroup\$ – Zacharý Jun 19 '17 at 14:40
  • \$\begingroup\$ @ZacharyT In Lua, hexadecimal numbers can be inlined if they start with a number, 1end would start to be interpreted as the number 1e then throw an error because 1en isn't a valid hexadecimal value. This only occure when the letter following the number is [abcdef] as other letters can't be interpreted as hexadecimal value -> w=1while doesn't throw an error. \$\endgroup\$ – Katenkyo Jun 19 '17 at 14:44
  • \$\begingroup\$ Welcome back to PPCG! \$\endgroup\$ – Leaky Nun Jun 19 '17 at 14:49
0
\$\begingroup\$

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
\$\endgroup\$
0
\$\begingroup\$

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.

\$\endgroup\$
  • \$\begingroup\$ You can simplify the loop to reduce 7 bytes \$\endgroup\$ – Rod Jun 19 '17 at 15:27
  • \$\begingroup\$ @Rod Would have never thought of that :). Thanks a lot! \$\endgroup\$ – Mr. Xcoder Jun 19 '17 at 15:29
0
\$\begingroup\$

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.

\$\endgroup\$
  • \$\begingroup\$ import math;lambda n,b:b**-~int(math.log(n,b))-n saves two bytes and is allowed per meta consensus. \$\endgroup\$ – Erik the Outgolfer Jun 19 '17 at 14:14
  • \$\begingroup\$ @EriktheOutgolfer ceil would not work. \$\endgroup\$ – Leaky Nun Jun 19 '17 at 14:15
  • \$\begingroup\$ @EriktheOutgolfer I wasn't using ceil because it doesn't work for powers of b, but as @Uriel pointed out importing before still saves a byte. \$\endgroup\$ – notjagan Jun 19 '17 at 14:18
  • \$\begingroup\$ You can reformat it to be completely fine: Try it online!. Just place the import after the lambda, and add f= in the header. \$\endgroup\$ – Mr. Xcoder Jun 19 '17 at 15:27
  • \$\begingroup\$ @Mr.Xcoder Ah, you are correct! I don't know why that didn't occur to me. \$\endgroup\$ – notjagan Jun 19 '17 at 15:30
0
\$\begingroup\$

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!

\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.