Arbitrary Base Conversion [geschlossen]

10

Erstellen Sie eine Routine, die ein Array von Blöcken in einem numerischen Basissystem verwendet, und konvertieren Sie sie in ein Array von Blöcken in einem anderen numerischen Basissystem. Sowohl das Von- als auch das Bis-System sind beliebig und sollten als Parameter akzeptiert werden. Das Eingabearray kann eine beliebige Länge haben (Wenn eine Sprache verwendet wird, in der keine Arraylängen mit dem Array gespeichert sind, z. B. C, sollte ein Längenparameter an die Funktion übergeben werden).

So sollte es funktionieren:

fromArray = [1, 1]
fromBase = 256
toBase = 16
result = convertBase(fromArray, fromBase, toBase);

Welche sollten zurückkehren [0, 1, 0, 1]oder möglicherweise [1, 0, 1](führende 0s sind optional, da sie den Wert der Antwort nicht ändern).

Hier sind einige Testvektoren:

  1. Identitätstestvektor

    fromArray = [1, 2, 3, 4]
fromBase = 16
toBase = 16
result = [1, 2, 3, 4]

  2. Trivialer Testvektor

    fromArray = [1, 0]
fromBase = 10
toBase = 100
result = [10]

  3. Großer Testvektor

    fromArray = [41, 15, 156, 123, 254, 156, 141, 2, 24]
fromBase = 256
toBase = 16
result = [2, 9, 0, 15, 9, 12, 7, 11, 15, 14, 9, 12, 8, 13, 0, 2, 1, 8]

  4. Wirklich großer Testvektor

    fromArray = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
fromBase = 2
toBase = 10
result = [1, 2, 3, 7, 9, 4, 0, 0, 3, 9, 2, 8, 5, 3, 8, 0, 2, 7, 4, 8, 9, 9, 1, 2, 4, 2, 2, 3]

  5. Ungleichmäßiger Basisvektor

    fromArray = [41, 42, 43]
fromBase = 256
toBase = 36
result = [1, 21, 29, 22, 3]

Andere Kriterien / Regeln:

  1. Alle ganzzahligen Variablen sollten für alle vernünftigen Eingabebereiche in eine standardmäßige 32-Bit-Ganzzahl mit Vorzeichen passen.

  2. Sie können in eine Zwischendarstellung konvertieren, solange der Vermittler nur ein Array von 32-Bit-Ganzzahlen mit Vorzeichen ist.

  3. Erwarten Sie, Basen von 2 bis 256 zu handhaben. Es besteht keine Notwendigkeit, höhere Basen als diese zu unterstützen (aber wenn Sie möchten, auf jeden Fall).

  4. Erwarten Sie Eingangs- und Ausgangsgrößen von mindestens bis zu 1000 Elementen. Eine Lösung, die auf 2 ^ 32-1 Elemente skaliert, wäre besser, aber 1000 ist in Ordnung.

  5. Hier geht es nicht unbedingt darum, den kürzesten Code zu haben, der diese Regeln erfüllt. Es geht darum, den saubersten und elegantesten Code zu haben.

Nun, das ist nicht gerade trivial, also könnte eine Antwort, die fast funktioniert, akzeptiert werden!

code-challenge number ircmaxell
quelle
Bedeutet # 1, dass wir keinen Bigint-Typ verwenden können?
Keith Randall
@ Keith: Richtig. Nur 32-Bit-Ganzzahlen.
Ircmaxell
Sie sagen "Ganzzahl mit Vorzeichen", aber die Beispiele gelten nur für positive Ganzzahlen. Müssen wir also mit Negativen umgehen?
Eelvex
@Eelvex: Ich sehe keine Notwendigkeit, mit Negativen umzugehen. Wenn ein Negativ behandelt wird, befindet es sich außerhalb des Konverters.
Ircmaxell
Sind sie immer ganzzahlige Basen?
Peter Olson

Antworten:

8

Python

# divides longnum src (in base src_base) by divisor
# returns a pair of (longnum dividend, remainder)
def divmod_long(src, src_base, divisor):
  dividend=[]
  remainder=0
  for d in src:
    (e, remainder) = divmod(d + remainder * src_base, divisor)
    if dividend or e: dividend += [e]
  return (dividend, remainder)

def convert(src, src_base, dst_base):
  result = []
  while src:
    (src, remainder) = divmod_long(src, src_base, dst_base)
    result = [remainder] + result
  return result
