La matematica dietro la conversione da qualsiasi base a qualsiasi base senza passare attraverso la base 10?

Ho esaminato la matematica dietro la conversione da qualsiasi base a qualsiasi base. Si tratta più di confermare i miei risultati che altro. Ho trovato quella che sembra essere la mia risposta su mathforum.org ma non sono ancora sicuro di averla bene. Ho la conversione da una base più grande a una base più piccola giù bene perché è semplicemente prendere la prima cifra moltiplicare per base che si desidera aggiungere la ripetizione della cifra successiva. Il mio problema si presenta quando si converte da una base più piccola a una base più grande. Quando lo fanno, parlano di come devi convertire la base più grande che desideri nella base più piccola che hai. Un esempio potrebbe andare dalla base 4 alla base 6, è necessario convertire il numero 6 in base 4 ottenendo 12. Quindi fai la stessa cosa che hai fatto durante la conversione da grande a piccolo. La difficoltà che ho con questo è che sembra che tu abbia bisogno di sapere quale sia un numero nell'altra base. Quindi avrei bisogno di sapere cosa c'è 6 nella base 4. Questo crea un grosso problema nella mia mente perché allora avrei bisogno di un tavolo. Qualcuno conosce un modo per farlo in un modo migliore.

Ho pensato che una conversione di base avrebbe aiutato, ma non riesco a trovare nulla che funzioni. E dal sito che ho trovato sembra che ti permetta di convertire da base a base senza passare attraverso la base 10 ma devi prima sapere come convertire il primo numero da base a base. Questo lo rende un po 'inutile.

I commentatori stanno dicendo che devo essere in grado di convertire una lettera in un numero. Se è così lo so già. Questo non è il mio problema comunque. Il mio problema è che per convertire una base grande in una base piccola devo prima convertire il numero base che ho nel numero base che voglio. Nel fare ciò, ho sconfitto lo scopo perché se ho la possibilità di convertire queste basi in altre basi ho già risolto il mio problema.

Modifica: ho capito come convertire da basi inferiori o uguali a 10 in altre basi inferiori o uguali a 10. Posso anche passare da una base maggiore di 10 a qualsiasi base inferiore o uguale a 10. Il problema inizia quando si converte da una base maggiore di 10 a un'altra base maggiore di 10. O passando da una base inferiore a 10 a una base maggiore di 10. Non ho bisogno di codice, ho solo bisogno della matematica di base che può essere applicato al codice.

Questa mi sembra una domanda basilare, quindi scusami se ti insegno un po '. Il punto più importante da imparare qui è che un numero non è la sua rappresentazione numerica . Un numero è un oggetto matematico astratto, mentre la sua rappresentazione numerica è una cosa concreta, vale a dire una sequenza di simboli su un foglio (o una sequenza di bit nella memoria di calcolo, o una sequenza di suoni che emetti quando comunichi un numero). Ciò che ti confonde è il fatto che non vedi mai un numero ma sempre la sua rappresentazione numerica. Quindi finisci per pensare che il numero sia la rappresentazione.

Pertanto, la domanda corretta da porre non è "come convertire da una base all'altra", ma piuttosto "come faccio a scoprire quale numero è rappresentato da una determinata stringa di cifre" e "come trovo la rappresentazione delle cifre di un dato il numero ".

Quindi produciamo due funzioni in Python, una per convertire una rappresentazione numerica in un numero e un'altra per fare il contrario. Nota: quando eseguiamo la funzione Python stamperà ovviamente sullo schermo il numero ottenuto nella base 10. Ma questo non significa che il computer mantenga i numeri nella base 10 (non lo è). È irrilevante il modo in cui il computer rappresenta i numeri.

def toDigits(n, b):
    """Convert a positive number n to its digit representation in base b."""
    digits = []
    while n > 0:
        digits.insert(0, n % b)
        n  = n // b
    return digits

def fromDigits(digits, b):
    """Compute the number given by digits in base b."""
    n = 0
    for d in digits:
        n = b * n + d
    return n

Proviamo questi:

>>> toDigits(42, 2)
[1, 0, 1, 0, 1, 0]
>>> toDigits(42, 3)
[1, 1, 2, 0]
>>> fromDigits([1,1,2,0],3)
42

Grazie alle funzioni di conversione, il problema si risolve facilmente:

def convertBase(digits, b, c):
    """Convert the digits representation of a number from base b to base c."""
    return toDigits(fromDigits(digits, b), c)

Un test:

>>> convertBase([1,1,2,0], 3, 2) 
[1, 0, 1, 0, 1, 0]

Nota: non abbiamo superato la rappresentazione in base 10! Abbiamo convertito la rappresentazione di base nel numero, quindi il numero in base c . Il numero non era in nessuna rappresentazione. (In realtà lo era, il computer doveva rappresentarlo in qualche modo, e lo rappresentava usando segnali elettrici e cose funky che si verificano nei chip, ma certamente quelli non erano 0 e 1.)$b$$c$

Penso che il modo migliore per capirlo sia discutere con un alieno (almeno per analogia).

La definizione è un numero nella base $x$$b$ significa che è una stringa di cifre < b .$x$$<b$

