32

Biarkan ndan bmenjadi bilangan bulat positif lebih besar dari 1.

Keluarkan jarak dari nke kekuatan berikutnya b.

Untuk n=5dan b=3, kekuatan selanjutnya 3dari 5adalah9 ( 3^2 = 9), jadi outputnya adalah 9 - 5 = 4.

Untuk n=8dan b=2, kekuatan berikutnya 2dari 8adalah 16( 2^4 = 16), jadi outputnya adalah 16 - 8 = 8. Catat itun ini adalah kekuatan dari 2contoh ini.

Testcases:

Ini adalah kode-golf . Jawaban terpendek dalam byte menang. Celah standar berlaku.

code-golf arithmetic

— Biarawati Bocor
sumber

16

Jelly , 4 3 byte

ạæċ

Sebuah link diad mengambil ndi kiri dan bdi kanan dan mengembalikan hasilnya.

Cobalah online!

Bagaimana?

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

— Jonathan Allan
sumber

4

Dicoret 4 masih teratur 4; (

— Uriel

2

@Uriel But  ;)

— HyperNeutrino

Pikiran awal Anda yang semula adalah "oh, itu æċ!" alih-alih "oww ini sangat susah ..."

— Erik the Outgolfer

Oh itu mungkin tidak ada dalam sejarah, tapi saya memang berubah dari 4 byter. Ituæċ_⁸

— Jonathan Allan

@ Jonathan Allan Karena tidak ada dalam sejarah, itu tidak masuk akal dan itu sebabnya saya mengeditnya.

— Erik the Outgolfer

8

x86-64 Majelis ( Windows x64 Calling Convention ), 14 13 byte

Pendekatan iteratif yang tidak efisien (tapi langsing!) (Dengan kredit ke @Neil untuk inspirasi):

               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

Fungsi di atas mengambil dua parameter bilangan bulat, n(lulus dalam ECXregister) dan b(lulus dalam EDXregister), dan mengembalikan hasil integer tunggal (dalam EAXregister). Untuk memanggilnya dari C, Anda akan menggunakan prototipe berikut:

unsigned HowFarAway(unsigned n, unsigned b);

Ini terbatas pada kisaran integer 32-bit. Itu dapat dengan mudah dimodifikasi untuk mendukung bilangan bulat 64-bit dengan menggunakan register panjang penuh, tetapi akan membutuhkan lebih banyak byte untuk menyandikan instruksi tersebut. :-)

— Cody Grey
sumber

Jadi, Anda tidak dapat mengatur eax ke 1 dalam waktu kurang dari 4 byte?

— Neil

Hmm ... Tidak dengan cara normal yang akan digunakan oleh programmer yang waras , tetapi Anda dapat push 1+ pop raxhanya dalam 3 byte. Tetapi ... maka Anda tidak perlu melewati penggandaan, sehingga itu masih merupakan penghematan yang masuk akal karena Anda dapat membatalkannya jmp.

— Cody Grey

Ah, saya tahu harus ada cara untuk bermain golf satu byte!

— Neil

Anda dapat melakukan hal yang sama dengan konvensi panggilan SysV di Linux, dengan demo TIO .

— Digital Trauma

Tentu saja Anda bisa. Anda dapat melakukannya dengan konvensi panggilan apa pun yang melewati setidaknya dua parameter integer pertama dalam register. Sistem V, Win x64, Win32 __fastcall, dll. Register hanya berubah, dan saya harus memilih satu. Koin muncul "Windows".

— Cody Grey

6

C (gcc) , 39 35 byte

Perilaku baru yang tidak terdefinisi berkat Erik

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

Cobalah online!

— Cleblanc
sumber

f(n,b,i){for(i=b;b<n;b*=i);n=b-n;}menghemat 5 byte, dan didukung oleh gcc

— Erik the Outgolfer

@EriktheOutgolfer mengapa tidak b-=n?

— Leaky Nun

@ LeakyNun Karena ini adalah argumen pertama yang Anda butuhkan untuk menyimpan nilai kembali.

— Erik the Outgolfer

Umm, Anda tidak memperbarui kode.

— Erik the Outgolfer

Bisakah Anda melakukannya b-=njika Anda menukar urutan bdan n?

— Zacharý

6

Dyalog APL, 10 byte

2 byte disimpan berkat @ZacharyT

⊢-⍨⊣*1+∘⌊⍟

Cobalah online!

Dibawa nsebagai argumen kanan dan bsebagai argumen kiri.

Menghitung .b^{⌊log_bn + 1⌋} - n

— Uriel
sumber

Nice, I was just about to post this exact solution

— Kritixi Lithos

@KritixiLithos I had hard time with the floor trick. you think it could be made into a train?

— Uriel

Yeah, it can: ⊣-⍨⊢*1+∘⌊⍟⍨.

— Zacharý

@ZacharyT nice one!

— Uriel

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.

— Kritixi Lithos

6

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!

— BLT
sumber

Nice, way shorter than the recursion I had in mind.

— JAD

pryr::f({a=b^(0:n)-n;min(a[a>0])}) is a few bytes shorter.

— JAD

Thanks. I've had bad luck using pryr::f when I define a new variable in the function; looks like it works here.

— BLT

2

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.

— JAD

4

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!

— Giuseppe
sumber

1

Using your same procedure, just a different path Pwp.I|-.;)^0@O?|uq;<

— MickyT

