32

Lasciate ned bessere numeri interi positivi più grandi di 1.

Emette la distanza dalla nprossima potenza di b.

Per n=5e b=3, la potenza successiva di 3from 5è 9( 3^2 = 9), quindi l'output è 9 - 5 = 4.

Per n=8e b=2, la potenza successiva di 2from 8è 16( 2^4 = 16), quindi l'output è 16 - 8 = 8. Si noti che questo nè un potere di 2questo esempio.

Casi test:

Questo è code-golf . Vince la risposta più breve in byte. Si applicano scappatoie standard .

code-golf arithmetic

— Perdente Suora
fonte

16

Gelatina , 4 3 byte

ạæċ

Un collegamento diadico che prende na sinistra ea bdestra e restituisce il risultato.

Provalo online!

Come?

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

— Jonathan Allan
fonte

4

Cancellato 4 è ancora regolare 4; (

— Uriel

2

@Uriel But  ;)

— HyperNeutrino,

quindi il tuo pensiero iniziale iniziale è "oh, è æċ!" invece di "oww è così difficile ..."

— Erik the Outgolfer,

Oh, potrebbe non esistere nella storia, ma sono cambiato da un 4 byte. Eraæċ_⁸

— Jonathan Allan il

@JonathanAllan Dal momento che non era nella storia, non aveva senso ed è per questo che l'ho modificato.

— Erik the Outgolfer,

8

Assemblea x86-64 ( convenzione di chiamata x64 di Windows ), 14 13 byte

Un approccio iterativo inefficiente (ma svelto!) (Con il merito di @Neil per ispirazione):

               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 funzione precedente accetta due parametri interi n((passati nel ECXregistro) e b(passati nel EDXregistro) e restituisce un singolo risultato intero (nel EAXregistro). Per chiamarlo da C, utilizzare il seguente prototipo:

unsigned HowFarAway(unsigned n, unsigned b);

Questo è limitato all'intervallo di un numero intero a 32 bit. Può essere facilmente modificato per supportare numeri interi a 64 bit utilizzando i registri lunghi completi, ma costerebbe più byte per codificare tali istruzioni. :-)

— Cody Grey
fonte

Quindi, non puoi impostare eax su 1 in meno di 4 byte?

— Neil,

Hmm ... Non in nessuno dei modi normali che un programmatore sano userebbe, ma potresti push 1+ pop raxin soli 3 byte. Ma ... allora non dovresti saltare la moltiplicazione, quindi sarebbe comunque un risparmio ragionevole perché potresti lasciar perdere jmp.

— Cody Grey,

Ah, sapevo che doveva esserci un modo per giocare a golf a un byte!

— Neil,

Puoi fare lo stesso con la convenzione di chiamata SysV su Linux, con una demo TIO .

— Trauma digitale il

Certo che puoi. Puoi farlo con qualsiasi convenzione di chiamata che passa almeno i primi due parametri interi nei registri. System V, Win x64, Win32 __fastcall, ecc. I registri cambiano e ho dovuto sceglierne uno. Coin uscì "Windows".

— Cody Grey,

6

C (gcc) , 39 35 byte

Nuovo comportamento indefinito grazie a Erik

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

Provalo online!

— cleblanc
fonte

f(n,b,i){for(i=b;b<n;b*=i);n=b-n;}salva 5 byte ed è supportato da gcc

— Erik the Outgolfer,

@EriktheOutgolfer perché no b-=n?

— Leaky Nun,

@LeakyNun Perché è il primo argomento in cui è necessario salvare il valore restituito.

— Erik the Outgolfer,

Umm, non hai aggiornato il codice.

— Erik the Outgolfer,

Puoi farlo b-=nse cambi l'ordine di be n?

— Zacharý,

6

Dyalog APL, 10 byte

2 byte salvati grazie a @ZacharyT

⊢-⍨⊣*1+∘⌊⍟

Provalo online!

Prende ncome argomento giusto e bcome argomento sinistro.

Calcola .b^{⌊log_bn + 1⌋} - n

— Uriel
fonte

— Bene

@KritixiLithos Ho avuto difficoltà con il trucco del pavimento. pensi che potrebbe essere trasformato in un treno?

— Uriel,

Sì, è possibile: ⊣-⍨⊢*1+∘⌊⍟⍨.

— Zacharý,

@ZacharyT bello!

— Uriel,

Ottengo ⊢-⍨⊣*1+∘⌊⍟10 byte ma con argomenti scambiati, quindi questo nè l'argomento giusto ed bè l'argomento sinistro. Ho usato il trucco di ZacharyT 1+∘⌊per farlo fin qui.

— Kritixi Lithos,

6

R , 38 34 byte

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

Funzione anonima. Memorizza tutti i valori di b alla potenza di tutto nell'intervallo [0, n], sottrae n da ciascuno, sottotipi su valori positivi e restituisce il valore min.

TIO ha una versione non pryr, chiamata come f(n,b); questa versione deve essere chiamata come f(b,n).

Salvati 4 byte grazie a Jarko Dubbeldam, che poi mi ha superato.

Provalo online!

— BLT
fonte

Bello, molto più breve della ricorsione che avevo in mente.

— JAD,

pryr::f({a=b^(0:n)-n;min(a[a>0])})è più breve di alcuni byte.

— JAD,

Grazie. Ho avuto sfortuna nell'usare pryr::fquando definisco una nuova variabile nella funzione; sembra che funzioni qui.

— BLT,

2

Hmm, vale sempre la pena controllare :) Ciò che mi infastidisce è se hai qualcosa del genere sapply(x, sum)o qualunque cosa, che aggiunge sumagli argomenti.