Esempi La stringa di cifre 10010011011 è un numero nella base 2, la stringa 68416841531 è un numero nella base 10, BADCAFE è un numero nella base 16.

Ora supponiamo che io sia cresciuto sul pianeta QUUX, dove a tutti viene insegnato a lavorare in per tutta la vita, e ti incontro che è abituato a basare b . Quindi mi mostri un numero e cosa devo fare? Ho bisogno di un modo per interpretarlo:$q$$b$

Definizione Posso interpretare un numero nella base (Nota: b è un numero nella base q ) con la seguente formula$b$$b$$q$

$$\begin{array}{rcl} [\![\epsilon]\!] &=& 0 \\ [\![\bar s d]\!] &=& [\![\bar s]\!] \times b + d \end{array}$$

dove indica la stringa vuota e ˉ s d indica una stringa che termina con la cifra d . Vedi la mia prova che l'aggiunta aggiunge per un'introduzione a questa notazione.$\epsilon$$\bar s d$$d$

Quindi cosa è successo qui? Mi hai dato un numero in base e l'ho interpretato in base q senza alcuna strana filosofia su cosa siano veramente i numeri.$b$$q$

Chiave La chiave di ciò è che e + I sono funzioni che operano su numeri q di base . Si tratta di semplici algoritmi definiti ricorsivamente su numeri q di base (stringhe di cifre).$\times$$+$$q$$q$

---

Questo può sembrare un po 'astratto dal momento che ho usato variabili piuttosto che numeri reali in tutto. Quindi supponiamo che tu sia una creatura base 13 (usando i simboli ) e io sono abituato a base 7 (che è molto più sensibile) usando i simboli α β γ δ ρ ζ ξ .$0123456789XYZ$$\alpha \beta \gamma \delta \rho \zeta \xi$

Quindi ho visto il tuo alfabeto e l'ho tabulato così:

$$\begin{array}{|c|c||c|c||c|c|} \hline 0 & \alpha & 1 & \beta & 2 & \gamma \\ 3 & \delta & 4 & \rho & 5 & \zeta \\ 6 & \xi & 7 & \beta\alpha & 8 & \beta\beta \\ 9 & \beta\gamma & X & \beta\delta & Y & \beta\rho \\ & & Z & \beta\zeta & & \\ \hline \end{array}$$

$\beta\xi$

$60Z8$

$$\begin{array}{rcl} [\![60Z8]\!] &=& \xi (\beta\xi)^3 + \alpha (\beta\xi)^2 + \beta \zeta (\beta\xi) + \beta\beta \\ \end{array}$$

$\beta \zeta \times \beta\xi$

Tabella di moltiplicazione Quux

$$\begin{array}{|c|cccccc|} \hline \\ \times & \beta & \gamma & \delta & \rho & \zeta & \xi \\ \hline \beta & \beta & \gamma & \delta & \rho & \zeta & \xi \\ \gamma & \gamma & \rho & \xi & \beta\beta & \beta\delta & \beta\zeta \\ \delta & \delta & \xi & \beta\gamma & \beta\zeta & \gamma\beta & \gamma\rho \\ \rho & \rho & \beta\beta & \beta\zeta & \gamma\gamma & \gamma\xi & \delta\delta \\ \zeta & \zeta & \beta\delta & \gamma\beta & \gamma\xi & \delta\rho & \rho\gamma \\ \xi & \xi & \beta\zeta & \gamma\rho & \delta\delta & \rho\gamma & \zeta\beta \\ \beta\alpha & \beta\alpha & \gamma\alpha & \delta\alpha & \rho\alpha & \zeta\alpha & \xi\alpha \\ \hline \end{array}$$

$\beta \zeta \times \beta\xi$

$$\begin{array}{ccc} & \beta & \zeta \\ \times & \beta & \xi \\ \hline & \xi & \gamma \\ & \rho & \\ \beta & \zeta & \\ \hline \delta & \beta & \gamma \\ \gamma & & \\ \end{array}$$

quindi sono arrivato così lontano

$$\begin{array}{rcl} [\![60Z8]\!] &=& \xi (\beta\xi)^3 + \alpha (\beta\xi)^2 + \beta \zeta (\beta\xi) + \beta\beta \\ &=& \xi (\beta\xi)^3 + \alpha (\beta\xi)^2 + \delta \beta \gamma + \beta\beta \\ \end{array}$$

Ora devo eseguire l'aggiunta usando l'algoritmo che è stato menzionato prima:

$$\begin{array}{ccc} \delta & \beta & \gamma \\ & \beta & \beta \\ \hline \delta & \gamma & \delta \\ \end{array}$$

così

$$\begin{array}{rcl} [\![60Z8]\!] &=& \xi (\beta\xi)^3 + \alpha (\beta\xi)^2 + \beta \zeta (\beta\xi) + \beta\beta \\ &=& \xi (\beta\xi)^3 + \alpha (\beta\xi)^2 + \delta \beta \gamma + \beta\beta \\ &=& \xi (\beta\xi)^3 + \alpha (\beta\xi)^2 + \delta \gamma \delta \\ \end{array}$$

