32

Seja ne bsejam inteiros positivos maiores que 1.

Emita a distância naté a próxima potência de b.

Para n=5e b=3, a próxima potência de 3from 5é 9( 3^2 = 9), portanto a saída é9 - 5 = 4 .

Para n=8e b=2, a próxima potência de 2from 8é 16( 2^4 = 16), então a saída é 16 - 8 = 8. Observe que né um poder 2deste exemplo.

Casos de teste:

Isso é código-golfe . A resposta mais curta em bytes vence. Aplicam-se brechas padrão .

code-golf arithmetic

— Freira Furada
fonte

16

Gelatina , 4 3 bytes

ạæċ

Um link diádico tomando nà esquerda eb à direita e retornando o resultado.

Experimente online!

Quão?

ạæċ - 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

Riscado 4 ainda é regular 4; (

— Uriel

2

@Uriel But  ;)

— HyperNeutrino

Se o seu pensamento inicial inicial é "oh, é æċ!" em vez de "uau, isso é tãããão difícil ..."

— Erik the Outgolfer

Oh, pode não existir na história, mas mudei de 4 byter. Foiæċ_⁸

— Jonathan Allan

@ JonathanAllan Como não estava na história, não fazia sentido, e foi por isso que editei isso.

— Erik the Outgolfer

8

Montagem x86-64 ( Convenção de chamada do Windows x64 ), 14 13 bytes

Uma abordagem iterativa ineficiente (mas esbelta!) (Com crédito a @Neil pela inspiração):

               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

A função acima pega dois parâmetros inteiros n(passados no ECXregistrador) e b(passados no EDXregistrador) e retorna um único resultado inteiro (no EAXregistrador). Para chamá-lo de C, você usaria o seguinte protótipo:

unsigned HowFarAway(unsigned n, unsigned b);

Isso é limitado ao intervalo de um número inteiro de 32 bits. Ele pode ser facilmente modificado para oferecer suporte a números inteiros de 64 bits usando os registros longos completos, mas custaria mais bytes para codificar essas instruções. :-)

— Cody Gray
fonte

Então, você não pode definir eax como 1 em menos de 4 bytes?

— Neil

Hmm ... Não da maneira normal que um programador sensato usaria, mas você poderia push 1+ pop raxem apenas 3 bytes. Mas ... então você não precisaria pular a multiplicação, de modo que ainda seria uma economia razoável, porque você poderia largar a jmp.

— Cody Grey

Ah, eu sabia que tinha que haver uma maneira de tirar um byte de golfe!

— 19417 Neil

Você pode fazer o mesmo com a convenção de chamada SysV no Linux, com uma demonstração do TIO .

— Digital Trauma

Claro que você pode. Você pode fazer isso com qualquer convenção de chamada que passe pelo menos os dois primeiros parâmetros inteiros nos registradores. Sistema V, Win x64, Win32 __fastcall, etc. Os registros mudam e eu tive que escolher um. Moeda surgiu "Windows".

— Cody Grey

6

C (gcc) , 39 35 bytes

Novo comportamento indefinido graças a Erik

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

Experimente online!

— cleblanc
fonte

f(n,b,i){for(i=b;b<n;b*=i);n=b-n;}economiza 5 bytes, e é apoiado por gcc

— Erik o Outgolfer

@EriktheOutgolfer porque não b-=n?

— Leaky Nun

@LeakyNun Porque é o primeiro argumento no qual você precisa salvar o valor de retorno.

— Erik the Outgolfer

Umm, você não atualizou o código.

— Erik o Outgolfer

Você pode fazer b-=nse você trocar a ordem de be n?

— Zachary

6

Dyalog APL, 10 bytes

2 bytes salvos graças a @ZacharyT

⊢-⍨⊣*1+∘⌊⍟

Experimente online!

Toma ncomo argumento certo e bcomo argumento esquerdo.

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

— Uriel
fonte

Bom, eu estava prestes a publicar esta solução exata

— Kritixi Lithos

@KritixiLithos Eu tive dificuldades com o truque no chão. você acha que poderia ser transformado em um trem?

— Uriel

