Wie weit ist n von der nächsten Potenz von b entfernt?

32

Sei nund bsei positive ganze Zahlen größer als 1.

Geben Sie die Entfernung von nzur nächsten Potenz von aus b.

Für n=5und b=3von dem nächsten Einschalten 3von 5ist 9( 3^2 = 9), so ist der Ausgang 9 - 5 = 4.

Für n=8und b=2von dem nächsten Einschalten 2von 8ist 16( 2^4 = 16), so ist der Ausgang 16 - 8 = 8. Beachten Sie, dass dies in diesem Beispiel neine Potenz von ist 2.

Testfälle:

  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

Das ist Code-Golf . Kürzeste Antwort in Bytes gewinnt. Es gelten Standardlücken .

code-golf arithmetic Undichte Nonne
quelle

Antworten:

16

Gelee ,  4  3 Bytes

ạæċ

Eine dyadische Verknüpfung, ndie links und brechts aufnimmt und das Ergebnis zurückgibt.

Probieren Sie es online!

Wie?

ạæċ - Link: number n, number b | n,b ∈ ℕ
 æċ - ceiling n to the next power of b
ạ   - absolute difference between n and that
Jonathan Allan
quelle
4
Durchgestrichen 4 ist immer noch regulär 4; (
Uriel
2
@Uriel But  ;)
HyperNeutrino
Ihr anfänglicher Gedanke ist "oh, es ist æċ!" anstelle von "oww das ist sooo schwer ..."
Erik the Outgolfer
Oh, es könnte nicht in der Geschichte existieren, aber ich habe von einem 4-Byte gewechselt. Es waræċ_⁸
Jonathan Allan
@ JonathanAllan Da es nicht in der Geschichte war, ergab es keinen Sinn und deshalb habe ich das herausgeschnitten.
Erik der Outgolfer
8

x86-64-Assembly ( Windows x64-Aufrufkonvention ), 14 bis 13 Byte

Ein ineffizienter (aber schlanker!) Iterativer Ansatz (mit Dank an @Neil für 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

Die obige Funktion akzeptiert zwei ganzzahlige Parameter n(im ECXRegister übergeben) und b(im EDXRegister übergeben) und gibt ein einzelnes ganzzahliges Ergebnis (im EAXRegister) zurück. Um es von C aufzurufen, würden Sie den folgenden Prototyp verwenden:

unsigned HowFarAway(unsigned n, unsigned b);

Dies ist auf den Bereich einer 32-Bit-Ganzzahl beschränkt. Es kann leicht modifiziert werden, um 64-Bit-Ganzzahlen zu unterstützen, indem die vollständigen langen Register verwendet werden. Die Codierung dieser Befehle würde jedoch mehr Byte kosten. :-)

Cody Gray
quelle
Sie können also eax nicht in weniger als 4 Bytes auf 1 setzen?
Neil
Hmm… Nicht auf die normale Art und Weise, die ein vernünftiger Programmierer verwenden würde, aber Sie könnten in nur 3 Bytes push 1+ pop rax. Aber… dann müssten Sie die Multiplikation nicht überspringen, sodass dies immer noch eine sinnvolle Ersparnis wäre, da Sie die fallen lassen könnten jmp.
Cody Grey
Ah, ich wusste, dass es eine Möglichkeit geben musste, ein Byte weg zu golfen!
Neil
Dasselbe können Sie mit der SysV-Aufrufkonvention unter Linux mit einer TIO-Demo tun .
Digital Trauma
Natürlich kannst du. Sie können dies mit jeder Aufrufkonvention tun, die mindestens die ersten beiden ganzzahligen Parameter in Registern übergibt. System V, Win x64, Win32 __fastcall usw. Die Register ändern sich nur, und ich musste eines auswählen. Münze kam "Windows".
Cody Grey
6

C (gcc) , 39-35 Bytes

Neues undefiniertes Verhalten dank Erik

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

Probieren Sie es online!

Cleblanc
quelle
f(n,b,i){for(i=b;b<n;b*=i);n=b-n;}spart 5 Bytes und wird von gcc
Erik the Outgolfer
@EriktheOutgolfer warum nicht b-=n?
Undichte Nonne
@LeakyNun Da dies das erste Argument ist, in dem Sie den Rückgabewert speichern müssen.
Erik der Outgolfer
Sie haben den Code nicht aktualisiert.
Erik der Outgolfer
Können Sie tun, b-=nwenn Sie die Reihenfolge von bund tauschen n?
Zacharý
6

