Bases equilibradas:

Las bases equilibradas son esencialmente las mismas que las bases normales, excepto que los dígitos pueden ser positivos o negativos, mientras que en las bases normales los dígitos solo pueden ser positivos.

A partir de aquí, las bases de equilibrado de la base bpueden ser representados como balb- por lo equilibrado de base 4 = bal4.

En la definición de este desafío, el rango de dígitos en una base de base equilibrada bes de -(k - 1)a b - k, donde

k = ceil(b/2)

Ejemplos del rango de dígitos en varias 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

Las representaciones de números en bases balanceadas son básicamente las mismas que las bases normales. Por ejemplo, la representación del número 27(base 10) a bal4(base equilibrada 4) es 2 -1 -1, porque

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

Tarea:

Su tarea es, dado tres entradas:

• el número a convertir ( n)
  • esta entrada puede ser flexible, consulte "Flexibilidad de E / S"
• la base que se nencuentra actualmente en ( b)
• la base que nse convertirá a ( c)

Donde 2 < b, c < 1,000.

Devuelve el número en crepresentación base equilibrada de n. La salida también puede ser flexible.

El programa / función debe determinar la longitud de nla entrada en sí.

Flexibilidad de E / S:

Su entrada ny salida se pueden representar de estas maneras:

• la definición de su idioma de una matriz
• una cadena, con cualquier carácter como separador (por ejemplo, espacios, comas)

Ejemplos:

Tenga en cuenta que estos usan una matriz Python como ny la salida. Puede usar lo que se ajuste a su idioma, siempre que se ajuste a la definición de "Flexibilidad de E / S".

[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]

Este es el código de golf , por lo que gana el código más corto en bytes.

Mathematica, 85 bytes

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

Explicación

#~FromDigits~#2

Convierta #1(1 está implícito - entrada 1, una lista de dígitos) en una base entera #2(entrada 2).

... ~IntegerDigits~#3

Convierta el entero resultante en base #3(entrada 3), creando una lista de dígitos.

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

Reemplazar repetidamente la lista de dígitos; si un dígito es mayor que el piso ( #3/ 2), reste #3de él y sume 1al dígito a la izquierda. Si no hay nada a la izquierda, inserte ay 0agregue 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..*}

Solución de fuerza bruta lenta.

Cómo funciona:

• map {[ .base(c).comb]}, 0..*- Genere la secuencia infinita perezosa de números naturales en base c, con cada número representado como una matriz de dígitos.
• $_ - ($_ > floor c/2) * c - Transfórmalo restando c de cada dígito que sea mayor que el piso (c / 2).
• first { f(b, n) == f(c, $_) }, ...- Obtenga la primera matriz de esa secuencia que, cuando se interpreta como un cnúmero base , es igual a la matriz de entrada ninterpretada como una baseb número .
• sub f { sum [R,](@^n) Z* ($^b X** 0..*) }- Función auxiliar que convierte una matriz @^nen un número en base $^b, al tomar la suma de los productos producidos al comprimir la matriz invertida con la secuencia de potencias de la 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, 118114 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}}&

⌊y ⌋son los caracteres de 3 bytes U+230Ay U+230B, respectivamente. Convierte #3a base 10de base #2, luego convierte a base #(por lo que el orden de los argumentos se invierte de los ejemplos). Si algún dígito es mayor que el dígito máximo permitido k=⌊#/2⌋, disminuya ese dígito #e incremente el siguiente dígito hacia arriba (puede que tenga que anteponerse 1). Siga haciendo esto hasta que todos los dígitos sean menores que k.