Bases équilibrées:

Les bases équilibrées sont essentiellement les mêmes que les bases normales, sauf que les chiffres peuvent être positifs ou négatifs, tandis que dans les bases normales, les chiffres ne peuvent être que positifs.

A partir de là, les bases équilibrées de la base bpeuvent être représentées comme balb- donc la base équilibrée 4 = bal4.

Dans la définition de ce défi, la plage de chiffres dans une base de base équilibrée best de -(k - 1)à b - k, où

k = ceil(b/2)

Exemples de plage de chiffres dans diverses bases équilibrées:

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

Les représentations des nombres dans les bases équilibrées sont fondamentalement les mêmes que les bases normales. Par exemple, la représentation du nombre 27(base 10) à bal4(base équilibrée 4) est 2 -1 -1, car

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

Tâche:

Votre tâche est, compte tenu de trois entrées:

• le nombre à convertir ( n)
  • cette entrée peut être flexible, voir "Flexibilité des E / S"
• la base qui nest actuellement en ( b)
• la base qui ndoit être convertie en ( c)

O 2 < b, c < 1,000..

Renvoie le nombre en creprésentation de base équilibrée de n. La sortie peut également être flexible.

Le programme / fonction doit déterminer la longueur de nl'entrée elle-même.

Flexibilité d'E / S:

Vos entrées net sorties peuvent être représentées de ces manières:

• la définition de votre langue d'un tableau
• une chaîne, avec n'importe quel caractère comme séparateur (par exemple des espaces, des virgules)

Exemples:

Notez que ceux-ci utilisent un tableau Python en tant que net la sortie. Vous pouvez utiliser ce qui convient à votre langue, tant qu'il correspond à la définition de la «flexibilité des 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]

C'est le code-golf , donc le code le plus court en octets gagne!

Mathematica, 85 octets

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

Explication

#~FromDigits~#2

Convertir #1(1 est implicite - entrée 1, une liste de chiffres) en une base entière #2(entrée 2).

... ~IntegerDigits~#3

Convertissez l'entier résultant en base #3(entrée 3), créant une liste de chiffres.

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

Remplacez à plusieurs reprises la liste des chiffres; si un chiffre est supérieur au plancher ( #3/ 2), soustrayez- #3le et ajoutez-le 1au chiffre de gauche. S'il n'y a rien à gauche, insérez a 0et ajoutez 1.

Perl 6 , 121 octets

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

Solution de force brute lente.

Comment ça fonctionne:

• map {[ .base(c).comb]}, 0..*- Générez la séquence infinie paresseuse de nombres naturels en base c, chaque nombre étant représenté par un tableau de chiffres.
• $_ - ($_ > floor c/2) * c- Transformez-le en soustrayant cde chaque chiffre supérieur au plancher (c / 2).
• first { f(b, n) == f(c, $_) }, ...- Obtenez le premier tableau de cette séquence qui, lorsqu'il est interprété comme un cnuméro de base , est égal au tableau d'entrée ninterprété comme un bnuméro de base .
• sub f { sum [R,](@^n) Z* ($^b X** 0..*) }- Fonction d'assistance qui transforme un tableau @^nen nombre dans la base $^b, en prenant la somme des produits obtenus en zippant le tableau inversé avec la séquence de puissances de la base.

JavaScript (ES6), 89 octets

(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 octets fonctionne pour des valeurs négatives 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 octets

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

⌊et ⌋sont les caractères à 3 octets U+230Aet U+230B, respectivement. Convertit #3en base 10depuis base #2, puis convertit en base #(donc l'ordre des arguments est inversé par rapport aux exemples). Si un chiffre est supérieur au chiffre maximal autorisé k=⌊#/2⌋, décrémentez ce chiffre de #et incrémentez le chiffre suivant (il peut être nécessaire de faire précéder 1). Continuez ainsi jusqu'à ce que tous les chiffres soient inférieurs à k.