Dyalog APL, 10 Bytes

2 Bytes gespart dank @ZacharyT

⊢-⍨⊣*1+∘⌊⍟

Probieren Sie es online!

Nimmt nals rechtes Argument und bals linkes Argument.

Berechnet .b⌊logbn + 1⌋ - n

Uriel
quelle
Schön, ich wollte gerade genau diese Lösung veröffentlichen
Kritixi Lithos
@KritixiLithos Ich hatte es schwer mit dem Bodentrick. Sie denken, es könnte in einen Zug verwandelt werden?
Uriel
Ja, es kann: ⊣-⍨⊢*1+∘⌊⍟⍨.
Zacharý
@ ZacharyT schön!
Uriel
Ich bekomme ⊢-⍨⊣*1+∘⌊⍟für 10 Bytes aber mit vertauschten Argumenten, so dass ndas richtige Argument und bdas linke Argument ist. Ich habe ZacharyTs Trick benutzt 1+∘⌊, um es so weit zu bringen.
Kritixi Lithos
6

R , 38 34 Bytes

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

Anonyme Funktion. Speichert alle Werte von b hoch aller Werte im Bereich [0, n], subtrahiert n von jedem Wert, setzt positive Werte unter und gibt die min zurück.

TIO hat eine Nicht-Pryr-Version namens f(n,b); Diese Version muss als aufgerufen werden f(b,n).

4 Bytes gespart dank Jarko Dubbeldam, der mich dann übertroffen hat.

Probieren Sie es online!

BLT
quelle
Schön, viel kürzer als die Rekursion, die ich mir vorgestellt hatte.
JAD
pryr::f({a=b^(0:n)-n;min(a[a>0])})ist ein paar Bytes kürzer.
JAD
Vielen Dank. Ich hatte Pech, pryr::fals ich eine neue Variable in der Funktion definierte. sieht aus wie es hier funktioniert.
BLT
2
Hmm, es lohnt sich immer nachzusehen :) Was mich ärgert ist, wenn Sie so etwas haben sapply(x, sum)oder was auch immer, dass es sumzu den Argumenten beiträgt.
JAD
4

Cubix , 24 20 Bytes

-4 Bytes dank MickyT

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

Liest in Eingabe wie n,b

Passt auf einen 2x2x2 Würfel:

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

Erläuterung:

I|I0 : Eingabe lesen, 0 (Zähler) auf den Stapel schieben

^w Setzt die IP an die richtige Stelle für die Schleife:

  • Pp-: berechnen b^(counter), nan die Spitze des Stapels verschieben, berechnenb^(counter) - n
  • ? : links abbiegen, wenn negativ, gerade, wenn 0, rechts, wenn positiv
    • Positiv O@:: Stapel oben ausgeben (Abstand) und beenden.
    • Negativ |?:: Gehen Sie so vor, als ob die Oberseite des Stapels Null wäre
  • <;qu;): Richten Sie die IP-Adresse in die richtige Richtung, legen Sie den oberen nRand des Stapels ab (negative / Null-Zahl), bewegen Sie sich zum unteren Rand des Stapels, drehen Sie sich um, legen Sie den oberen Rand des Stapels ab ( b^(counter)) und erhöhen Sie den Zähler
  • IP ist auf ^wund das Programm wird fortgesetzt.

Schau es dir online an!

Probieren Sie es online!

Giuseppe
quelle
1
Verwenden Sie das gleiche Verfahren, nur einen anderen PfadPwp.I|-.;)^0@O?|uq;<
MickyT
@ MickyT Genie! Ich habe das Gefühl, dass Sie jedes Mal, wenn ich eine Cubix-Antwort vorlege, mitkommen und vier oder fünf Bytes
Giuseppe,
2

05AB1E , 9 8 Bytes

sLmʒ‹}α¬

Probieren Sie es online!