Keith Randall
quelle
Vielen Dank. Ich suchte nach einer solchen Routine. Ich habe eine Weile gebraucht, um es in Javascript umzuwandeln. Ich werde es wahrscheinlich ein wenig Golf spielen und hier zum Spaß posten.
Stephen Perelson
5

Hier ist eine Haskell-Lösung

import Data.List
import Control.Monad

type Numeral = (Int, [Int])

swap              ::  (a,b) -> (b,a)
swap (x,y)        =   (y,x)

unfoldl           ::  (b -> Maybe (b,a)) -> b -> [a]
unfoldl f         =   reverse . unfoldr (fmap swap . f)

normalize         ::  Numeral -> Numeral
normalize (r,ds)  =   (r, dropWhile (==0) ds)

divModLongInt            ::  Numeral -> Int -> (Numeral,Int)
divModLongInt (r,dd) dv  =   let  divDigit c d = swap ((c*r+d) `divMod` dv)
                                  (remainder, quotient) = mapAccumR divDigit 0 (reverse dd)
                             in   (normalize (r,reverse quotient), remainder)

changeRadixLongInt       ::  Numeral -> Int -> Numeral
changeRadixLongInt n r'  =   (r', unfoldl produceDigit n)
  where  produceDigit  (_,[])   =  Nothing
         produceDigit  x        =  Just (divModLongInt x r')

changeRadix :: [Int] -> Int -> Int -> [Int]
changeRadix digits origBase newBase = snd $ changeRadixLongInt (origBase,digits) newBase

doLine line = let [(digits,rest0)] = reads line
                  [(origBase,rest1)] = reads rest0
                  [(newBase,rest2)] = reads rest1
              in show $ changeRadix digits origBase newBase

main = interact (unlines . map doLine . lines)

Und die Tests aus der Frage ausführen:

$ ./a.out 
[1,2,3,4] 16 16
[1,2,3,4]
[1,0] 10 100
[10]
[41, 15, 156, 123, 254, 156, 141, 2, 24] 256 16
[2,9,0,15,9,12,7,11,15,14,9,12,8,13,0,2,1,8]
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] 2 10
[1,2,3,7,9,4,0,0,3,9,2,8,5,3,8,0,2,7,4,8,9,9,1,2,4,2,2,3]
[41, 42, 43] 256 36
[1,21,29,22,3]
Geoff Reedy
quelle
Oh wow. Das ist großartig! Wenn ich es nur verstehen könnte: -) ... (aber das ist jetzt meine Aufgabe) ...
ircmaxell
5

R.

Behandelt viele tausend Elemente * in weniger als einer Minute.

addb <- function(v1,v2,b) {
    ml <- max(length(v1),length(v2))
    v1 <- c(rep(0, ml-length(v1)),v1)
    v2 <- c(rep(0, ml-length(v2)),v2)
    v1 = v1 + v2
    resm = v1%%b
    resd = c(floor(v1/b),0)
    while (any(resd != 0)) {
        v1 = c(0,resm) + resd
        resm = v1%%b
        resd = c(floor(v1/b),0)
    }
    while (v1[1] == 0) v1 = v1[-1]
    return(v1)
}

redb <- function(v,b) {
    return (addb(v,0,b))
}

mm = rbind(1)

mulmat <- function(fromb, tob, n) {
    if (dim(mm)[2] >= n) return(mm)
    if (n == 1) return(1)
    newr = addb(mulmat(fromb,tob,n-1) %*% rep(fromb-1,n-1), 1, tob)
    newm = mulmat(fromb,tob,n-1)
    while (is.null(dim(newm)) || dim(newm)[1] < length(newr)) newm = rbind(0,newm)
    mm <<-  cbind(newr, newm)
    return(mm)
}

dothelocomotion <- function(fromBase, toBase, v) {
    mm  <<- rbind(1)
    return(redb(mulmat(fromBase, toBase, length(v)) %*% v, toBase))
}

* Für> 500 Elemente müssen Sie die Standardrekursionsstufe erhöhen oder die mmMatrix nicht zurücksetzendothelocomotion()

Beispiele:

v1 = c(41, 15, 156, 123, 254, 156, 141, 2, 24)
dothelocomotion(256,16,v1)
2  9  0 15  9 12  7 11 15 14  9 12  8 13  0  2  1  8

dothelocomotion(256,36,c(41,42,43))
1 21 29 22  3