Sim, é possível: ⊣-⍨⊢*1+∘⌊⍟⍨.

— Zachary

@ZacharyT nice one!

— Uriel

Eu recebo ⊢-⍨⊣*1+∘⌊⍟10 bytes, mas com argumentos trocados, de modo que esse né o argumento correto e bo argumento esquerdo. Eu usei o truque de ZacharyT 1+∘⌊para chegar até aqui.

— Kritixi Lithos

6

R , 38 34 bytes

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

Função anônima. Armazena todos os valores de b à potência de tudo no intervalo [0, n], subtrai n de cada um, subconta em valores positivos e retorna o mínimo.

O TIO possui uma versão não-pryr, chamada como f(n,b) ; esta versão precisa ser chamada como f(b,n).

Economizou 4 bytes graças a Jarko Dubbeldam, que então me superou.

Experimente online!

— BLT
fonte

Bom, muito mais curto que a recursão que eu tinha em mente.

— JAD

pryr::f({a=b^(0:n)-n;min(a[a>0])})é alguns bytes mais curto.

— JAD

Obrigado. Eu tive má sorte usando pryr::fquando defino uma nova variável na função; parece que funciona aqui.

— BLT

2

Hmm, sempre vale a pena conferir :) O que me incomoda é se você tem algo parecido sapply(x, sum)ou algo assim , que isso acrescenta sumaos argumentos.

— JAD

4

Cubix , 24 20 bytes

-4 bytes graças ao MickyT

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

Lê na entrada como n,b

Se encaixa em um cubo 2x2x2:

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

Explicação:

I|I0 : leia a entrada, pressione 0 (contador) na pilha

^w coloca o IP no lugar certo para o loop:

Pp-: calcular b^(counter), mover npara o topo da pilha, calcularb^(counter) - n
? : virar à esquerda se negativo, reto se 0, à direita se positivo
- Positivo:: O@saída da parte superior da pilha (distância) e saída.
- Negativo:: |?prossiga como se o topo da pilha fosse zero
<;qu;): aponte o IP na direção certa, coloque na parte superior da pilha (número negativo / zero), vá para a parte inferior da pilha, faça inversão de marcha, coloque a parte superior da pilha (b^(counter) ) e aumente o contador
O IP está em ^we o programa continua.

Assista online!

Experimente online!

— Giuseppe
fonte

11

Usando o seu mesmo procedimento, só um caminho diferentePwp.I|-.;)^0@O?|uq;<

— MickyT

@MickyT genius! Eu sinto que cada vez que eu enviar uma resposta cubix, você vem e raspar quatro ou cinco bytes ...

— Giuseppe

3

Haskell , 20 bytes

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

Experimente online!

until salva o dia

— xnor
fonte

Augh, eu sabia que devia ter sido construído para isso. Agradável.

— vroomfondel

2

05AB1E , 9 8 bytes

sLmʒ‹}α¬

Experimente online!

Explicação

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

11

Você me venceu por um minuto. Foi exatamente o que escrevi, mas usei em ćvez de ¬.

— Riley

@Riley: Também funciona com filtro, mas infelizmente não salva bytes.

— Emigna

11

@Emigna infelizmente não salva bytes * salva byte (s) *

— Erik the Outgolfer

@EriktheOutgolfer: Sim, bem. Foi uma alteração adicional utilizando o modo estranho obras de entrada implícitas que salvou um byte :)

— Emigna

11

@carusocomputing: Sim. Na verdade, ele salva um byte para tê-los na ordem "errada" , pois posso reutilizar nimplicitamente, tanto na comparação de filtros quanto no cálculo da diferença absoluta.

— Emigna

2

Java (OpenJDK 8) , 42 bytes

Com base na resposta C de @ GovindParmar .

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

Experimente online!

— Beluga Bashful
fonte

2

MATL , 10 9 bytes

yy:YAn^w-

Experimente online!

Explicação

Considere entradas 694e 3como um exemplo.

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 bytes

Muito parecido com a abordagem de Rick, mas publicado com sua permissão (e alguma ajuda para salvar um byte).

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

Tente

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>

