Matemaattinen muuntaminen mistä tahansa tukikohdasta mihin tahansa tukikohtaan käymättä läpi perustan 10?

Tämä näyttää minulle hyvin perustavanlaatuiselta kysymykseltä, joten anteeksi, jos luennoin teitä vähän. Tärkein asia, jonka sinun on opittava tässä, on se, että luku ei ole sen numeroesitys . Luku on abstrakti matemaattinen esine, kun taas sen numeroesitys on konkreettinen asia, nimittäin symbolisarja paperilla (tai bittisarja laskentamuistissa tai äänisarja, jonka teet, kun välität numeron). Hämmentävää on tosiasia, että et koskaan näe numeroa, mutta aina sen numeroesitys. Joten päädyt ajattelemaan, että luku on edustus.

Siksi oikea kysymys ei ole ” miten muunnetaan tukiasemasta toiseen ” pikemminkin ” miten saan selville, mitä lukua edustaa annettu numerosarja ” ja ” kuinka löydän tietyn luvun numeroesityksen ”.

Tehkäämme siis kaksi funktiota Pythonissa, yksi lukuesityksen muuntamiseksi numero ja toinen päinvastaisesta toiminnasta. Huomaa: kun suoritamme funktion, Python tietysti tulostaa näytölle numeron, jonka se sai tukiasemaan 10. Mutta tämä ei tarkoita, että tietokone pitää numeroita perustassa 10 (se ei ole ”t”). Ei ole merkitystä kuinka tietokone edustaa numeroita.

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 

Testaa nämä:

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

Muunnostoiminnoilla asennettu ongelma ratkaistaan helposti:

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

Testi :

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

Huomaa: teimme ei läpäise perusasetuksen 10 esitystä! Muunnimme perusesityksen $ b $ numeroksi ja sitten numeron perustaksi $ c $ . Numero ei ollut ei missään esityksessä. (Itse asiassa se oli, tietokoneen piti edustaa sitä jotenkin, ja se edusti sitä käyttämällä sähköisiä signaaleja ja funky tavaraa, joka tapahtuu siruina, mutta varmasti ne w Ei 0 ”s” ja 1 ”s.)

Kommentit

• Tämä ei ’ vakuuttaa minä 100%. Itse asiassa muunnit numeron jossakin esityksessä (vaikka voit väittää, ettet tiedä mikä se on), koska tietokoneet eivät ole platonisia matemaatikkoja eikä algoritmisi voi muuntaa mielivaltaista numerosarjaa $ b_1 $: ksi $ b_2 $: ksi; se voi muuntaa vain betonikoneen edustamat sekvenssit. Python on hurmaavan joustava; C ei olisi ollut niin anteeksiantava. On täysin kelvollinen kysyä kuinka muuntaa mielivaltaiset merkkijonot $ b_1 $: sta $ b_2 $: ksi; tämä on kuitenkin mahdollista vain lineaarisessa ajassa lukuun ottamatta tiettyjä perusyhdistelmiä (esim. 2 < – > 16)
• On pätevä esittää kysymys, mutta löytää oikea vastaus on parasta olla tietoinen siitä, että numerot ovat abstrakteja kokonaisuuksia.
• Tämä välittää numeron tukiaseman 10 esityksen kautta, koska fromDigits palauttaa perustan 10 luvun.
• @anorton: Ei, ehdottomasti se ei . Python tulostaa näytöllä olevan numeron 10-numeroisena esityksenä, mutta itse numeroa ei tallenneta tällä tavalla. Yritän saada selville, että ei ole merkitystä kuinka numerot toteutetaan Pythonissa. Ei se mitään. Ainoa asia on, että he käyttäytyvät kuin numerot.
• Lopuksi yleinen ratkaisu mihin tahansa tukikohtaan eikä rajoitu vain tiettyihin käyttötapauksiin, alle 36: n tukiasemiin tai tapauksiin, joissa voit löytää tarpeeksi yksilöllisiä symboleja. .