dothelocomotion(2,10, rep(1,90))
1 2 3 7 9 4 0 0 3 9 2 8 5 3 8 0 2 7 4 8 9 9 1 2 4 2 2 3
Eelvex
quelle
3

Eine weniger verschleierte und schnellere JavaScript-Version:

function convert (number, src_base, dst_base)
{
    var res = [];
    var quotient;
    var remainder;

    while (number.length)
    {
        // divide successive powers of dst_base
        quotient = [];
        remainder = 0;
        var len = number.length;
        for (var i = 0 ; i != len ; i++)
        {
            var accumulator = number[i] + remainder * src_base;
            var digit = accumulator / dst_base | 0; // rounding faster than Math.floor
            remainder = accumulator % dst_base;
            if (quotient.length || digit) quotient.push(digit);
        }

        // the remainder of current division is the next rightmost digit
        res.unshift(remainder);

        // rinse and repeat with next power of dst_base
        number = quotient;
    }

    return res;
}

Die Rechenzeit wächst mit o (Anzahl der Ziffern 2 ).
Nicht sehr effizient für große Zahlen.
Spezialisierte Versionen Line Base64-Codierung nutzen Basisverhältnisse, um die Berechnungen zu beschleunigen.


quelle
Gottes Werk tun Sohn
Bryc
2

Javascript

Vielen Dank an Keith Randall für Ihre Python-Antwort. Ich hatte Probleme mit den Details meiner Lösung und kopierte schließlich Ihre Logik. Wenn jemand eine Stimme für diese Lösung abgibt, weil sie funktioniert, geben Sie bitte auch eine Stimme für die Lösung von Keith.

function convert(src,fb,tb){
  var res=[]
  while(src.length > 0){
    var a=(function(src){
      var d=[];var rem=0
      for each (var i in src){
        var c=i+rem*fb
        var e=Math.floor(c/tb)
        rem=c%tb
        d.length||e?d.push(e):0
      }
      return[d,rem]
    }).call(this,src)
    src=a[0]
    var rem=a[1]
    res.unshift(rem)
  }
  return res
}

Tests

