32

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:

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

code-golf arithmetic Fuite, nonne
la source

16

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

Jonathan Allan
la source

4

Barré 4 est toujours régulier 4; (

Uriel

2

@Uriel But  ;)

HyperNeutrino

tfw votre première pensée initiale est "oh c'est æċ!" au lieu de "oww c'est trop dur ..."

Erik the Outgolfer

Oh, il pourrait ne pas exister dans l'histoire, mais j'ai changé d'un 4 octets. C'étaitæċ_⁸

Jonathan Allan

@JonathanAllan Comme ce n'était pas dans l'histoire, cela n'avait pas de sens et c'est pourquoi j'ai édité cela.

Erik the Outgolfer

8

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

Cody Grey
la source

Donc, vous ne pouvez pas définir eax sur 1 en moins de 4 octets?

Neil

Hmm… Pas de la manière habituelle qu'un programmeur sensé utiliserait, mais vous pourriez push 1+ pop raxen seulement 3 octets. Mais… alors vous n'auriez pas à sauter la multiplication, donc ce serait quand même une économie raisonnable car vous pourriez laisser tomber le jmp.

Cody Gray

Ah, je savais qu'il devait y avoir un moyen de jouer au golf un octet!

Neil

Vous pouvez faire de même avec la convention d'appel SysV sous Linux, avec une démo TIO .

Digital Trauma

Bien sûr vous pouvez. Vous pouvez le faire avec n'importe quelle convention d'appel qui transmet au moins les deux premiers paramètres entiers dans les registres. System V, Win x64, Win32 __fastcall, etc. Les registres changent juste, et j'ai dû en choisir un. Coin est venu "Windows".

Cody Gray

6

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!

cleblanc
la source

f(n,b,i){for(i=b;b<n;b*=i);n=b-n;}enregistre 5 octets et est pris en charge par gcc

Erik the Outgolfer

@EriktheOutgolfer pourquoi pas b-=n?

Leaky Nun

@LeakyNun Parce que c'est le premier argument dans lequel vous devez enregistrer la valeur de retour.

Erik the Outgolfer

Umm, vous n'avez pas mis à jour le code.

Erik the Outgolfer

Pouvez-vous faire b-=nsi vous échangez l'ordre de bet n?

Zacharý

6

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^{⌊log_bn + 1⌋} - n

Uriel
la source

Bien, j'étais sur le point de publier cette solution exacte

Kritixi Lithos

@KritixiLithos J'ai eu du mal avec le truc au sol. vous pensez que cela pourrait être transformé en train?

Uriel

Oui, il peut: ⊣-⍨⊢*1+∘⌊⍟⍨.

Zacharý

@ZacharyT nice one!

Uriel

J'obtiens ⊢-⍨⊣*1+∘⌊⍟10 octets mais avec des arguments échangés, c'est ndonc l'argument de droite et bl'argument de gauche. J'ai utilisé l'astuce de ZacharyT 1+∘⌊pour descendre aussi loin.

Kritixi Lithos

6

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!

BLT
la source

Sympa, bien plus court que la récursivité que j'avais en tête.

JAD

pryr::f({a=b^(0:n)-n;min(a[a>0])})est quelques octets plus court.

JAD

Merci. J'ai eu de la malchance à utiliser pryr::florsque j'ai défini une nouvelle variable dans la fonction; on dirait que ça marche ici.

BLT

2

Hmm, ça vaut toujours la peine de vérifier :) Ce qui m'ennuie, c'est que si vous avez quelque chose comme sapply(x, sum)ça, ça ajoute sumaux arguments.

JAD

4

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!

Giuseppe
la source

1

En utilisant votre même procédure, juste un chemin différentPwp.I|-.;)^0@O?|uq;<

MickyT

@MickyT genius! J'ai l'impression que chaque fois que je soumets une réponse cubique, vous venez et vous rasez quatre ou cinq octets ...

Giuseppe

3

Haskell , 20 octets

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

Essayez-le en ligne!

until sauve la journée

Xnor
la source

Augh, je savais qu'il devait y avoir une fonction intégrée pour ça. Agréable.

vroomfondel

2

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)

Emigna
la source

1

Tu m'as battu d'une minute. C'est exactement ce que j'ai écrit, mais j'ai utilisé à la ćplace de ¬.

Riley

@Riley: Fonctionne également avec le filtre, mais ne sauvegarde malheureusement aucun octet.

Emigna

1

@Emigna ne sauvegarde malheureusement aucun octet * enregistre le ou les octets *

Erik the Outgolfer

@EriktheOutgolfer: Oui, eh bien. C'était un changement supplémentaire utilisant la manière étrange de travailler avec la saisie implicite qui a sauvé un octet :)

Emigna

1

@carusocomputing: Oui. Il enregistre en fait un octet pour les avoir dans le "mauvais" ordre car je peux les réutiliser nimplicitement, à la fois dans la comparaison des filtres et dans le calcul de la différence absolue.

Emigna

2

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!

Beluga timide
la source

2

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

Luis Mendo
la source

2

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>

Développer l'extrait

Hirsute
la source

2

Mathematica, 24 octets

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

merci Martin

I / O

[343, 7]

2058

J42161217
la source

Vous pouvez utiliser 1/Log@##ou #2~Log~#. Ou encore mieux permutez l'ordre des entrées et utilisez Log@##.

Martin Ender

Et puis #^Floor[...]#est plus court que #^(Floor[...]+1). Et il y a aussi les opérateurs Unicode Floor.

Martin Ender

oui, oui bien sûr, je travaille sur tout ça, vous êtes rapide!

J42161217

