34
\$\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\$
0

44 Answers 44

17
\$\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\$
5
  • 4
    \$\begingroup\$ Crossed out 4 is still regular 4 ;( \$\endgroup\$
    – Uriel
    Jun 19, 2017 at 13:53
  • 3
    \$\begingroup\$ @Uriel But   ;) \$\endgroup\$
    – hyper-neutrino
    Jun 19, 2017 at 13:56
  • \$\begingroup\$ tfw your initially initial thought is "oh it's æċ!" instead of "oww this is sooo hard..." \$\endgroup\$ Jun 19, 2017 at 14:04
  • \$\begingroup\$ Oh it might not exist in the history, but I did change from a 4 byter. It was æċ_⁸ \$\endgroup\$ Jun 19, 2017 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\$ Jun 19, 2017 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\$
5
  • \$\begingroup\$ So, you can't set eax to 1 in fewer than 4 bytes? \$\endgroup\$
    – Neil
    Jun 19, 2017 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, 2017 at 15:35
  • \$\begingroup\$ Ah, I knew there had to be a way to golf a byte off! \$\endgroup\$
    – Neil
    Jun 19, 2017 at 15:41
  • \$\begingroup\$ You can do the same with the SysV calling convention on Linux, with a TIO demo. \$\endgroup\$ Jun 20, 2017 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, 2017 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\$
5
  • \$\begingroup\$ f(n,b,i){for(i=b;b<n;b*=i);n=b-n;} saves 5 bytes, and is supported by gcc \$\endgroup\$ Jun 19, 2017 at 14:16
  • \$\begingroup\$ @EriktheOutgolfer why not b-=n? \$\endgroup\$
    – Leaky Nun
    Jun 19, 2017 at 14:22
  • \$\begingroup\$ @LeakyNun Because it's the first argument you need to save the return value to. \$\endgroup\$ Jun 19, 2017 at 14:23
  • \$\begingroup\$ Umm, you didn't update the code. \$\endgroup\$ Jun 19, 2017 at 14:32
  • \$\begingroup\$ Can you do b-=n if you swap the order of b and n? \$\endgroup\$
    – Adalynn
    Jun 19, 2017 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\$
9
  • \$\begingroup\$ Nice, I was just about to post this exact solution \$\endgroup\$
    – user41805
    Jun 19, 2017 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, 2017 at 14:12
  • \$\begingroup\$ Yeah, it can: ⊣-⍨⊢*1+∘⌊⍟⍨. \$\endgroup\$
    – Adalynn
    Jun 19, 2017 at 14:21
  • \$\begingroup\$ @ZacharyT nice one! \$\endgroup\$
    – Uriel
    Jun 19, 2017 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\$
    – user41805
    Jun 19, 2017 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\$
4
  • \$\begingroup\$ Nice, way shorter than the recursion I had in mind. \$\endgroup\$
    – JAD
    Jun 20, 2017 at 9:43
  • \$\begingroup\$ pryr::f({a=b^(0:n)-n;min(a[a>0])}) is a few bytes shorter. \$\endgroup\$
    – JAD
    Jun 20, 2017 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, 2017 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, 2017 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\$
2
  • 1
    \$\begingroup\$ Using your same procedure, just a different path Pwp.I|-.;)^0@O?|uq;< \$\endgroup\$
    – MickyT
    Jun 19, 2017 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, 2017 at 19:51
3
\$\begingroup\$

Haskell, 20 bytes

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

Try it online!

until saves the day

\$\endgroup\$
1
  • \$\begingroup\$ Augh, I knew there must have been a builtin for that. Nice. \$\endgroup\$ Jun 20, 2017 at 15:02
3
\$\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
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\$
6
  • 1
    \$\begingroup\$ You beat me by a minute. That's exactly what I wrote, but I used ć instead of ¬. \$\endgroup\$
    – Riley
    Jun 19, 2017 at 13:54
  • \$\begingroup\$ @Riley: Also works with filter, but unfortunately doesn't save any bytes. \$\endgroup\$
    – Emigna
    Jun 19, 2017 at 13:58
  • 1
    \$\begingroup\$ @Emigna unfortunately doesn't save any bytes *saves byte(s)* \$\endgroup\$ Jun 19, 2017 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, 2017 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, 2017 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\$
4
  • \$\begingroup\$ You can use 1/Log@## or #2~Log~#. Or even better swap the order of the inputs and use Log@##. \$\endgroup\$ Jun 19, 2017 at 14:06
  • \$\begingroup\$ And then #^Floor[...]# is shorter than #^(Floor[...]+1). And there's the Unicode operators for Floor as well. \$\endgroup\$ Jun 19, 2017 at 14:07
  • \$\begingroup\$ yes, yes of course.I'm working on all these.you are quick! \$\endgroup\$
    – ZaMoC
    Jun 19, 2017 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\$ Jun 19, 2017 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
  • 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, 2017 at 15:59
  • \$\begingroup\$ Suggest n/b instead of n>=b \$\endgroup\$
    – ceilingcat
    May 9, 2019 at 16:27
2
\$\begingroup\$

Japt, 16 8 bytes

This feels longer than it needs to be! That's a bit better!

nVpUìV l

Try it