console.log(convert([1, 2, 3, 4], 16, 16))
console.log(convert([1, 0], 10, 100))
console.log(convert([41, 15, 156, 123, 254, 156, 141, 2, 24], 256, 16))
console.log(convert([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 2, 10))
console.log(convert([41, 42, 43], 256, 36))

/*
Produces:
[1, 2, 3, 4]
[10]
[2, 9, 0, 15, 9, 12, 7, 11, 15, 14, 9, 12, 8, 13, 0, 2, 1, 8]
[1, 2, 3, 7, 9, 4, 0, 0, 3, 9, 2, 8, 5, 3, 8, 0, 2, 7, 4, 8, 9, 9, 1, 2, 4, 2, 2, 3]
[1, 21, 29, 22, 3]
*/

Dies könnte wahrscheinlich stark geschrumpft sein, aber ich möchte es tatsächlich für ein kleines Nebenprojekt verwenden. Also habe ich es (etwas) lesbar gehalten und versucht, Variablen in Schach zu halten.

Stephen Perelson
quelle
Wie ist es Javascript? für jeden?
Hernán Eche
Keine Variablennamen über 3 Zeichen, veraltete for eachAnweisungen und atemberaubende Konstrukte wie d.length||e?d.push(e):0... Ist dies eine verschleierte Code-Herausforderung oder so? Sie könnten dasselbe mit einer verständlichen Syntax und besseren Leistungen schreiben.
@kuroineko Dies ist Code Golf. Was hast du erwartet? Sauberer, lesbarer Code mit aktuellen Standards? Ich habe nie behauptet, meine Antwort sei perfekt und ich würde sie sicherlich nicht wie in einem Produktionsprojekt verwenden.
Stephen Perelson
Nun, ich brauchte diesen Algorithmus tatsächlich aus irgendeinem Grund in JavaScript und musste ihn von Grund auf neu schreiben, wobei ich die Python-Lösung als Basis nahm. Ich schätze Ihren Beitrag, aber für praktische Zwecke war er meiner Meinung nach kaum nutzbar.
2

Mathematica

Keine Variablen definiert, keine Eingabe akzeptiert, solange sie in den Speicher passt.

f[i_, sb_, db_] := IntegerDigits[FromDigits[i, sb], db];

Probefahrt: 

f[{1,2,3,4},16,16]
f[{1,0},10,100]
f[{41,15,156,123,254,156,141,2,24},256,16]
f[{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
   1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
   1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},2,10]
f[{41,42,43},256,36]

aus

{1,2,3,4}
{10}
{2,9,0,15,9,12,7,11,15,14,9,12,8,13,0,2,1,8}
{1,2,3 7,9,4,0,0,3,9,2,8,5,3,8,0,2,7,4,8,9,9,1,2,4,2,2,3}
{1,21,29,22,3}
Dr. Belisarius
quelle
1

Scala:

def toDecimal (li: List[Int], base: Int) : BigInt = li match {                       
  case Nil => BigInt (0)                                                             
  case x :: xs => BigInt (x % base) + (BigInt (base) * toDecimal (xs, base)) }  

def fromDecimal (dec: BigInt, base: Int) : List[Int] =
  if (dec==0L) Nil else (dec % base).toInt :: fromDecimal (dec/base, base)

def x2y (value: List[Int], from: Int, to: Int) =
  fromDecimal (toDecimal (value.reverse, from), to).reverse

Testcode mit Tests:

def test (li: List[Int], from: Int, to: Int, s: String) = {
 val erg= "" + x2y (li, from, to)
 if (! erg.equals (s))
   println ("2dec: " + toDecimal (li, from) + "\n\terg: " + erg + "\n\texp: " + s)
}   

 test (List (1, 2, 3, 4), 16, 16, "List(1, 2, 3, 4)")
 test (List (1, 0), 10, 100, "List(10)")
 test (List (41, 15, 156, 123, 254, 156, 141, 2, 24), 256, 16, "List(2, 9, 0, 15, 9, 12, 7, 11, 15, 14, 9, 12, 8, 13, 0, 2, 1, 8)") 
 test (List (1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1), 
   2, 10, "List(1, 2, 3, 7, 9, 4, 0, 0, 3, 9, 2, 8, 5, 3, 8, 0, 2, 7, 4, 8, 9, 9, 1, 2, 4, 2, 2, 3)") 
 test (List (41, 42, 43), 256, 36, "List(1, 21, 29, 22, 3)")

Alle Tests bestanden.

Benutzer unbekannt
quelle
1

J, 109 105

Behandelt Tausende von Ziffern ohne Schweiß. Keine ganzen Zahlen verletzt!

e=:<.@%,.|~
t=:]`}.@.(0={.)@((e{:)~h=:+//.@)^:_
s=:[t[:+/;.0]*|.@>@(4 :'x((];~[t((*/e/)~>@{.)h)^:(<:#y))1')

Beispiele

256 16 s 41 15 156 123 254 156 141 2 24
2 9 0 15 9 12 7 11 15 14 9 12 8 13 0 2 1 8

256 36 s 41 42 43
1 21 29 22 3

16 16 s 1 2 3 4
1 2 3 4

256 46 s ?.1000$45
14 0 4 23 42 7 11 30 37 10 28 44 ...

time'256 46 s ?.3000$45'  NB. Timing conversion of 3000-vector.
1.96s

Es wird kürzer.

Eelvex
quelle
0

Smalltalk, 128

o:=[:n :b|n>b ifTrue:[(o value:n//b value:b),{n\\b}]ifFalse:[{n}]].
f:=[:a :f :t|o value:(a inject:0into:[:s :d|s*f+d])value:t].

Tests:

f value:#[41 15 156 123 254 156 141 2 24]
  value:256
  value:16. 
    -> #(2 9 0 15 9 12 7 11 15 14 9 12 8 13 0 2 1 8)

f value:#[1 2 3 4]
  value:16
  value:16.
    -> #(1 2 3 4)

f value:#[1 0]
  value:10
  value:100.
    -> #(10)

f value:#[1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1]
  value:2
  value:10.
    -> #(1 2 3 7 9 4 0 0 3 9 2 8 5 3 8 0 2 7 4 8 9 9 1 2 4 2 2 3)

f value:#[41 42 43]
  value:256
  value:36.
    -> #(1 21 29 22 3)

und für Ihre besondere Unterhaltung ( Herausforderung: Finden Sie heraus, was am Eingabewert so besonders ist ):

f value:#[3 193 88 29 73 27 40 245 35 194 58 189 243 91 104 156 144 128 0 0 0 0]
  value:256
  value:1000.
    -> #(1 405 6 117 752 879 898 543 142 606 244 511 569 936 384 0 0 0)
blabla999
quelle