Mielestäni paras tapa ymmärtää tämä on keskustelu ulkomaalaisen kanssa (ainakin kuten (analogia).

Määritelmä $ x $ on luku perustassa $ b $ tarkoittaa, että $ x $ on merkkijono merkkijonoja $ < b $.

Esimerkkejä Numeroiden merkkijono 10010011011 on numero kannassa 2, merkkijono 68416841531 on numero kannassa 10, BADCAFE on numero kannassa 16.

Nyt Oletetaan, että kasvoin QUUX-planeetalla, jossa kaikkia opetetaan työskentelemään $ q $: ssa koko elämänsä ajan, ja tapaan sinut, joka on tottunut perustamaan $ b $: n. Joten näytät minulle numeron, ja mitä teen? Tarvitsen tapan tulkita se:

Määritelmä Voin tulkita luku kohdassa $ b $ (Huomaa: $ b $ on luku luvussa $ q $) seuraavan kaavan avulla:

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

missä $ \ epsilon $ tarkoittaa tyhjää merkkijonoa ja $ \ bar sd $ merkitsee merkkijonoa, joka päättyy numeroon $ d $. Katso todistus siitä, että lisäys lisää , joka on johdanto tälle merkinnälle.

Joten mitä täällä tapahtui? Olet antanut minulle numeron in $ b $ ja olen tulkinnut sen base $ q $: ksi ilman outoa filosofiaa siitä, mitkä numerot todella ovat.

Key Avain tähän on se, että minulla olevat $ \ times $ ja $ + $ ovat funktioita, jotka toimivat $ q $ -numeroilla. Nämä ovat yksinkertaisia algoritmeja, jotka on määritelty rekursiivisesti $ q $ -numeroilla (merkkijonot numeroa).

Tämä saattaa tuntua hieman abstraktilta, koska olen käyttänyt muuttujia todellisten numeroiden sijaan kaikkialla. Oletetaan siis, että olet perus 13 olento (käyttäen symboleja $ 0123456789XYZ $) ja minä olen käytetään perustamaan 7 (mikä on paljon järkevämpää) käyttämällä symboleja $ \ alpha \ beta \ gamma \ delta \ rho \ zeta \ xi $.

Joten olen nähnyt aakkosesi ja taulukoin sen seuraavasti:

$$ \ 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} $$

Joten tiedän, että työskentelet pohjana $ \ beta \ xi $, ja tiedän, mikä tukiasema 7 merkitsee sinua kirjoitus vastaa.

Jos keskustelimme fysiikasta ja kerroit minulle perusvakioista (sano) 60Z8 $, joten minun on tulkittava tämä:

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

Joten aloitan kertomalla $ \ beta \ zeta \ kertaa \ beta \ xi $, mutta tämä on minulle luokka-asteen juttua, muistan:

Quux-kertolasku

$$ \ 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} $$

niin etsin $ \ beta \ zeta \ times \ beta \ xi $, mitä teen:

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

joten olen päässyt niin pitkälle

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

Nyt minun on suoritettava lisäys käyttämällä algoritmia, joka mainittiin aiemmin:

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

joten

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

ja jatkan näin saan $$ [\! [60Z8] \!] = \ zeta \ delta \ xi \ gamma \ rho. $$

Sisään Yhteenveto: Jos minulla on oma käsitykseni luvusta perustason $ q $ numerosarjojen suhteen, niin minulla on tapa tulkita numerosi base $ b $: sta omaan järjestelmääni perustuen aritmeettisiin perusoperaatioihin – jotka toimivat luontaisesti base $ q $.

Kommentit

• No, se oli paljon mutkikkaita viivoja. Kuinka saisin tietokoneen tekemään niin?
• @Griffin, luulen, että kysyt tämän (outon) kysymyksen ennenaikaisesti. Valitset ohjelmointikielen ja kirjoitat algoritmin lisäys- ja kertolaskuihin perus-q-numeroille (edustettuna numeroiden luetteloina) ja määrität sitten toiminnon, jolla tulkitaan perus-b-numerot perus-q-numeroiksi ja tulkitaan perus-b-numerot perus-q-numeroiksi. Olen ’ selittänyt kaiken tämän.
• Asia on, että tunnen käsitteen, jota yrität kuvata. Minun ongelmani on, että tietokoneeni ei ’ voi käyttää mutkikkaita viivojasi.
• Tiedän mitä selitit, mutta sen toteuttaminen käytännössä on paljon vaikeampi. Näiden numeroiden määritteleminen ei ole ’ t yhtä helppoa.
• Miksi pudotit alfanumeron merkittävimpään sijaintiin? Koska 6 = & xi ;, Wouldn ’ t 7 = & alfa; & alfa ;?

Tämä on refactoring (Python 3) Andrej ”s -koodista. Vaikka Andrej: n koodinumerot on esitetty numeroiden (skalaarien) luettelon kautta, seuraavissa koodinumeroissa on luettelo mielivaltaisista symboleista , joka on otettu mukautetusta merkkijonosta:

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) 

Muunnoksen suorittaminen arvosta edustukseksi mukautetussa alustassa:

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

Muunnoksen suorittaminen esityksestä (mukautetussa pohjassa) arvoksi :

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

Perusmuunnoksen suorittaminen asiakastukiasemasta toiseen:

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

Kommentit

