Basi bilanciate:

Le basi bilanciate sono essenzialmente le stesse delle basi normali, tranne per il fatto che le cifre possono essere positive o negative, mentre in basi normali le cifre possono essere solo positive.

Da qui in poi, le basi bilanciate della base bpossono essere rappresentate come balb- così la base bilanciata 4 = bal4.

Nella definizione di questa sfida, l'intervallo di cifre in una base di base bilanciata bva da -(k - 1)a b - k, dove

k = ceil(b/2)

Esempi di intervallo di cifre in varie basi bilanciate:

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

Le rappresentazioni dei numeri in basi bilanciate sono sostanzialmente le stesse delle basi normali. Ad esempio, la rappresentazione del numero 27(base 10) in bal4(base bilanciata 4) è 2 -1 -1, perché

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

Compito:

Il tuo compito è, dato tre input:

• il numero da convertire ( n)
  • questo input può essere flessibile, vedere "Flessibilità I / O"
• la base che nè attualmente in ( b)
• la base che ndeve essere convertita in ( c)

Dove 2 < b, c < 1,000.

Restituisce il numero nella crappresentazione di base bilanciata di n. L'output può anche essere flessibile.

Il programma / funzione deve determinare la lunghezza ndell'input stesso.

Flessibilità I / O:

I tuoi input ne output possono essere rappresentati in questi modi:

• la definizione della lingua di un array
• una stringa, con qualsiasi carattere come separatore (ad es. spazi, virgole)

Esempi:

Si noti che questi usano un array Python come ne l'output. È possibile utilizzare ciò che si adatta alla propria lingua, purché rientri nella definizione di "Flessibilità I / O".

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

Questo è code-golf , quindi vince il codice più breve in byte!

Mathematica, 85 byte

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

Spiegazione

#~FromDigits~#2

Converti #1(1 è implicito - input 1, un elenco di cifre) in una base intera #2(input 2).

... ~IntegerDigits~#3

Converti l'intero risultante in base #3(input 3), creando un elenco di cifre.

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

Sostituire ripetutamente l'elenco delle cifre; se una cifra è maggiore del pavimento ( #3/ 2), sottrarre #3da essa e aggiungere 1alla cifra a sinistra. Se non c'è nulla a sinistra, inserisci a 0e aggiungi 1.

Perl 6 , 121 byte

->\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..*}

Soluzione a forza bruta lenta.

Come funziona:

• map {[ .base(c).comb]}, 0..*- Genera la sequenza pigra infinita di numeri naturali in base c, con ogni numero rappresentato come una matrice di cifre.
• $_ - ($_ > floor c/2) * c- Trasformalo sottraendo cda ogni cifra maggiore del piano (c / 2).
• first { f(b, n) == f(c, $_) }, ...- Ottieni il primo array di quella sequenza che, quando interpretato come cnumero base , è uguale all'array di input ninterpretato come bnumero base .
• sub f { sum [R,](@^n) Z* ($^b X** 0..*) }- Funzione di aiuto che trasforma un array @^nin un numero in base $^b, prendendo la somma dei prodotti ottenuti zippando l'array invertito con la sequenza di potenze della base.

JavaScript (ES6), 89 byte

(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 byte funziona per valori negativi di 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 byte

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 ⌋sono i caratteri a 3 byte U+230Ae U+230B, rispettivamente. Converte #3in base 10da base #2, quindi converte in base #(quindi l'ordine degli argomenti viene invertito dagli esempi). Se una cifra è maggiore della cifra massima consentita k=⌊#/2⌋, decrementa quella cifra di #e incrementa la cifra successiva verso l'alto (potrebbe essere necessario anteporre 1). Continuare a farlo fino a quando tutte le cifre sono inferiori a k.