N'oubliez pas Log@##! En fait, si vous changez l'ordre des arguments, cela #^⌊Log@##⌋#-#2&devrait être possible pour -5 octets (je pense)!

CalculatorFeline

2

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

Govind Parmar
la source

2

Utiliser forau lieu d' whileenregistrer deux octets:o;p(n,b){for(o=b;n>=b;)b*=o;return b-n;}

Steadybox

Suggérer à la n/bplace den>=b

plafondcat

2

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.

JAD
la source

1

JavaScript (ES6), 31 octets

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

Cas de test:

Afficher l'extrait de code

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

Développer l'extrait

Rick Hitchcock
la source

Vous pouvez enregistrer un octet en curry (peu importe si j'ai essayé de curry à la fois net bou juste n), car cela vous évite d'avoir à passer nrécursivement.

Neil

Merci @Neil, mais j'ai du mal à trouver comment faire ça (?)

Rick Hitchcock

Les deux versions que j'ai imaginées étaient n=>g=(b,p=b)=>p>n?p-n:g(b,p*b)et n=>b=>(g=p=>p>n?p-n:g(p*b))(b).

Neil

Fonctionnerait f=(n,i)=>g=(b=i)=>b>n?b-n:g(b*i)pour 30 octets? Il devrait être appelé comme ceci: f(324,5)(). EDIT: Ah, @Neil m'a battu.

Shaggy

@Neil, merci, j'ai besoin de plus de pratique avec le curry.

Rick Hitchcock

1

Octave , 32 octets

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

Essayez-le en ligne!

Luis Mendo
la source

1

Octave, 26 octets

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

Vérifiez tous les cas de test!

rahnema1
la source

1

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!

Nnnes
la source

1

Haskell , 31 octets

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

Essayez-le en ligne!

vroomfondel
la source

1

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)

Brad Gilbert b2gills
la source

1

PARI / GP , 26 24 octets

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

Charles
la source

1

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

ETHproductions
la source

1

... Attendez. Quelle?

Shaggy

@Shaggy J'ai ajouté une explication, j'espère que cela aide.

ETHproductions

1

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 .

Jonathan Allan
la source

tio.run/… est un peu plus court mais avoir à produire le résultat au format "% .0f" est probablement de la triche.

rici

@rici Nice, je pense qu'il peut être correct d'utiliser l'arithmétique à virgule flottante. Je vais l'ajouter comme alternative (un autre octet peut être enregistré en changeant de forme car il b-nn'est jamais nul en même temps que n<bc'est vrai).

Jonathan Allan

1

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.

Chaîne non liée
la source

0

PHP> = 7,1, 46 octets

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

PHP Sandbox Online

Jörg Hülsermann
la source

0

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

Katenkyo
la source

Je ne connais pas bien Lua, mais l'espace entre 1et est-il endnécessaire?

Zacharý

@ZacharyT Dans Lua, les nombres hexadécimaux peuvent être alignés s'ils commencent par un nombre, 1endcommenceraient à être interprétés comme le nombre 1epuis lanceraient une erreur car ce 1enn'est pas une valeur hexadécimale valide. Cela ne se produit que lorsque la lettre qui suit le nombre est [abcdef]car les autres lettres ne peuvent pas être interprétées comme une valeur hexadécimale -> w=1whilene génère pas d'erreur.

Katenkyo

Bienvenue à PPCG!

Leaky Nun

0

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

Steenbergh
la source

0

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.

M. Xcoder
la source

Vous pouvez simplifier la boucle pour réduire 7 octets

Rod

@Rod n'aurait jamais pensé à ça :). Merci beaucoup!

M. Xcoder

0

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.

notjagan
la source

import math;lambda n,b:b**-~int(math.log(n,b))-nenregistre deux octets et est autorisé par méta-consensus.

Erik the Outgolfer

@EriktheOutgolfer ceilne fonctionnerait pas.

Leaky Nun

@EriktheOutgolfer Je n'utilisais pas ceilparce que cela ne fonctionne pas pour les pouvoirs de b, mais comme l'a souligné @Uriel, l'importation enregistre toujours un octet.

notjagan

Vous pouvez le reformater pour qu'il soit parfait: essayez-le en ligne! . Il suffit de placer l' importafter le lambda et d'ajouter f=dans l'en-tête.

M. Xcoder

@ Mr.Xcoder Ah, vous avez raison! Je ne sais pas pourquoi cela ne m'est pas venu à l'esprit.

notjagan

0

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!

Steadybox
la source

À quelle distance est n de la prochaine puissance de b?

Réponses:

Gelée , 4 3 octets

Comment?

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

C (gcc) , 39 35 octets

Dyalog APL, 10 octets

R , 38 34 octets

Cubix , 24 20 octets

Explication:

Haskell , 20 octets

05AB1E , 9 8 octets

Java (OpenJDK 8) , 42 octets

MATL , 10 9 octets

Explication

JavaScript (ES6), 29 octets

L'essayer

Mathematica, 24 octets

C, 42 40 octets

R, 30 octets

JavaScript (ES6), 31 octets

Octave , 32 octets

Octave, 26 octets

Rubis , 38 octets

Haskell , 31 octets

Perl 6 , 31 30 29 octets

PARI / GP , 26 24 octets

Japt , 9 octets

Explication

Python , 42 41 octets

Python 3, 37 octets?

Brachylog , 7 octets

PHP> = 7,1, 46 octets

Lua, 74 73 octets

A expliqué

QBIC , 23 octets

Explication

Python 2 , 48 41 octets

Python 3 , 50 48 octets

Lisp commun, 73 octets