nVpUìV l     :Implicit input of integers U=n & V=b
n            :Subtract U from
 Vp          :  Raise V to the power of
   UìV       :    Convert U to a base-V digit array
       l     :    Get the length
\$\endgroup\$
2
\$\begingroup\$

AWK, 34 32+2 bytes

{for(n=$2;n<=$1;n*=$2);}$0=n-$11

Try it online!

Requires the -M option for arbitrary precision to handle the 12345678901234567890 1000000 => 999987654321098765432110 case.

The non-loop version requires the same number of bytes:

$0=$2^int(log($1)/log($2)+1)-$1

After almost 5 years, saved 2 bytes in each formulation by removing unnecessary grouping symbols. Thanks @PaoloVlw

\$\endgroup\$
3
  • \$\begingroup\$ Aahhh... I see that I may not need the 2 bytes for the "large" answer, since I accidentally grabbed Toby Speight's inputs rather than the original inputs. Oh well. This should allow it to work for all cases. \$\endgroup\$ Jun 20, 2017 at 15:55
  • 1
    \$\begingroup\$ These save both versions 2 bytes each: {for(n=$2;n<=$1;n*=$2);}$0=n-$1 and $0=$2^int(log($1)/log($2)+1)-$1. \$\endgroup\$ May 1 at 3:36
  • 2
    \$\begingroup\$ @PauloVlw It's nice to know that someone is still interested in AWK. :) \$\endgroup\$ May 3 at 18:27
2
+50
\$\begingroup\$

Desmos, 30 27 bytes

f(n,b)=b^{floor(log_bbn)}-n

Try It On Desmos

-3 thanks to @Aiden Chow and @Steffan

Gotta love using your favorite graphing calculator for code golf. Taken from the R answer.

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

Python 2,  42 41  35 bytes

Saved 6 thanks to loopy walt! (A superior recursive algorithm.)

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

A recursive function which repeatedly integer divides by b until that yields 0 (n<1) yielding 1 (well, True which works like 1) at the tail and multiplies back up by b removing the remainder after division by b at each step. That is, we subtract n from b^k in base b, "digit" by "digit".

Try it online!

\$\endgroup\$
5
  • \$\begingroup\$ tio.run/… is a bit shorter but having to output the result with format "%.0f" is probably cheating. \$\endgroup\$
    – rici
    Jun 19, 2017 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\$ Jun 19, 2017 at 19:56
  • \$\begingroup\$ 35 bytes (Python2) I believe. \$\endgroup\$
    – loopy walt
    May 4 at 22:37
  • \$\begingroup\$ Much better, thanks @loopywalt (I think I'd have posted as my own if I'd seen this and written that!) Do let me know if you think there is a clearer description or if I have any mistakes. \$\endgroup\$ May 5 at 19:01
  • 1
    \$\begingroup\$ Not much glory to earn with very late answers... Re clarity, perhaps mention that we are basically subtracting (from b^k) n digit-by-digit in base b. \$\endgroup\$
    – loopy walt
    May 5 at 19:24
2
\$\begingroup\$

Vyxal, 8 bytes

ɾe'¹>;hε

Try it Online!

Port of 05AB1E.

How?

ɾe'¹>;hε
ɾ        # Inclusive range from one to (implicit) first input
 e       # For each element, push it to the power of the (implicit) second input
  '¹>;   # Filter for only elements greater than the first input
      h  # Get the first item
       ε # Get the absolute difference of the first item and the (implicit) first input
\$\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\$
9
  • \$\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, 2017 at 14:17
  • \$\begingroup\$ Thanks @Neil, but I'm having trouble figuring out how to do that(?) \$\endgroup\$ Jun 19, 2017 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, 2017 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, 2017 at 14:34
  • \$\begingroup\$ @Neil, thanks, I need more practice with currying. \$\endgroup\$ Jun 19, 2017 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\$
2
  • 1
    \$\begingroup\$ ... Wait. What? \$\endgroup\$
    – Shaggy
    Jun 19, 2017 at 17:04
  • \$\begingroup\$ @Shaggy I've added an explanation, hopefully this helps. \$\endgroup\$ Jun 19, 2017 at 19:41
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\$
1
\$\begingroup\$

Forth (gforth), 45 bytes

: f >r 1 begin i * 2dup < until rdrop - abs ;

Try it online!

Code Explanation

: f          # start a new word definition
  >r         # store b on the return stack for quick access
  1          # create a counter to store powers of b
  begin      # start an indefinite loop
    i *      # multiply the counter by b
    2 dup <  # duplicate the counter and n. Check if n is less than the counter
  until      # if it is, end the loop
  rdrop      # remove b from the return stack
  - abs      # subtract and get absolute value (avoid negative)
;            # end the word definition
\$\endgroup\$
1
\$\begingroup\$

Husk, 6 bytes

≠Ω>¹*³

Try it online!

≠Ω>¹*³      # ¹ and ³ duplicate arguments ⁰ and ², so parses as:
≠Ω>⁰*²²⁰
            # now:
 Ω>⁰*²²     # Ω = Iterate function f until test result t is truthy, starting with x:
      ²     #     x is arg 2
    *²      #     f is *² = times arg 2, so iterating generates power series of arg 2
  >⁰        #     t is >⁰ = greater than arg 1  
            # then:
≠           # get the absolute difference to
       ⁰    # arg 1
\$\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.