— JAD,

4

Cubix , 24 20 byte

-4 byte grazie a MickyT

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

Legge in input come n,b

Si adatta a un cubo 2x2x2:

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

Spiegazione:

I|I0 : leggi l'ingresso, premi 0 (contatore) nello stack

^w mette l'IP nel posto giusto per il loop:

Pp-: calcola b^(counter), sposta nin cima allo stack, calcolab^(counter) - n
? : gira a sinistra se negativo, dritto se 0, a destra se positivo
- Positivo:: O@uscita dall'alto dello stack (distanza) ed uscita.
- Negativo:: |?procedere come se la parte superiore dello stack fosse zero
<;qu;): punta l'IP nella giusta direzione, fai apparire la parte superiore dello stack (numero negativo / zero), sposta nin fondo allo stack, inversione a U, fai apparire la parte superiore dello stack ( b^(counter)) e incrementa il contatore
L'IP è attivo ^we il programma continua.

Guardalo online!

Provalo online!

— Giuseppe
fonte

1

Usando la stessa procedura, solo un percorso diversoPwp.I|-.;)^0@O?|uq;<

— MickyT

@MickyT genius! Sento che ogni volta che invio una risposta cubica, vieni e ti radi quattro o cinque byte ...

— Giuseppe,

3

Haskell , 20 byte

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

Provalo online!

until salva la giornata

— XNOR
fonte

Augh, sapevo che doveva esserci stato un presupposto per questo. Bello.

— vroomfondel,

2

05AB1E , 9 8 byte

sLmʒ‹}α¬

Provalo online!

Spiegazione

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
fonte

1

Mi hai battuto un minuto. È esattamente quello che ho scritto, ma l'ho usato al ćposto di ¬.

— Riley,

@Riley: funziona anche con il filtro, ma sfortunatamente non salva alcun byte.

— Emigna,

1

@Emigna purtroppo non salva alcun byte * salva byte (s) *

— Erik the Outgolfer

@EriktheOutgolfer: Sì, bene. È stata un'ulteriore modifica utilizzando lo strano modo in cui funzionano gli input impliciti che hanno salvato un byte :)

— Emigna,

1

@carusocomputing: Sì. In realtà salva un byte per averli nell'ordine "sbagliato" in quanto posso riutilizzarli nimplicitamente, sia nel confronto del filtro che nel calcolo della differenza assoluta.

— Emigna,

2

Java (OpenJDK 8) , 42 byte

Basato sulla risposta C di @ GovindParmar .

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

Provalo online!

— Beluga vergognoso
fonte

2

MATL , 10 9 byte

yy:YAn^w-

Provalo online!

Spiegazione

Considera gli input 694e 3come esempio.

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
fonte

2

JavaScript (ES6), 29 byte

Molto simile all'approccio di Rick, ma pubblicato con il suo permesso (e alcuni aiutano a salvare un byte).

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