@MickyT genius! I feel like every time I submit a cubix answer, you come along and shave off four or five bytes...

— Giuseppe

3

Haskell, 20 bytes

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

Try it online!

until saves the day

— xnor
sumber

Augh, I knew there must have been a builtin for that. Nice.

— vroomfondel

2

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)

— Emigna
sumber

1

You beat me by a minute. That's exactly what I wrote, but I used ć instead of ¬.

— Riley

@Riley: Also works with filter, but unfortunately doesn't save any bytes.

— Emigna

1

@Emigna unfortunately doesn't save any bytes *saves byte(s)*

— Erik the Outgolfer

@EriktheOutgolfer: Yes, well. It was an additional change utilizing the weird way implicit input works that saved a byte :)

— Emigna

1

@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.

— Emigna

2

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!

— Bashful Beluga
sumber

2

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

— Luis Mendo
sumber

2

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>

Expand snippet

— Shaggy
sumber

2

Mathematica, 24 bytes

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

thanks Martin

I/O

[343, 7]

2058

— J42161217
sumber

You can use 1/Log@## or #2~Log~#. Or even better swap the order of the inputs and use Log@##.

— Martin Ender

And then #^Floor[...]# is shorter than #^(Floor[...]+1). And there's the Unicode operators for Floor as well.

— Martin Ender

yes, yes of course.I'm working on all these.you are quick!

— J42161217

Don't forget Log@##! Actually, if you swap the argument order, #^⌊Log@##⌋#-#2& should be possible for -5 bytes (I think)!

— CalculatorFeline

2

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;}

— Govind Parmar
sumber

2

Using for instead of while saves two bytes: o;p(n,b){for(o=b;n>=b;)b*=o;return b-n;}

— Steadybox

Suggest n/b instead of n>=b

— ceilingcat

2

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.

— JAD
sumber

1

JavaScript (ES6), 31 bytes

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

Test cases:

Show code snippet

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

Expand snippet

— Rick Hitchcock
sumber

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.

— Neil

Thanks @Neil, but I'm having trouble figuring out how to do that(?)

— Rick Hitchcock

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).

— Neil

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.

— Shaggy

@Neil, thanks, I need more practice with currying.

— Rick Hitchcock

1

Octave, 32 bytes

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

Try it online!

— Luis Mendo
sumber

1

Octave, 26 bytes

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

Verify all test cases!

— rahnema1
sumber

1

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!

— Nnnes
sumber

1

Haskell, 31 bytes

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

Try it online!

— vroomfondel
sumber

1

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)

— Brad Gilbert b2gills
sumber

1

PARI/GP, 26 24 bytes

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

— Charles
sumber

1

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

— ETHproductions
sumber

1

... Wait. What?

— Shaggy

@Shaggy I've added an explanation, hopefully this helps.

— ETHproductions

1

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.

— Jonathan Allan
sumber

tio.run/… is a bit shorter but having to output the result with format "%.0f" is probably cheating.

— rici

@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).

— Jonathan Allan

1

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.

— Unrelated String
sumber

0

PHP>=7.1, 46 bytes

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

PHP Sandbox Online

— Jörg Hülsermann
sumber

0

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

— Katenkyo
sumber

I don't know Lua that well, but is the space between 1 and end needed?

— Zacharý

@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.

— Katenkyo

Welcome back to PPCG!

— Leaky Nun

0

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

— steenbergh
sumber

0

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.

— Mr. Xcoder
sumber

You can simplify the loop to reduce 7 bytes

— Rod

@Rod Would have never thought of that :). Thanks a lot!

— Mr. Xcoder

0

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.

— notjagan
sumber

import math;lambda n,b:b**-~int(math.log(n,b))-n saves two bytes and is allowed per meta consensus.

— Erik the Outgolfer

@EriktheOutgolfer ceil would not work.

— Leaky Nun

@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.

— notjagan

You can reformat it to be completely fine: Try it online!. Just place the import after the lambda, and add f= in the header.

— Mr. Xcoder

@Mr.Xcoder Ah, you are correct! I don't know why that didn't occur to me.

— notjagan

0

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!

— Steadybox
sumber

Seberapa jauh n ke kekuatan b berikutnya?

Jelly , 4 3 byte

Bagaimana?

x86-64 Majelis ( Windows x64 Calling Convention ), 14 13 byte

C (gcc) , 39 35 byte

Dyalog APL, 10 byte

R, 38 34 bytes

Cubix, 24 20 bytes

Explanation:

Haskell, 20 bytes

05AB1E, 9 8 bytes

Java (OpenJDK 8), 42 bytes

MATL, 10 9 bytes

Explanation

JavaScript (ES6), 29 bytes

Try it

Mathematica, 24 bytes

C, 42 40 bytes

R, 30 bytes

JavaScript (ES6), 31 bytes

Octave, 32 bytes

Octave, 26 bytes

Ruby, 38 bytes

Haskell, 31 bytes

Perl 6, 31 30 29 bytes

PARI/GP, 26 24 bytes

Japt, 9 bytes

Explanation

Python, 42 41 bytes

Python 3, 37 bytes?

Brachylog, 7 bytes

PHP>=7.1, 46 bytes

Lua, 74 73 Byte

Explained

QBIC, 23 bytes

Explanation

Python 2, 48 41 bytes

Python 3, 50 48 bytes

Common Lisp, 73 bytes