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:

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

code-golf arithmetic

— Undichte Nonne
quelle

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^{⌊log_bn + 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,

3

Haskell , 20 Bytes

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

Probieren Sie es online!

until rettet den Tag

— xnor
quelle

Augh, ich wusste, dass es dafür einen eingebauten gibt. Nett.

— Vroomfondel

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

Java (OpenJDK 8) , 42 Byte

Basierend auf der C-Antwort von @ GovindParmar .

n->b->{for(int o=b;n>=b;b*=o);return b-n;}

Probieren Sie es online!

— Schüchterner Beluga
quelle

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

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

Erweitern Sie das Snippet

— 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

Oktave , 32 Bytes

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

Probieren Sie es online!

— Luis Mendo
quelle

1

Oktave, 26 Bytes

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

Überprüfen Sie alle Testfälle!

— rahnema1
quelle

1

Ruby , 38 Bytes

Zwei verschiedene Ansätze:

->(n,b){p b**(Math.log(n,b).to_i+1)-n}

Probieren Sie es online!

->(n,b){p b**(0..n).find{|x|b**x>n}-n}

Probieren Sie es online!

— Nnnes
quelle

1

Haskell , 31 Bytes

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

Probieren Sie es online!

— vroomfondel
quelle

1

Perl 6 , 31 30 29 Bytes

->\n,\b{(b,b* *...*>n).tail -n}

Testen Sie es (31)

->\n,\b{b**(log(n,b).Int+1)-n}

Testen Sie es (30)

{$^b**(log($^a,$b).Int+1)-$a}

Testen Sie es (29)

{($^b,$b* *...*>$^a).tail-$a}

Testen Sie es (29)

— Brad Gilbert b2gills
quelle

1

PARI / GP , 26 24 Bytes

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

— Charles
quelle

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

PHP> = 7.1, 46 Bytes

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

PHP Sandbox Online

— Jörg Hülsermann
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

0

Common Lisp, 73 Bytes

(defun f(n b)(setq a b)(loop(when(> b n)(return(- b n)))(setq b(* b a))))

Probieren Sie es online!

— Steadybox
quelle

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

Gelee , 4 3 Bytes

Wie?

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

C (gcc) , 39-35 Bytes

Dyalog APL, 10 Bytes

R , 38 34 Bytes

Cubix , 24 20 Bytes

Erläuterung:

Haskell , 20 Bytes

05AB1E , 9 8 Bytes

Java (OpenJDK 8) , 42 Byte

MATL , 10 9 Bytes

Erläuterung

JavaScript (ES6), 29 Byte

Versuch es

Mathematica, 24 Bytes

C, 42 bis 40 Bytes

R, 30 Bytes

JavaScript (ES6), 31 Byte

Oktave , 32 Bytes

Oktave, 26 Bytes

Ruby , 38 Bytes

Haskell , 31 Bytes

Perl 6 , 31 30 29 Bytes

PARI / GP , 26 24 Bytes

Japt , 9 Bytes

Erläuterung

Python , 42 41 Bytes

Python 3, 37 Bytes?

Brachylog , 7 Bytes

PHP> = 7.1, 46 Bytes

Lua, 74 73 Byte

Erklärt

QBIC , 23 Bytes

Erläuterung

Python 2 , 48 41 Bytes

Python 3 , 50 48 Bytes

Common Lisp, 73 Bytes