Expandir snippet

— Shaggy
fonte

2

Mathematica, 24 bytes

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

obrigado Martin

I / O

[343, 7]

2058

— J42161217
fonte

Você pode usar 1/Log@##ou #2~Log~#. Ou ainda melhor, trocar a ordem das entradas e usar Log@##.

— Martin Ender

E então #^Floor[...]#é mais curto que #^(Floor[...]+1). E também há operadores Unicode Floor.

— Martin Ender

Sim, sim, claro. Estou trabalhando em tudo isso. você é rápido!

— J42161217

Não esqueça Log@##! Na verdade, se você trocar a ordem dos argumentos, #^⌊Log@##⌋#-#2&deve ser possível por -5 bytes (eu acho)!

— CalculatorFeline

2

C, 42 40 bytes

Obrigado ao comentarista @Steadybox pela dica

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

— Govind Parmar
fonte

2

Usar em forvez de whilesalvar dois bytes:o;p(n,b){for(o=b;n>=b;)b*=o;return b-n;}

— Steadybox

Sugerir em n/bvez den>=b

— ceilingcat

2

R, 30 bytes

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

Avalia para a função

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

Qual leva a primeira potência maior ou igual a ne, em seguida, substratos ndesse valor.

Alterado ceiling(power)para floor(power+1)garantir que, se nfor um poder b, assumimos o poder seguinte.

— JAD
fonte

1

JavaScript (ES6), 31 bytes

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

Casos de teste:

Mostrar snippet de código

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

Expand snippet

— Rick Hitchcock
fonte

Você pode salvar um byte fazendo curry (não importa se eu tentei curry os dois ne bapenas n), porque isso evita que você nprecise passar recursivamente.

— 19417 Neil

Graças @Neil, mas eu estou tendo dificuldade para descobrir como fazer isso (?)

— Rick Hitchcock

As duas versões que eu criei foram 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).

— 19417 Neil

Iria f=(n,i)=>g=(b=i)=>b>n?b-n:g(b*i)trabalhar por 30 bytes? Teria de ser chamado assim: f(324,5)(). EDIT: Ah, @ Nee me venceu.

— Shaggy

@ Neil, obrigado, preciso de mais prática com currying.

— 21417 Rick Stallone

1

Oitava , 32 bytes

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

Experimente online!

— Luis Mendo
fonte

1

Oitava, 26 bytes

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

Verifique todos os casos de teste!

— rahnema1
fonte

1

Ruby , 38 bytes

Duas abordagens diferentes:

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

Experimente online!

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

Experimente online!

— Nnnes
fonte

1

Haskell , 31 bytes

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

Experimente online!

— vroomfondel
fonte

1

Perl 6 , 31 30 29 bytes

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

Teste (31)

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

Teste (30)

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

Teste (29)

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

Teste (29)

— Brad Gilbert b2gills
fonte

1

PARI / GP , 26 24 bytes

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

— Charles
fonte

1

Japonês , 9 bytes

_q}a@nVpX

Teste online!

Explicação

_  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

11

... Esperar. O que?

— Shaggy

@ Shaygy Eu adicionei uma explicação, espero que isso ajude.

— ETHproductions

1

Python , 42 41 bytes

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

Uma função recursiva que, começando com v=1, multiplica-se repetidamente baté exceder estritamente ae depois retorna a diferença.

Experimente online!

Nota: O resultado nunca será zero; portanto, a>=v and f(a,b,v*b)or v-apode ser substituído por(a<v)*(v-a)or f(a,b,v*b) sem causar erros de recursão.

Python 3, 37 bytes?

Usando uma idéia de rici's ...

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

que usa aritmética de ponto flutuante (portanto, os resultados podem se afastar da distância real),
tente isso aqui .

— Jonathan Allan
fonte

tio.run/… é um pouco mais curto, mas ter que gerar o resultado com o formato "% .0f" provavelmente está trapaceando.

— rici

@rici Nice, acho que pode ser bom usar aritmética de ponto flutuante. Vou adicioná-lo como uma alternativa (outro byte pode ser salvo alternando os formulários devido a b-nnunca ser zero ao mesmo tempo que n<bé verdadeiro).

