Seberapa jauh n ke kekuatan b berikutnya?


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:

  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

Ini adalah . Jawaban terpendek dalam byte menang. Celah standar berlaku.

Jawaban:


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

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


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!


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⌊logbn + 1⌋ - n


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!


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!


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


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)

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

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

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>


2

Mathematica, 24 bytes

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

thanks Martin

I/O

[343, 7]

2058


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

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.


1

JavaScript (ES6), 31 bytes

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

Test cases:


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

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

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.


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



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

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


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.


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

Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.