[Question]
  [
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 [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"). Shortest answer in bytes wins. [Standard loopholes](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) apply.
  
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~4~~ 3 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
ạæċ
```
A dyadic link taking `n` on the left and `b` on the right and returning the result.
**[Try it online!](https://tio.run/##y0rNyan8///hroWHlx3p/v//v7GRyX9TAA "Jelly – 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
```
[Answer]
## x86-64 Assembly ([Windows x64 Calling Convention](https://msdn.microsoft.com/en-us/library/ms235286.aspx)), 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. :-)
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~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!](https://tio.run/##LYhBCsIwEADvfUUoCNmQHGwFD2teojkkq7E5uCmx5FL6bM/RgjAMw5B5ErUWJeugE6wxF5lswHCxjEHZBMg2GMatvXxiSboCTb4oVXHthJhL4iXK/vAWO/cb97pej@6nweko/ZKT3Afofw4OALDbWhtPYzt/OBvyND2@ "C (gcc) – Try It Online")
[Answer]
# Dyalog APL, 10 bytes
*2 bytes saved thanks to @ZacharyT*
```
⊢-⍨⊣*1+∘⌊⍟
```
[Try it online!](http://tryapl.org/?a=f%u2190%u22A2-%u2368%u22A3%2A1+%u2218%u230A%u235F%20%u22C4%202%202%205%205%203%20f%208%20212%20563%20491%20424&run)
Takes `n` as right argument and `b` as left argument.
Calculates `b⌊logbn + 1⌋ - n`.
[Answer]
# [R](https://www.r-project.org/), ~~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.](https://codegolf.stackexchange.com/a/127422/62105)
[Try it online!](https://tio.run/##K/r/P802rTQvuSQzP08jTydJszrRNilOw8AqT1M3zzo3M08jMTrRziBWs5aLK03DyNBIx0gTyDA1M9YxBTFMLA0hDCMIZWxkAmT8/w8A "R – Try It Online")
[Answer]
# [Cubix](https://github.com/ETHproductions/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!](http://ethproductions.github.io/cubix/?code=UHdwLkl8LS47KV4wQE8/fHVxOzw=&input=MjEyIDI=&speed=20)
[Try it online!](https://tio.run/##Sy5Nyqz4/z@gvEDPs0ZXz1ozzsDB376mtNDa5v9/I0MjBSMA "Cubix – Try It Online")
[Answer]
# [Haskell](https://www.haskell.org/), 20 bytes
```
n%b=until(>n)(*b)1-n
```
[Try it online!](https://tio.run/##FYoxDsIwEAS/cgWRbLQUPp9NXIRvUKAUiYQUC3OKwDR83hhNs7OabXk/7qW0psM6fbTmYi5qzXG17qTtuWSlifZX1koH@ub9mutGZrB0Y8cI0UOSg7BAYoIXj5AYPCbEJPD957m3CB2PEefOf3Wf2w8 "Haskell – Try It Online")
`until` saves the day
[Answer]
# 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.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~9~~ 8 bytes
```
sLmʒ‹}α¬
```
[Try it online!](https://tio.run/##MzBNTDJM/f@/2Cf31KRHDTtrz208tOb/f3MuYxNjAA "05AB1E – 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)
```
[Answer]
# [Java (OpenJDK 8)](http://openjdk.java.net/), 42 bytes
*Based on [@GovindParmar's C answer](https://codegolf.stackexchange.com/a/127227/58217).*
```
n->b->{for(int o=b;n>=b;b*=o);return b-n;}
```
[Try it online!](https://tio.run/##lZAxb4MwEIX3/IoboSqWAoQGuTBW6tApY9XBEEAmcLbMESmK@O3UlXAydIEbfKdnf372a8VVBEpX2J4vs@y1MgSt1dhIsmP1iCVJhexjGfhOj0UnSyg7MQzwJSTCfQe2Fn0gQbZdlTxDb3e9ExmJzfcPCNMM/nL4r9yV759IVVOZ13/C0vMcashgxiAvgvxeK@NJJFBZwTG3S/GSKZ@bikaDUATIp9l58Ifb6TZQ1TM1EtP2QdShVzOhdXfzwn3ou9H3OaxhDknkmMNaJk7325kwdky0mklSxxzXMlH8@M/b6gzScDMTHtPNGSTp9gyiZ25Pn2k3zb8 "Java (OpenJDK 8) – Try It Online")
[Answer]
# [MATL](https://github.com/lmendo/MATL), ~~10~~ 9 bytes
```
yy:YAn^w-
```
[Try it online!](https://tio.run/##y00syfn/v7LSKtIxL65c9/9/M0sTLmMA)
### 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
```
[Answer]
# JavaScript (ES6), 29 bytes
Very similar to [Rick's approach](https://codegolf.stackexchange.com/a/127232/58974) 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>
```
[Answer]
# Mathematica, 24 bytes
```
#2^⌊1/#~Log~#2⌋#2-#&
```
thanks Martin
**I/O**
> 
> [343, 7]
> 
> 
> 2058
> 
> 
> 
[Answer]
# 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;}
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), ~~16~~ 8 bytes
~~This feels longer than it needs to be!~~ That's a bit better!
```
nVpUìV l
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=blZwVexWIGw&input=MjEyCjI)
```
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
```
[Answer]
# [AWK](https://www.gnu.org/software/gawk/manual/gawk.html), ~~34~~ 32+2 bytes
```
{for(n=$2;n<=$1;n*=$2);}$0=n-$11
```
[Try it online!](https://tio.run/##RcxLCgIxDAbgfU7RxSxUEPJqp2GsN/AQbgQROqKCC/Hq1unUx7/6QpJ/fz@V8jiMl0VOHQ95kzoa8mrycnh2mPK6o1KY2LFLW6cKPojz1YFBjZpJFJTVSR0EPWgwF@cPAVFxfTWjj@CN20QRDThaaxAJEOzb4EGmtrZAAv4QiEV96KPhX45wTr2wKbEPXoUJfyJ8jefbcczXst69AQ "AWK – 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
[Answer]
# [Desmos](https://desmos.com), ~~30~~ 27 bytes
```
f(n,b)=b^{floor(log_bbn)}-n
```
[Try It On Desmos](https://www.desmos.com/calculator/vqju31kztc)
-3 thanks to @Aiden Chow and @Steffan
Gotta love using your favorite graphing calculator for code golf. Taken from the [R answer](https://codegolf.stackexchange.com/a/127422/107299).
[Answer]
# [Python 2](https://docs.python.org/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!](https://tio.run/##JY3LCsMgEEXX7Ve4iyOThaN5GJr@i9KGBloTUhH69VbN6nAuB@7@C6/NU0rL/LYf97DMosM4y4nbWwTBY2thO9jC6y4cpCVreH4DWz3jnCQhAfKuV9hlaiNPkkZV2BscM5VWOJTOUCWNpna9OTuV@w5gul72Y/WhPiBr2nuD@VwUhfQH "Python 2 – Try It Online")**
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 8 bytes
```
ɾe'¹>;hε
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCLJvmUnwrk+O2jOtSIsIiIsIjM0M1xuNyJd)
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
```
[Answer]
# 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
```
[Answer]
# [Octave](https://www.gnu.org/software/octave/), 32 bytes
```
@(n,b)b^(fix(log(n)/log(b))+1)-n
```
[Try it online!](https://tio.run/##y08uSSxL/Z9mq6en999BI08nSTMpTiMts0IjJz9dI09TH0QlaWpqG2rq5v1P0zAyNNIx0uRK0zA2MtEx1fwPAA "Octave – Try It Online")
[Answer]
# Octave, 26 bytes
```
@(n,b)b^sum(b.^(0:n)<=n)-n
```
[Verify all test cases!](https://tio.run/##JU3JqsIwFF17vuJuCgnUktybxEYt@B@PJ1hrwYWpWAfoz9cGV2fgDMP5eXpf5vmgUtnq9ji@bqqtjspsk943Sa/T3DenNO6AqfmrqgpsmZgK5@CDkKciMFy0mVlxcOxIqBDj4UKkekkKxAltqGDja/jImdvaRHAdc08kIMRfz0OWhWwaC1qe/P9uEQD64UEdNWS39Bg@o5o0Vt11vKteTaorrS4zsNYal9TNXw "Octave – Try It Online")
[Answer]
# [Ruby](https://www.ruby-lang.org/), 38 bytes
Two different approaches:
```
->(n,b){p b**(Math.log(n,b).to_i+1)-n}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf104jTydJs7pAIUlLS8M3sSRDLyc/HSymV5Ifn6ltqKmbV/s/TS85MSdHw8jQSMdIkwvKMzUz1jGF80wsDZF5RiY6xgiemaWOBZxnbGKsY44wxdIIiWdkYYlkipklsinGQDMRckZA9n8A "Ruby – Try It Online")
```
->(n,b){p b**(0..n).find{|x|b**x>n}-n}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf104jTydJs7pAIUlLS8NATy9PUy8tMy@luqaiBihSYZdXq5tX@z9NLzkxJ0fDyNBIx0iTC8ozNTPWMYXzTCwNkXlGJjrGCJ6ZpY4FnGdsYqxjjjDF0giJZ2RhiWSKmSWyKcZAMxFyRkD2fwA "Ruby – Try It Online")
[Answer]
# [Haskell](https://www.haskell.org/), 31 bytes
```
f n b=[b^x-n|x<-[1..],b^x>n]!!0
```
[Try it online!](https://tio.run/##FYrhCoIwGEVf5fOfwlXy21wOshcZC2YkjXTISrDo3dfi/LnncO/u@bjNc0oTBRoHM172Onz3U23aprHIeg62KA5pcT7QQGv04UXl4lYqt3DdYnzTVFH58SsZbhmdEpC6hWQJqTSEFOg0g3sNpSVE7mzzF11GoMcx81/ZbVWlHw "Haskell – Try It Online")
[Answer]
# [Perl 6](https://perl6.org), ~~31 30~~ 29 bytes
```
->\n,\b{(b,b* *...*>n).tail -n}
```
[Test it (31)](https://tio.run/##RY7BboMwEETv@xVzSQIECNjGBaFEvfbeI5cYHAmJGAS0ahXly3rrj9ElatXDase7b2Y92LHTy9tk8a7juqTrJ7Z131gcl@hUubAyN8@EJkAQx3Fwcn48n9sOkbsvjD7PdppxRNc6O3n@91dc91fjHapmf1hfL24uaQ1/Za6koTs77B@mki79@OuPTvDAt1AZLvsx2Hq2DXzcCGgnrP/xXGj8EH/LENMwtm6@YLeRDTYpV7MLwSHmn6L7AmSQUByUQyAnkQruSlGmJa@0IFWkLFKpSAnFrEwyUrpgXkmSSuIJIslyygrBMs2TgkRerLFSky4elowke3mUpHxJrOoH "Perl 6 – Try It Online")
```
->\n,\b{b**(log(n,b).Int+1)-n}
```
[Test it (30)](https://tio.run/##RY69boNAEIT7fYppHIP5MffDBYRspU2fkibA2ULCBwISJbL8ZOnyYmSxEqVY3dztNzM32LEzy9tk8W7iuqDLJx7qvrE4LNGxdGFZXavdzuv6s@fCyo@f3RwIP3K3hcmn2U4zDuhaZyfP//6K6/5SefuyCfbrjeGC1uwX5goauleH4G4q6NSPv/7oCA9chbLisR@DrWfbwMeVgHbC@p17eYi/ZYhpGFs3n7DdqAYbwdNsQ3BI9U/RbQFSKGgOyiCRkRSST60pNYpXRpLOBQuhNGmpmVVJStrkzGtFSis8QiZpRmkuWYosyUlm@RqrDJn8bklJsZefEsFNclU/ "Perl 6 – Try It Online")
```
{$^b**(log($^a,$b).Int+1)-$a}
```
[Test it (29)](https://tio.run/##RY7NboNADITvfoo5kAYCIewPWxBK1WvvPUaR@NlUSAQQ0KpVlCfrrS9GTdQqB8tj@5vZ7e3QmPl9tPgwYZnR@QsPZVdZ7OeLcyw2G7fp3lznmAdO4YUv7eQLb@vk15nB58mOE/Zo6taOrvfzHZbduXB3h8rfLRPTGS3Rr8xl1Dd5C/9myujUDX/@7RNcHNoAh4LLfva2nGwFDxcC6hHLb9w2KLwA/8cAYz/U7XTCeqUqrARXtQ7AIcWdousMxFDQHJRAIiEpJHetKTaKT0aSTgULoTRpqZlVUUzapMxrRUorPEJGcUJxKlmKJEpJJukSqwyZ9GaJSbGXV5Hgl@SifgE "Perl 6 – Try It Online")
```
{($^b,$b* *...*>$^a).tail-$a}
```
[Test it (29)](https://tio.run/##RY7NaoNQEIX38xRnYRo1xnh/vFEkodvuuwwBf25AMCpqS0vIk3XXF7NjaOlimDMz3zn39nZozPw2WrybsMzo@omnsqssDvPNdc5F4BQ@/DAM/aNzzr1wyutm6@T3mcHnyY4TDmjq1o6u9/0Vlt21cHenarNbppd2ymiJfmUuo77JW2wepowu3fDr3x7h4tQGOBVc9qO35WQreLgRUI9YfuO2QeEF@DsGGPuhbqcL1itVYSW4qnUADin@KbrPQAwFzUEJJBKSQnLXmmKj@GQk6VSwEEqTlppZFcWkTcq8VqS0wh4yihOKU8lSJFFKMkmXWGXIpA9LTIq9vIoEvyQX9QM "Perl 6 – Try It Online")
[Answer]
# [PARI/GP](http://pari.math.u-bordeaux.fr/), ~~26~~ 24 bytes
```
f(n,b)=b^logint(b*n,b)-n
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 9 bytes
```
_q}a@nVpX
```
[Test it online!](http://ethproductions.github.io/japt/?v=1.4.5&code=X3F9YUBuVnBY&input=MTI3IDI=)
### 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
```
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 7 bytes
```
^ʰ↙X>₁-
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/pf/ahjuVKSgq2CUrl9RrmSjkIehF1SrqSgawdiPWrb8Kip6eGuztqHWyf8jzu14VHbzAi7R02Nuv//RytEG@kYGRrF6kSb6piaGYNpE0tDIG2sY2JkAqQtdEzMLIG0uY6xiTGYNrWEqDeysASrM7M0AfONjSC0UaxCLAA "Brachylog – 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.
```
[Answer]
# [Forth (gforth)](http://www.complang.tuwien.ac.at/forth/gforth/Docs-html/), 45 bytes
```
: f >r 1 begin i * 2dup < until rdrop - abs ;
```
[Try it online!](https://tio.run/##JYxBCoNAEATvvqLwGFBwVo0bg3/RGI0QdFmVPN/M6mWKoat7WPz2ScYh4DgeDDSejO49TjMTN6TfHU/2eZu@@N4vjoS2W6nVdle8/lqHIfVIOGkMSUOsYykvTx1JJhq5qCgNhTK32UXJtacsLZXS5IZ78KyclMqeXmkvz6gffnRNefwB "Forth (gforth) – 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
```
[Answer]
# [Husk](https://github.com/barbuz/Husk), 6 bytes
```
≠Ω>¹*³
```
[Try it online!](https://tio.run/##yygtzv7/cGfjw11dj5oa/z/qXHBupd2hnVqHNv///z862kjHyNAoVifaVMfUzBhMm1gaAmljHRMjEyBtoWNiZgmkzXWMTYxjYwE "Husk – 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
```
]