— Jonathan Allan

1

Braquilog , 7 bytes

^ʰ↙X>₁-

Experimente online!

Leva a entrada como uma lista [b, n].

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

— String não relacionada
fonte

0

PHP> = 7.1, 46 bytes

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

Sandbox do PHP Online

— Jörg Hülsermann
fonte

0

Lua, 74 73 Byte

Uma solução direta, estou usando 10 bytes para garantir que os argumentos sejam tratados como números e não como seqüências de caracteres. Saídas para STDIN.

Editar: esqueceu de remover o espaço w=1 n=n+0, economiza um 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)

Explicado

Experimente 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

Eu não conheço Lua tão bem, mas é o espaço entre 1e endnecessário?

— Zachary

@ZacharyT Em Lua, números hexadecimais podem ser incorporados se começarem com um número, 1end começarem a ser interpretados como o número e, em 1eseguida, gerarão um erro porque 1ennão é um valor hexadecimal válido. Isso ocorre apenas quando a letra após o número é [abcdef]como outras letras não pode ser interpretada como valor hexadecimal -> w=1whilenão gera um erro.

— precisa

Bem-vindo de volta ao PPCG!

— Leaky Nun

0

QBIC , 23 bytes

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

Toma bprimeiro o parâmetro e depoisn .

Explicação

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

@ A simplificação do loop de Rod economizou 7 bytes!

Programa completo sem recursão ou manipulação de bits:

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

Experimente online!

Formato de entrada: n, b.

— Mr. Xcoder
fonte

Você pode simplificar o loop para reduzir 7 bytes

— Rod

@ Rod nunca teria pensado nisso :). Muito obrigado!

— Mr. Xcoder

0

Python 3 , 50 48 bytes

^{Obrigado ao EriktheOutgolfer por salvar 2 bytes!}

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

Experimente online!

O Python não possui nenhum log sofisticado ou teto embutido, então eu apenas segui a abordagem óbvia com um pouco de talento para o golfe.

— notjagan
fonte

import math;lambda n,b:b**-~int(math.log(n,b))-nsalva dois bytes e é permitido por meta consenso.

— Erik the Outgolfer

@EriktheOutgolfer ceilnão funcionaria.

— Leaky Nun

@EriktheOutgolfer eu não estava usando ceilporque não funciona para os poderes de b, mas como @Uriel apontou a importação antes ainda salva um byte.

— notjagan

Você pode reformatá-lo para ficar completamente bem: Experimente on-line! . Basta colocar o importapós o lambda e adicionar f=no cabeçalho.

— Mr. Xcoder

@ Mr.Xcoder Ah, você está correto! Não sei por que isso não me ocorreu.

— notjagan

0

Lisp comum, 73 bytes

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

Experimente online!

— Steadybox
fonte

A que distância está n da próxima potência de b?

Gelatina , 4 3 bytes

Quão?

Montagem x86-64 ( Convenção de chamada do Windows x64 ), 14 13 bytes

C (gcc) , 39 35 bytes

Dyalog APL, 10 bytes

R , 38 34 bytes

Cubix , 24 20 bytes

Explicação:

Haskell , 20 bytes

05AB1E , 9 8 bytes

Java (OpenJDK 8) , 42 bytes

MATL , 10 9 bytes

Explicação

JavaScript (ES6), 29 bytes

Tente

Mathematica, 24 bytes

C, 42 40 bytes

R, 30 bytes

JavaScript (ES6), 31 bytes

Oitava , 32 bytes

Oitava, 26 bytes

Ruby , 38 bytes

Haskell , 31 bytes

Perl 6 , 31 30 29 bytes

PARI / GP , 26 24 bytes

Japonês , 9 bytes

Explicação

Python , 42 41 bytes

Python 3, 37 bytes?

Braquilog , 7 bytes

PHP> = 7.1, 46 bytes

Lua, 74 73 Byte

Explicado

QBIC , 23 bytes

Explicação

Python 2 , 48 41 bytes

Python 3 , 50 48 bytes

Lisp comum, 73 bytes