Erläuterung

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
quelle
1
Du hast mich eine Minute geschlagen. Genau das habe ich geschrieben, aber ich habe ćstattdessen verwendet ¬.
Riley
@Riley: Funktioniert auch mit Filter, speichert aber leider keine Bytes.
Emigna
1
@Emigna speichert leider keine Bytes * speichert Bytes *
Erik the Outgolfer
@EriktheOutgolfer: Ja, gut. Es war eine zusätzliche Änderung, die die seltsame Art und Weise der impliziten Eingabe nutzte und ein Byte sparte :)
Emigna
1
@carusocomputing: Ja. Es spart tatsächlich ein Byte, um sie in der "falschen" Reihenfolge zu haben, da ich sie nimplizit wiederverwenden kann , sowohl beim Filtervergleich als auch bei der Berechnung der absoluten Differenz.
Emigna
2

MATL , 10 9 Bytes

yy:YAn^w-

Probieren Sie es online!

Erläuterung

Betrachten Sie Eingaben 694und 3als Beispiel.

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
quelle
2

JavaScript (ES6), 29 Byte

Sehr ähnlich wie Ricks Ansatz, aber mit seiner Erlaubnis gepostet (und etwas Hilfe beim Speichern eines Bytes).

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

Versuch es

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>
Erweitern Sie das Snippet

Zottelig
quelle
2

Mathematica, 24 Bytes

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

Danke Martin

I / O

[343, 7]

2058

J42161217
quelle
Sie können 1/Log@##oder verwenden #2~Log~#. Oder noch besser die Reihenfolge der Eingaben vertauschen und verwenden Log@##.
Martin Ender
Und ist dann #^Floor[...]#kürzer als #^(Floor[...]+1). Und es gibt auch die Unicode-Operatoren Floor.
Martin Ender
Ja, ja natürlich. Ich arbeite an all diesen Dingen. Du bist schnell!
J42161217
Nicht vergessen Log@##! Eigentlich, wenn man die Argumentreihenfolge vertauscht, #^⌊Log@##⌋#-#2&sollte das für -5 Bytes möglich sein (glaube ich)!
CalculatorFeline
2

C, 42 bis 40 Bytes

Vielen Dank an Kommentator @Steadybox für den Tipp

o;p(n,b){for(o=b;n>=b;)b*=o;return b-n;}
Govind Parmar
quelle
2
Verwenden forstatt whilespart zwei Bytes:o;p(n,b){for(o=b;n>=b;)b*=o;return b-n;}
Steadybox
Schlagen Sie n/bstattdessen vorn>=b
ceilingcat
2

R, 30 Bytes

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

Wertet die Funktion aus

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

nWobei die erste Potenz größer oder gleich ist und dann subtrahiertn von diesem Wert .

Geändert ceiling(power), floor(power+1)um sicherzustellen, dass, wenn neine Kraft von ist b, wir die nächste Kraft nehmen.

JAD
quelle
1

JavaScript (ES6), 31 Byte

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

Testfälle:

Code-Snippet anzeigen

Rick Hitchcock
quelle
Sie können ein Byte speichern, indem Sie das Curren ausführen (es war egal, ob ich beide nund bnur ndas Curren ausgeführt habe), da Sie dadurch nicht nrekursiv übergeben müssen.
Neil
Danke @Neil, aber ich habe Probleme herauszufinden, wie das geht (?)
Rick Hitchcock
Die beiden Versionen, die ich mir ausgedacht habe, waren n=>g=(b,p=b)=>p>n?p-n:g(b,p*b)und n=>b=>(g=p=>p>n?p-n:g(p*b))(b).
Neil
Würde f=(n,i)=>g=(b=i)=>b>n?b-n:g(b*i)für 30 Bytes arbeiten? Es müßte wie so genannt werden: f(324,5)(). EDIT: Ah, @Neil hat mich geschlagen.
Shaggy
@Neil, danke, ich brauche mehr Übung mit dem Curry.
Rick Hitchcock
1

Japt , 9 Bytes

_q}a@nVpX

Online testen!

Erläuterung

_  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
quelle
1
... Warten. Was?
Shaggy
@ Shaggy Ich habe eine Erklärung hinzugefügt, hoffentlich hilft dies.
ETHproductions
1

Python ,  42  41 Bytes

f=lambda a,b,v=1:(a<v)*(v-a)or f(a,b,v*b)

Eine rekursive Funktion, die beginnend mit v=1wiederholt multipliziert wird, bbis sie adie Differenz streng überschreitet, und dann die Differenz zurückgibt.

Probieren Sie es online!

