Bases balanceadas:

As bases equilibradas são essencialmente as mesmas que as bases normais, exceto que os dígitos podem ser positivos ou negativos, enquanto nas bases normais os dígitos podem ser apenas positivos.

Daqui em diante, bases balanceadas de base bpodem ser representadas como balb- base balanceada 4 = bal4.

Na definição deste desafio, a gama de dígitos em uma base equilibrada da base bé de -(k - 1)que b - k, onde

k = ceil(b/2)

Exemplos do intervalo de dígitos em várias bases balanceadas:

bal10:
  k = ceil(10/2) = 5
  range = -(5 - 1) to 10 - 5 = -4 to 5
        = -4, -3, -2, -1, 0, 1, 2, 3, 4, 5
bal5:
  k = ceil(5/2) = 3
  range = -(3 - 1) to 5 - 3 = -2 to 2
        = -2, -1, 0, 1, 2

As representações de números em bases balanceadas são basicamente as mesmas que as bases normais. Por exemplo, a representação do número 27(base 10) a bal4(base balanceada 4) é 2 -1 -1porque

  2 -1 -1 (bal4)
= 2 * 4^2 + -1 * 4 + -1 * 1
= 32 + (-4) + (-1)
= 27 (base 10)

Tarefa:

Sua tarefa é, com três entradas:

• o número a ser convertido ( n)
  • essa entrada pode ser flexível, consulte "Flexibilidade de E / S"
• a base que nestá atualmente em ( b)
• a base que ndeve ser convertida em ( c)

Onde 2 < b, c < 1,000.

Retorne o número na crepresentação base balanceada de n. A saída também pode ser flexível.

O programa / função deve determinar o comprimento da nprópria entrada.

Flexibilidade de E / S:

Sua entrada ne saída podem ser representadas das seguintes maneiras:

• a definição de matriz de seu idioma
• uma string, com qualquer caractere como separador (por exemplo, espaços, vírgulas)

Exemplos:

Observe que eles usam uma matriz Python como ne a saída. Você pode usar o que for adequado ao seu idioma, desde que ele se enquadre na definição de "I / O Flexibility".

[2, -1, -1] 4 7 = [1, -3, -1]
[1, 2, 3, 4] 9 5 = [1, 2, 2, -1, 2]
[10, -9, 10] 20 5 = [1, 1, 1, -2, 1, 0]

Isso é código-golfe , então o código mais curto em bytes vence!

Mathematica, 85 bytes

#~FromDigits~#2~IntegerDigits~#3//.{p___,a_:0,b_,q___}/;b>⌊#3/2⌋:>{p,a+1,b-#3,q}&

Explicação

#~FromDigits~#2

Converter #1(1 está implícito - entrada 1, uma lista de dígitos) em uma base inteira #2(entrada 2).

... ~IntegerDigits~#3

Converta o número inteiro resultante em base #3(entrada 3), criando uma lista de dígitos.

... //.{p___,a_:0,b_,q___}/;b>⌊#3/2⌋:>{p,a+1,b-#3,q}

Substitua repetidamente a lista de dígitos; se um dígito for maior que o piso ( #3/ 2), subtraia #3e adicione 1ao dígito à esquerda. Se não houver nada à esquerda, insira ae 0adicione 1.

Perl 6 , 121 bytes

->\n,\b,\c{sub f{sum [R,](@^n)Z*($^b X**0..*)}
first {f(b,n)==f c,$_},map {[$_-($_>floor c/2)*c for .base(c).comb]},0..*}

Solução lenta de força bruta.

Como funciona:

• map {[ .base(c).comb]}, 0..*- Gere a sequência infinita lenta de números naturais na base c, com cada número representado como uma matriz de dígitos.
• $_ - ($_ > floor c/2) * c- Transforme-o subtraindo cde cada dígito maior que o piso (c / 2).
• first { f(b, n) == f(c, $_) }, ...- Obtenha a primeira matriz dessa sequência que, quando interpretada como um cnúmero base , é igual à matriz de entrada ninterpretada como um bnúmero base .
• sub f { sum [R,](@^n) Z* ($^b X** 0..*) }- Função auxiliar que transforma uma matriz @^nem um número na base $^b, calculando a soma dos produtos produzidos fechando a matriz invertida com a sequência de potências da base.

JavaScript (ES6), 89 bytes

(n,b,c,g=(n,d=n%c,e=d+d<c)=>[...(n=n/c+!e|0)?g(n):[],e?d:d-c])=>g(n.reduce((r,d)=>r*b+d))

100 bytes funciona para valores negativos de n.

(n,b,c,g=(n,d=(n%c+c)%c)=>[...(n-=d,n/=c,d+d<c||(d-=c,++n),n?g(n):[]),d])=>g(n.reduce((r,d)=>r*b+d))

Mathematica, 118 114 bytes

IntegerDigits[#3~FromDigits~#2,k=⌊#/2⌋;#]//.{{a_,x___}/;a>k:>{1,a-#,x},{x___,a_,b_,y___}/;b>k:>{x,a+1,b-#,y}}&

⌊e ⌋são os caracteres de 3 bytes U+230Ae U+230B, respectivamente. Converte #3em base a 10partir de base #2e depois em base #(portanto, a ordem dos argumentos é revertida nos exemplos). Se qualquer dígito for maior que o dígito máximo permitido k=⌊#/2⌋, diminua esse dígito #e aumente o próximo dígito para cima (pode ser necessário adicionar previamente 1). Continue fazendo isso até que todos os dígitos sejam menores que k.