Soit net bsoit des entiers positifs supérieurs à 1.

Sortie de la distance de nla prochaine puissance de b.

Pour n=5et b=3, la puissance suivante de 3from 5est 9( 3^2 = 9), donc la sortie est 9 - 5 = 4.

Pour n=8et b=2, la puissance suivante de 2from 8est 16( 2^4 = 16), donc la sortie est 16 - 8 = 8. Notez que nc'est une puissance de 2dans cet exemple.

Cas de test:

  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

C'est du code-golf . La réponse la plus courte en octets gagne. Les failles standard s'appliquent.

Gelée ,  4  3 octets

ạæċ

Un lien dyadique prenant nà gauche et bà droite et renvoyant le résultat.

Essayez-le en ligne!

Comment?

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

Assemblage x86-64 ( Convention d'appel Windows x64 ), 14 13 octets

Une approche itérative inefficace (mais svelte!) (Crédit à @Neil pour l'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

La fonction ci-dessus prend deux paramètres entiers, n(passés dans le ECXregistre) et b(passés dans le EDXregistre), et retourne un seul résultat entier (dans le EAXregistre). Pour l'appeler depuis C, vous utiliseriez le prototype suivant:

unsigned HowFarAway(unsigned n, unsigned b);

Ceci est limité à la plage d'un entier 32 bits. Il peut être facilement modifié pour prendre en charge des entiers 64 bits en utilisant les registres longs complets, mais cela coûterait plus d'octets pour coder ces instructions. :-)

C (gcc) , 39 35 octets

Nouveau comportement indéfini grâce à Erik

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

Essayez-le en ligne!

Dyalog APL, 10 octets

2 octets économisés grâce à @ZacharyT

⊢-⍨⊣*1+∘⌊⍟

Essayez-le en ligne!

Prend ncomme argument droit et bcomme argument gauche.

Calcule .b⌊logbn + 1⌋ - n

R , 38 34 octets

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

Fonction anonyme. Stocke toutes les valeurs de b à la puissance de tout dans la plage [0, n], soustrait n de chaque, sous-ensembles sur les valeurs positives et renvoie le min.

TIO a une version non pryr, appelée comme f(n,b); cette version doit être appelée comme f(b,n).

Sauvegardé 4 octets grâce à Jarko Dubbeldam, qui m'a ensuite surpassé.

Essayez-le en ligne!

Cubix , 24 20 octets

-4 octets grâce à MickyT

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

Lit en entrée comme n,b

Convient à un cube 2x2x2:

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

Explication:

I|I0 : lire l'entrée, pousser 0 (compteur) dans la pile

^w met l'IP au bon endroit pour la boucle:

• Pp-: calculer b^(counter), déplacer nen haut de la pile, calculerb^(counter) - n
• ? : tourner à gauche si négatif, droit si 0, droit si positif
  • Positif:: O@sortie en haut de la pile (distance) et sortie.
  • Négatif:: |?procéder comme si le haut de la pile était nul
• <;qu;): pointez l'IP dans la bonne direction, éclatez le haut de la pile (nombre négatif / zéro), déplacez-vous nvers le bas de la pile, demi-tour, éclatez le haut de la pile ( b^(counter)) et incrémentez le compteur
• IP est à ^wet le programme continue.

Regardez-le en ligne!

Essayez-le en ligne!

Haskell , 20 octets

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

Essayez-le en ligne!

until sauve la journée

05AB1E , 9 8 octets

sLmʒ‹}α¬

Essayez-le en ligne!

Explication

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)

Java (OpenJDK 8) , 42 octets

Basé sur la réponse C de @ GovindParmar .

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

Essayez-le en ligne!

MATL , 10 9 octets

yy:YAn^w-

Essayez-le en ligne!

Explication

Considérez les entrées 694et 3comme exemple.

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

JavaScript (ES6), 29 octets

Très similaire à l'approche de Rick mais publié avec sa permission (et un peu d'aide pour sauvegarder un octet).

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

L'essayer

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>

Mathematica, 24 octets

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

merci Martin

I / O

[343, 7]

2058

C, 42 40 octets

Merci au commentateur @Steadybox pour l'astuce

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

R, 30 octets

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

Évalue la fonction

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

Qui prend la première puissance supérieure ou égale à n, puis soustraitn de cette valeur.

Modifié ceiling(power)pour floor(power+1)garantir que si nest une puissance de b, nous prenons la puissance suivante.

JavaScript (ES6), 31 octets

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

Cas de test:

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

Octave , 32 octets

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

Essayez-le en ligne!

Octave, 26 octets

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

Vérifiez tous les cas de test!

Rubis , 38 octets

Deux approches différentes:

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

Essayez-le en ligne!

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

Essayez-le en ligne!

Haskell , 31 octets

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

Essayez-le en ligne!

Perl 6 ,  31 30  29 octets

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

Testez-le (31)

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

Testez-le (30)

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

Testez-le (29)

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

Testez-le (29)

PARI / GP , 26 24 octets

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

Japt , 9 octets

_q}a@nVpX

Testez-le en ligne!

Explication

_  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

Python ,  42  41 octets

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

Une fonction récursive qui, en commençant par v=1, se multiplie de façon répétée par bjusqu'à ce qu'elle dépasse strictement a, puis renvoie la différence.

Essayez-le en ligne!

Remarque: Le résultat ne sera jamais nul et a>=v and f(a,b,v*b)or v-apeut donc être remplacé par (a<v)*(v-a)or f(a,b,v*b)sans provoquer d'erreurs de récursivité.

Python 3, 37 octets?

En utilisant une idée de rici ...

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

qui utilise l'arithmétique à virgule flottante (les résultats peuvent donc s'écarter de leur vraie distance),
essayez ici .

Brachylog , 7 octets

^ʰ↙X>₁-

Essayez-le en ligne!

Prend la saisie sous forme de liste [b, n].

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

PHP> = 7,1, 46 octets

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

PHP Sandbox Online

Lua, 74 73 octets

Une solution simple, j'utilise 10 octets pour garantir que les arguments sont traités comme des nombres et non comme des chaînes. Sorties vers STDIN.

Modifier: oublié de supprimer l'espace w=1 n=n+0, enregistre un octet

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)

A expliqué

Essayez-le en ligne!

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

QBIC , 23 octets

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

Prend d' babord le paramètre n.

Explication

{       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

Python 2 , 48 41 octets

• @ La simplification de la boucle de Rod a sauvé 7 octets!

Programme complet sans récursivité ni twiddling de bits:

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

Essayez-le en ligne!

Format d' entrée: n, b.

Python 3 , 50 48 octets

^{Merci à EriktheOutgolfer pour avoir économisé 2 octets!}

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

Essayez-le en ligne!

Python n'a pas de bûches de fantaisie ni de plafonds intégrés, donc je suis juste allé avec l'approche évidente avec un peu de flair golfique.

Lisp commun, 73 octets

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

Essayez-le en ligne!