$$[\![60Z8]\!] = \zeta\delta\xi\gamma\rho.$$

---

$q$$b$$q$

Questo è solo un refactoring (Python 3) del codice di Andrej . Nel codice di Andrej i numeri sono rappresentati attraverso un elenco di cifre (scalari), mentre nei seguenti codici i numeri sono rappresentati attraverso un elenco di simboli presi da una stringa personalizzata :

def v2r(n, base): # value to representation
    """Convert a positive number to its digit representation in a custom base."""
    b = len(base)
    digits = ''
    while n > 0:
        digits = base[n % b] + digits
        n  = n // b
    return digits

def r2v(digits, base): # representation to value
    """Compute the number represented by string 'digits' in a custom base."""
    b = len(base)
    n = 0
    for d in digits:
        n = b * n + base[:b].index(d)
    return n

def b2b(digits, base1, base2):
    """Convert the digits representation of a number from base1 to base2."""
    return v2r(r2v(digits, base1), base2)

Per eseguire una conversione da valore a rappresentazione in una base personalizzata:

>>> v2r(64,'01')
'1000000'
>>> v2r(64,'XY')
'YXXXXXX'
>>> v2r(12340,'ZABCDEFGHI') # decimal base with custom symbols
'ABCDZ'

Per eseguire una conversione dalla rappresentazione (in una base personalizzata) al valore:

>>> r2v('100','01')
4
>>> r2v('100','0123456789') # standard decimal base
100
>>> r2v('100','01_whatevr') # decimal base with custom symbols
100
>>> r2v('100','0123456789ABCDEF') # standard hexadecimal base
256
>>> r2v('100','01_whatevr-jklmn') # hexadecimal base with custom symbols
256

Per eseguire una conversione di base da una base personalizzata a un'altra:

>>> b2b('1120','012','01')
'101010'
>>> b2b('100','01','0123456789')
'4'
>>> b2b('100','0123456789ABCDEF','01')
'100000000'

L'operazione fondamentale della conversione di base è l' toDigits()operazione della risposta @AndrejBauer. Tuttavia, per realizzarlo non è necessario creare un numero nella rappresentazione interna dei numeri, che è fondamentalmente una conversione da e verso la rappresentazione di base 2. È possibile effettuare le operazioni necessarie nella rappresentazione di base originale.

Quindi il primo passo è eseguire ripetute operazioni di divisione del modulo

def convertBase(n,original_base,destination_base):
    digits = []    
    while not is_zero(n):
        digits.insert(0,modulo_div(n,original_base,destination_base))
    return digits

Poiché la rappresentazione interna è composta da cifre, è necessario eseguire una funzione specilaizzata per verificare zero

def is_zero(n):
    for d in n:
        if d != 0:
            return False
    return True

Alla fine si deve fare l'operazione modulo_div che è in realtà la divisione standard per base di destinazione come abbiamo imparato a scuola.

def modulo_div(n,original_base,destination_base):
    carry = 0
    for i in range(len(n)):
        d = n[i]
        d+=original_base*carry 
        carry = d%destination_base 
        d=(d//destination_base)
        n[i] = d
        #print(i,d,carry)
    return carry

solo un test di verifica per verificare che il codice sia corretto:

print(convertBase([1,1,2,0], 3, 2))
#[1, 0, 1, 0, 1, 0]

print(convertBase([1, 0, 1, 0, 1, 0], 2, 3))
#[1, 1, 2, 0]

Conosco un modo semplice per eseguire la conversione di base che non richiede un programma per computer. È definendo un modo per convertire da qualsiasi base a base 2 e viceversa e quindi convertendo da una base a un'altra base convertendo prima dalla prima base alla base 2, quindi convertendo dalla base 2 all'altra base. 2 è così facile da moltiplicare o dividere per in qualsiasi base.

Per convertire da qualsiasi base a base 2, tutto ciò che devi fare è riconoscere che per qualsiasi numero, se prendi la sua notazione di base 2 e inizi da 0 e poi per ogni cifra nell'ordine da sinistra a destra doppia se quella cifra è zero e raddoppiare di aggiungere 1 se quella cifra è 1, si arriva a quel numero stesso. Ora dato quel numero in qualsiasi base, puoi dividere per 2 in quella base per ottenere un quoziente e il resto. Se il resto è 1, l'ultima cifra binaria è 1 e se il resto è 0, l'ultima cifra binaria è 0. Dividi nuovamente per 2. Se il resto è 1, la seconda ultima cifra è 1 e se il resto è 0, la seconda ultima cifra è 0 e così via fino a ottenere un quoziente di 0.

Per convertire dalla base 2 a qualsiasi base, tutto ciò che devi fare è in quella base, iniziare da 0, quindi per ogni cifra binaria che va da sinistra a destra, raddoppia in quella base se quella cifra è 0 e raddoppia quindi aggiungi 1 in quella base se quella cifra è 1.

È possibile convertire dalla base n alla base 10 senza alcuna conversione in una base intermedia.

Per convertire dalla base n alla base 9, ad esempio, si prende l'algoritmo per la conversione in base 10 e si sostituisce "10" con "9". Lo stesso per qualsiasi altra base.