• Tervetuloa sivustolle ja kiitos osallistumisestasi. Hyvin optimoidun lähdekoodin tuottaminen ei kuitenkaan ole ’ t, mistä tämä sivusto oikeastaan on. Andrej ’ -koodi tekee käsitteistä selkeät, mitä hänen vastauksessaan tarvitaan, mutta koodin parantaminen sen ulkopuolella on ohjelmoinnin eikä tietokone tiede .
• @DavidRicherby Olen osittain samaa mieltä, mutta tämä kommentti oli liian pitkä kommentille, ja sen paras paikka olla jonnekin lähellä Andrej ’ vastausta, että ’ siksi lähetin sen tänne. Joka tapauksessa, jos luulet sen olevan ’ parempi, voisin muuntaa sen kommentiksi, jossa on linkki koodiin, mutta ei ’ ei ylimääräinen purismi?
• Huolimatta @David ’ s ” site-purist ” vastalauseet, löysin vastauksestasi hyödyllisen, koska siinä korostetaan sitä tosiasiaa, että kyseiset perustat voidaan ajatella abstraktimmin ” aakkosina ” mielivaltaisia, eripituisia symboleja – eikä rajoitu tavalliseen 2 – 36 merkin alueeseen. Voit itse asiassa pitää tavuvirtoja 256 peruslukun ” -numeroina ”.

Perusmuunnoksen perusoperaatio on @AndrejBauer -vastauksen toDigits() -operaatio. Sen tekemiseksi ei kuitenkaan ole tarvetta luoda numeroa numeroiden sisäiseen esitykseen, mikä on pohjimmiltaan muunnos 2-esityksestä ja perusesitykseen.Voit tehdä tarvittavat toiminnot alkuperäisessä pohjaesityksessä.

Ensimmäinen askel on siis tehdä toistuva moduulijako-operaatio

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 

Koska sisäinen esitys on numeroa, on tehtävä erityinen nollan testaustoiminto

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

Lopulta on tehtävä modulo_div-operaatio, joka on itse asiassa standardijako määränpään mukaan, kuten opimme koulussa.

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 

vain testitarkistus varmistaaksesi, että koodi on oikea:

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] 

Kommentit

• Kiitos lähettämisestä, mutta huomioi, että emme ’ ole koodaussivusto, joten iso koodilohko ei ole ’ ei sovi tähän vastauksena. Varsinkin kun kysymys nimenomaisesti sanoo, ” En tarvitse ’ ei tarvitse koodia, tarvitsen vain sen takana olevan perusmatematiikan. ”
• @DavidRicherby Yritin lisätä tekstiä.
• Kiitos. Ja näen siellä ’ saavan paljon koodia tällä sivulla huolimatta siitä, mitä sanoin!
• @David: FWIW, mielestäni tämä vastaa OP: ta ’ -kysymys parhaiten, koska se näyttää kuinka muuntaa kahden perustan välillä muuntamatta ensin alkuperäisen esitys joksikin välimuodoksi ja sitten muuntamalla se kohdetukikohdaksi.
• Hieno kokeilu, mutta d on edelleen tukikohdassa 10, joten itse asiassa purat pienemmän osan n: stä muuntamalla sen tukikohdaksi 10, sitten muuntamalla sen halutuksi emäkseksi ja keräämällä ne lopulliseen tulokseen.

Tiedän helpon tavan tehdä perusmuunnos, joka ei vaadi tietokoneohjelmaa. Se määritellään tapa muuntaa mistä tahansa pohjasta pohjaan 2 ja päinvastoin ja peittää sitten yhdestä alustasta toiseen pohjaan muuntamalla ensin ensimmäisestä pohjasta tukikohtaan 2 ja sitten muuntamalla tukikohdasta 2 toiseen tukikohtaan. 2 on niin helppo kertoa tai jakaa millä tahansa alustalla.

Jos haluat muuntaa minkä tahansa perustan tukikohdaksi 2, sinun tarvitsee vain tunnistaa, että mihin tahansa numeroon, jos otat sen pohja 2 -merkinnän ja aloitat 0: sta ja sitten jokaiselle numerolle järjestyksessä vasemmalta oikealle kaksinkertainen, jos kyseinen luku on nolla, ja kaksinkertainen kuin lisäämällä 1, jos kyseinen numero on 1, pääset itse siihen numeroon. Nyt kun tämä luku on annettu missä tahansa emäksessä, voit jakaa osuuden 2: lla saadaksesi osamäärän ja loput. Jos loppuosa on 1, viimeinen binäärinumero on 1 ja jos loppuosa on 0, viimeinen binäärinumero on 0. Jaa taas 2: lla. Jos loppuosa on 1, toinen viimeinen numero on 1 ja jos loppu on 0, toinen viimeinen numero on 0 ja niin edelleen, kunnes saat osamäärän 0.

Muuntaa tukiasemasta 2 mihin tahansa Pohja, kaikki mitä sinun tarvitsee tehdä, on tuossa perustassa, aloita 0: sta, sitten kaksinkertaista jokaiselle vasemmalta oikealle menevälle binääriluvulle kaksinkertainen tuohon pohjaan, jos kyseinen luku on 0, ja kaksinkertaista sitten lisätä 1 siihen pohjaan, jos kyseinen luku on 1.

kommentit

• 2 is so easy to multiply or divide by in any base. En ’ t katso, että parittomille perustoille, jotka ovat enemmän kuin yksi mistä tahansa kahden voimasta (aluksi 11 ja 13).