Hinweis: Das Ergebnis wird niemals Null sein und a>=v and f(a,b,v*b)or v-akann durch ersetzt werden, (a<v)*(v-a)or f(a,b,v*b)ohne dass es zu Rekursionsfehlern kommt.

Python 3, 37 Bytes?

Mit einer Idee von Rici's ...

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


Versuchen Sie dies hier , wenn Sie Fließkomma-Arithmetik verwenden (daher können die Ergebnisse von der tatsächlichen Entfernung abweichen) .

Jonathan Allan
quelle
tio.run/… ist etwas kürzer, aber das Ergebnis mit dem Format "% .0f" ausgeben zu müssen, ist wahrscheinlich ein Betrug.
rici
@rici Schön, ich denke, es ist in Ordnung, Gleitkomma-Arithmetik zu verwenden. Ich füge es als Alternative hinzu (ein anderes Byte kann gespeichert werden, indem die Formulare gewechselt werden, da es b-nniemals zur gleichen Zeit null n<bist, wie es wahr ist).
Jonathan Allan
1

Brachylog , 7 Bytes

^ʰ↙X>₁-

Probieren Sie es online!

Übernimmt die Eingabe als Liste [b, n].

    >₁     n is strictly less than
^ ↙X       some power of
 ʰ         b,
      -    and their difference is
           the output.
Nicht verwandte Zeichenfolge
quelle
0

Lua, 74 73 Byte

Als einfache Lösung verwende ich 10 Bytes, um sicherzustellen, dass die Argumente als Zahlen und nicht als Zeichenfolgen behandelt werden. Ausgänge zu STDIN.

Bearbeiten: habe vergessen, den Platz in zu entfernen w=1 n=n+0, spart ein 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)

Erklärt

Probieren Sie es 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
quelle
Ich kenne Lua nicht so gut, aber ist der Raum zwischen 1und endnötig?
Zacharý
@ZacharyT In Lua können Hexadezimalzahlen inline gesetzt werden, wenn sie mit einer Zahl 1endbeginnen, als Zahl interpretiert werden und 1edann einen Fehler auslösen, da 1enes sich nicht um einen gültigen Hexadezimalwert handelt. Dies ist nur dann der Fall, wenn der Buchstabe nach der Zahl [abcdef]nicht als Hexadezimalwert interpretiert werden kann -> w=1whilees wird kein Fehler ausgegeben .
Katenkyo
Willkommen zurück bei PPCG!
Undichte Nonne
0

QBIC , 23 Bytes

{p=:^q~p>:|_xp-b|\q=q+1

Übernimmt dann bzuerst den Parameter n.

Erläuterung

{       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
quelle
0

Python 2 , 48 41 Bytes

  • @ Rods Schleifenvereinfachung sparte 7 Bytes!

Volles Programm ohne Rekursion oder Bit-Twiddling:

i=1;n,b=input()
while n>=i:i*=b
print i-n

Probieren Sie es online!

Eingabeformat: n, b.

Mr. Xcoder
quelle
Sie können die Schleife vereinfachen , um 7 Bytes zu reduzieren
Rod
@ Rod Hätte nie daran gedacht :). Vielen Dank!
Mr. Xcoder
0

Python 3 , 50 48 Bytes

Danke an EriktheOutgolfer für das Speichern von 2 Bytes!

lambda n,b:b**-~int(math.log(n,b))-n
import math

Probieren Sie es online!

Python hat keine ausgefallenen Log- oder Deckenelemente, deshalb habe ich mich für den offensichtlichen Ansatz mit ein bisschen Golf-Flair entschieden.

notjagan
quelle
import math;lambda n,b:b**-~int(math.log(n,b))-n Spart zwei Bytes und ist per Metakonsens erlaubt.
Erik der Outgolfer
@EriktheOutgolfer ceilwürde nicht funktionieren.
Undichte Nonne
@EriktheOutgolfer habe ich nicht benutzt, ceilweil es für Potenzen von nicht funktioniert b, aber als @Uriel darauf hinwies, dass das Importieren vorher noch ein Byte speichert.
Notjagan
Sie können es komplett neu formatieren: Probieren Sie es online aus! . Setzen Sie einfach das importnach dem Lambda, und fügen Sie f=in der Überschrift hinzu.
Mr. Xcoder
@ Mr.Xcoder Ah, du hast recht! Ich weiß nicht, warum mir das nicht eingefallen ist.
Notjagan