Provalo

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>

Espandi frammento

— ispido
fonte

2

Mathematica, 24 byte

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

grazie Martin

I / O

[343, 7]

2058

— J42161217
fonte

Puoi usare 1/Log@##o #2~Log~#. O ancora meglio scambiare l'ordine degli input e utilizzare Log@##.

— Martin Ender,

E poi #^Floor[...]#è più breve di #^(Floor[...]+1). E ci sono anche gli operatori Unicode Floor.

— Martin Ender,

sì, sì certo. Sto lavorando a tutto questo. Sei veloce!

— J42161217

Non dimenticare Log@##! In realtà, se si scambia l'ordine degli argomenti, #^⌊Log@##⌋#-#2&dovrebbe essere possibile per -5 byte (credo)!

— Calcolatrice

2

C, 42 40 byte

Grazie al commentatore @Steadybox per l'informazione

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

— Govind Parmar
fonte

2

Usando forinvece di whilesalvare due byte:o;p(n,b){for(o=b;n>=b;)b*=o;return b-n;}

— Steadybox

Suggerisci n/binvece din>=b

— ceilingcat

2

R, 30 byte

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

Valuta la funzione

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

Che prende la prima potenza maggiore o uguale a n, e quindi i substrati nda quel valore.

Modificato ceiling(power)per floor(power+1)garantire che se nè un potere di b, prendiamo il potere successivo.

— JAD
fonte

1

JavaScript (ES6), 31 byte

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

Casi test:

Mostra snippet di codice

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

Espandi frammento

— Rick Hitchcock
fonte

È possibile salvare un byte per currying (non importava se ho provato currying sia ne bo solo n), perché si evita di dover passare nin modo ricorsivo.

— Neil,

Grazie @Neil, ma ho problemi a capire come farlo (?)

— Rick Hitchcock,

Le due versioni che ho ideato erano n=>g=(b,p=b)=>p>n?p-n:g(b,p*b)e n=>b=>(g=p=>p>n?p-n:g(p*b))(b).

— Neil,

Funzionerebbe f=(n,i)=>g=(b=i)=>b>n?b-n:g(b*i)per 30 byte? Si avrebbe bisogno di essere chiamato in questo modo: f(324,5)(). EDIT: Ah, @Neil mi ha battuto.

— Shaggy,

@Neil, grazie, ho bisogno di più pratica con il curry.

— Rick Hitchcock,

1

Ottava , 32 byte

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

Provalo online!

— Luis Mendo
fonte

1

Ottava, 26 byte

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

Verifica tutti i casi di test!

— rahnema1
fonte

1

Rubino , 38 byte

Due approcci diversi:

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

Provalo online!

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

Provalo online!

— Nnnes
fonte

1

Haskell , 31 byte

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

Provalo online!

— vroomfondel
fonte

1

Perl 6 , 31 30 29 byte

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

Provalo (31)

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

Provalo (30)

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

Provalo (29)

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

Provalo (29)

— Brad Gilbert b2gills
fonte

1

PARI / GP , 26 24 byte

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

— Charles
fonte

1

Japt , 9 byte

_q}a@nVpX

Provalo online!

Spiegazione

_  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
fonte

1

... Aspettare. Che cosa?

— Shaggy,

@Shaggy Ho aggiunto una spiegazione, spero che questo aiuti.

— ETHproductions

1

Python , 42 41 byte

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

Una funzione ricorsiva che, a partire da v=1, si moltiplica ripetutamente bfino a quando non supera rigorosamente ae quindi restituisce la differenza.

Provalo online!

Nota: il risultato non sarà mai zero, quindi a>=v and f(a,b,v*b)or v-apuò essere sostituito (a<v)*(v-a)or f(a,b,v*b)senza causare errori di ricorsione.

Python 3, 37 byte?

Usando un'idea di rici's ...

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

che utilizza l'aritmetica in virgola mobile (quindi i risultati possono allontanarsi dalla loro vera distanza),
provalo qui .

— Jonathan Allan
fonte

tio.run/… è un po 'più breve, ma è necessario tradire il risultato con il formato "% .0f".

— rici,

