Convertissez entre des bases équilibrées!

13

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!

code-golf math base-conversion clismique
la source
Dans votre première réponse, 4 n'est pas un chiffre légal de 7 balances; Je pense que la réponse devrait être [1, -3, -1]. Et j'obtiens des réponses différentes pour le deuxième cas de test ([1,2,2, -1,2]) et le troisième cas de test ([1,1,0, -2,1,0]) aussi ...?
Greg Martin
@GregMartin Ah, oups - j'ai calculé ceux-ci à la main, donc il y avait forcément des problèmes. Merci d'avoir remarqué! Pouvez-vous revérifier vos solutions, au cas où?
clismique
@GregMartin @ Qwerp-Derp Le troisième cas de test est[1,1,1,-2,1,0]
ngenisis

Réponses:

2

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.

JungHwan Min
la source
Il est généralement recommandé de parler un peu de votre solution et de l'expliquer aux personnes qui ne connaissent peut-être pas Mathematica.
ATaco
@ATaco Explication ajoutée!
JungHwan Min
Je suis un peu mystifié par cela. Je n'ai jamais vu de modèles optionnels utilisés ailleurs que des définitions de fonctions. Vous n'avez pas besoin de l'extérieur {...}car il n'y a qu'une seule règle de remplacement.
ngenisis
1
@JungHwanMin C'est vrai, je suppose que ce qui m'embrouille, c'est comment cela affecte le match p___. Cela trouve-t-il le plus court p___suivi de a_,b_ou b_, ou vérifie-t-il le modèle entier nécessitant chacun des modèles facultatifs, puis supprime progressivement les modèles facultatifs jusqu'à ce qu'il trouve une correspondance (ou une troisième option)?
ngenisis
1
@ngenisis Je crois que j'avais tort dans le commentaire précédent (supprimé), en observant le résultat de FixedPointList[k=#3;#/.{p___,a_:0,b_,q___}/;b>⌊k/2⌋:>{p,a+1,b-k,q}&, #~FromDigits~#2~IntegerDigits~#3]&. {p___,a_,b_,q___}est mis en correspondance en premier (pour tous les possibles p), puis {p___,b_,q___}est mis en correspondance. Le deuxième remplacement ne s'applique que lorsque best au début, car s'il y a un bmilieu qui satisfait la condition, {p___,a_,b_,q___}il correspondrait à la place.
JungHwan Min
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.
smls
la source
1

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))
Neil
la source
0

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.

ngenisis
la source