@rici Nice, penso che potrebbe essere OK usare l'aritmetica in virgola mobile. Lo aggiungerò come alternativa (un altro byte può essere salvato cambiando i moduli perché b-nnon è mai zero nello stesso momento in cui n<bè vero).

— Jonathan Allan,

1

Brachylog , 7 byte

^ʰ↙X>₁-

Provalo online!

Accetta input come elenco [b, n].

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

— Stringa non correlata
fonte

0

PHP> = 7.1, 46 byte

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

PHP Sandbox online

— Jörg Hülsermann
fonte

0

Lua, 74 73 byte

Una soluzione semplice, sto usando 10 byte per garantire che gli argomenti siano trattati come numeri e non stringhe. Uscita su STDIN.

Modifica: dimenticato di rimuovere lo spazio in w=1 n=n+0, salva un 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)

spiegato

Provalo 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
fonte

Non conosco Lua così bene, ma è lo spazio tra 1e endnecessario?

— Zacharý,

@ZacharyT In Lua, i numeri esadecimali possono essere incorporati se iniziano con un numero, 1endinizierebbero ad essere interpretati come il numero, 1equindi genererebbero un errore perché 1ennon è un valore esadecimale valido. Ciò si verifica solo quando la lettera che segue il numero è [abcdef]come altre lettere che non possono essere interpretate come valore esadecimale -> w=1whilenon genera un errore.

— Katenkyo,

Bentornato in PPCG!

— Leaky Nun,

0

QBIC , 23 byte

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

Prende bprima il parametro , quindi n.

Spiegazione

{       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
fonte

0

Python 2 , 48 41 byte

@ Semplificazione del loop di Rod salvato 7 byte!

Programma completo senza ricorsione o bit twiddling:

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

Provalo online!

Formato di input: n, b.

— Mr. Xcoder
fonte

È possibile semplificare il loop per ridurre 7 byte

— Rod

@Rod Non ci avrei mai pensato :). Molte grazie!

— Mr. Xcoder,

0

Python 3 , 50 48 byte

^{Grazie a EriktheOutgolfer per aver salvato 2 byte!}

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

Provalo online!

Python non ha log di fantasia o built-in sul soffitto, quindi ho semplicemente seguito l'approccio ovvio con un tocco di golf.

— notjagan
fonte

import math;lambda n,b:b**-~int(math.log(n,b))-nsalva due byte ed è consentito per meta consenso.

— Erik the Outgolfer,

@EriktheOutgolfer ceilnon funzionerebbe.

— Leaky Nun,

@EriktheOutgolfer Non stavo usando ceilperché non funziona per i poteri di b, ma come ha sottolineato @Uriel l'importazione prima di salvare ancora un byte.

— notjagan,

Puoi riformattarlo per essere completamente a posto: provalo online! . Basta posizionare il importdopo il lambda e aggiungere f=nell'intestazione.

— Mr. Xcoder,

@ Mr.Xcoder Ah, hai ragione! Non so perché non mi sia venuto in mente.

— Notjagan,

0

Lisp comune, 73 byte

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

Provalo online!

— Steadybox
fonte

Quanto è distante n dalla prossima potenza di b?

Gelatina , 4 3 byte

Come?

Assemblea x86-64 ( convenzione di chiamata x64 di Windows ), 14 13 byte

C (gcc) , 39 35 byte

Dyalog APL, 10 byte

R , 38 34 byte

Cubix , 24 20 byte

Spiegazione:

Haskell , 20 byte

05AB1E , 9 8 byte

Java (OpenJDK 8) , 42 byte

MATL , 10 9 byte

Spiegazione

JavaScript (ES6), 29 byte

Provalo

Mathematica, 24 byte

C, 42 40 byte

R, 30 byte

JavaScript (ES6), 31 byte

Ottava , 32 byte

Ottava, 26 byte

Rubino , 38 byte

Haskell , 31 byte

Perl 6 , 31 30 29 byte

PARI / GP , 26 24 byte

Japt , 9 byte

Spiegazione

Python , 42 41 byte

Python 3, 37 byte?

Brachylog , 7 byte

PHP> = 7.1, 46 byte

Lua, 74 73 byte

spiegato

QBIC , 23 byte

Spiegazione

Python 2 , 48 41 byte

Python 3 , 50 48 byte

Lisp comune, 73 byte